diff --git a/.github/workflows/daily-dev-prerelease.yml b/.github/workflows/daily-dev-prerelease.yml
index 8765b6d96..7a28765db 100644
--- a/.github/workflows/daily-dev-prerelease.yml
+++ b/.github/workflows/daily-dev-prerelease.yml
@@ -230,9 +230,6 @@ jobs:
             "Kun-${DEV_VERSION}-mac-x64.zip"
             "Kun-${DEV_VERSION}-win-x64.exe"
             "Kun-${DEV_VERSION}-linux-x86_64.AppImage"
-            "latest-mac.yml"
-            "latest.yml"
-            "latest-linux.yml"
           )
 
           for file in "${required[@]}"; do
diff --git a/kun/README.md b/kun/README.md
index c1c2748cf..f63d06110 100644
--- a/kun/README.md
+++ b/kun/README.md
@@ -187,6 +187,7 @@ Shape:
           "enabled": true,
           "transport": "stdio",
           "command": "npx",
+          "cwd": "/path/to/workspace",
           "args": ["-y", "@modelcontextprotocol/server-github"],
           "env": { "GITHUB_TOKEN": "<github-token>" },
           "trustScope": "workspace",
@@ -453,7 +454,8 @@ stay local to one thread, leave it as a pinned constraint.
   server `enabled` flag, transport-specific fields (`command` for
   `stdio`, `url` for HTTP/SSE), `trustedWorkspaceRoots` for
   workspace-scoped servers, and `/v1/runtime/tools` for redacted
-  `lastError` diagnostics.
+  `lastError` diagnostics. Stdio servers can set `cwd`; if omitted,
+  workspace-scoped servers start in the first trusted workspace root.
 - Web tools are missing: `capabilities.web.enabled` must be true and
   at least one of `fetchEnabled` / `searchEnabled` must be true.
   Built-in fetch handles HTTP(S) pages; search may still be
diff --git a/kun/README.zh-CN.md b/kun/README.zh-CN.md
index 12e296e59..7458fd6a3 100644
--- a/kun/README.zh-CN.md
+++ b/kun/README.zh-CN.md
@@ -176,6 +176,7 @@ Kun 使用 JSON 配置文件管理运行时行为，避免重建后重配或硬
           "enabled": true,
           "transport": "stdio",
           "command": "npx",
+          "cwd": "/path/to/workspace",
           "args": ["-y", "@modelcontextprotocol/server-github"],
           "env": { "GITHUB_TOKEN": "<github-token>" },
           "trustScope": "workspace",
@@ -391,7 +392,7 @@ SSE 使用 `id: <seq>`、`event: <kind>` 与 `data:`。新连接可通过 `since
 
 ## 故障排查
 
-- MCP 不出现：检查 `capabilities.mcp.enabled`、服务器的 `enabled` 开关、`transport` 字段（`stdio` 需检查 `command`，HTTP/SSE 需检查 `url`）、workspace 级服务器的 `trustedWorkspaceRoots`，以及 `/v1/runtime/tools` 的 `lastError`。
+- MCP 不出现：检查 `capabilities.mcp.enabled`、服务器的 `enabled` 开关、`transport` 字段（`stdio` 需检查 `command`，HTTP/SSE 需检查 `url`）、workspace 级服务器的 `trustedWorkspaceRoots`，以及 `/v1/runtime/tools` 的 `lastError`。stdio 服务器可配置 `cwd`；未配置时，workspace 级服务器会在第一个受信任工作区根目录中启动。
 - Web 工具不可用：检查 `capabilities.web.enabled`，并确保 `fetchEnabled` / `searchEnabled` 至少一项为 true。内置 provider 负责抓取 HTTP(S) 页面，搜索可能因未实现 provider 而不可用。
 - 图片上传失败：检查 `maxImageBytes`、`maxImageDimension`、`allowedMimeTypes` 与文本 fallback 的大小限制。纯文本模型需要足够小的 base64 文本 fallback。
 - 记忆未注入：确认 `capabilities.memory` 为 true，`/v1/memory/diagnostics` 显示正常，作用域与工作区匹配且未被禁用；再看 `lastInjectedIds`。
diff --git a/kun/src/adapters/in-memory-approval-gate.ts b/kun/src/adapters/in-memory-approval-gate.ts
index 5614511ca..39a0f40f6 100644
--- a/kun/src/adapters/in-memory-approval-gate.ts
+++ b/kun/src/adapters/in-memory-approval-gate.ts
@@ -26,6 +26,7 @@ export class InMemoryApprovalGate implements ApprovalGate {
   decide(approvalId: string, decision: 'allow' | 'deny', reason?: string): boolean {
     const approval = this.approvals.get(approvalId)
     if (!approval) return false
+    if (approval.status !== 'pending') return false
     const resolved = resolveApprovalRequest(approval, decision, reason)
     this.approvals.set(approvalId, resolved)
     const resolver = this.resolvers.get(approvalId)
diff --git a/kun/src/adapters/model/compat-model-client.streaming-tool-calls.test.ts b/kun/src/adapters/model/compat-model-client.streaming-tool-calls.test.ts
new file mode 100644
index 000000000..1f846adae
--- /dev/null
+++ b/kun/src/adapters/model/compat-model-client.streaming-tool-calls.test.ts
@@ -0,0 +1,243 @@
+import { describe, expect, it } from 'vitest'
+import { CompatModelClient } from './compat-model-client.js'
+import type { ModelCapabilityMetadata } from '../../contracts/capabilities.js'
+import type { ModelRequest, ModelStreamChunk } from '../../ports/model-client.js'
+
+// These tests exercise the REAL streaming SSE path (`streamSse` /
+// `consumeStreamPayload`), which had no coverage before. They lock in the fix
+// for the silent tool-call drop: the chat_completions branch only finalized on
+// `finish_reason === 'tool_calls'`, so a provider ending with 'stop', 'length',
+// or a bare `[DONE]` while a tool call was pending dropped it entirely.
+
+type CapturedCall = { url: string; body: Record<string, unknown> }
+
+function sseResponse(frames: string[]): Response {
+  const encoder = new TextEncoder()
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const frame of frames) controller.enqueue(encoder.encode(frame))
+      controller.close()
+    }
+  })
+  return new Response(stream, {
+    status: 200,
+    headers: { 'content-type': 'text/event-stream' }
+  })
+}
+
+function frame(payload: unknown): string {
+  return `data: ${JSON.stringify(payload)}\n\n`
+}
+
+function streamingFetch(frames: string[], calls: CapturedCall[] = []): typeof fetch {
+  return (async (url: string, init: { body: string }) => {
+    calls.push({ url: String(url), body: JSON.parse(init.body) as Record<string, unknown> })
+    return sseResponse(frames)
+  }) as unknown as typeof fetch
+}
+
+function capability(overrides: Partial<ModelCapabilityMetadata> = {}): (model: string) => ModelCapabilityMetadata {
+  return (model) => ({
+    id: model,
+    inputModalities: ['text'],
+    outputModalities: ['text'],
+    supportsToolCalling: true,
+    messageParts: ['text'],
+    ...overrides
+  })
+}
+
+function request(overrides: Partial<ModelRequest> = {}): ModelRequest {
+  return {
+    threadId: 't1',
+    turnId: 'u1',
+    model: 'test-model',
+    systemPrompt: 'You are a helpful assistant.',
+    prefix: [],
+    history: [],
+    tools: [{ name: 'edit', description: 'edit a file', inputSchema: { type: 'object' } }],
+    abortSignal: new AbortController().signal,
+    ...overrides
+  }
+}
+
+async function drain(iterable: AsyncIterable<ModelStreamChunk>): Promise<ModelStreamChunk[]> {
+  const chunks: ModelStreamChunk[] = []
+  for await (const chunk of iterable) chunks.push(chunk)
+  return chunks
+}
+
+function toolCallCompletes(
+  chunks: ModelStreamChunk[]
+): Extract<ModelStreamChunk, { kind: 'tool_call_complete' }>[] {
+  return chunks.filter(
+    (c): c is Extract<ModelStreamChunk, { kind: 'tool_call_complete' }> =>
+      c.kind === 'tool_call_complete'
+  )
+}
+
+function completed(chunks: ModelStreamChunk[]): Extract<ModelStreamChunk, { kind: 'completed' }> {
+  const last = chunks.at(-1)
+  if (!last || last.kind !== 'completed') throw new Error('stream did not end with completed')
+  return last
+}
+
+function chatToolDelta(d: { index: number; id?: string; name?: string; args?: string }): string {
+  const fn: Record<string, unknown> = {}
+  if (d.name !== undefined) fn.name = d.name
+  if (d.args !== undefined) fn.arguments = d.args
+  const call: Record<string, unknown> = { index: d.index, function: fn }
+  if (d.id !== undefined) call.id = d.id
+  return frame({ choices: [{ index: 0, delta: { tool_calls: [call] } }] })
+}
+
+function chatFinish(reason: string): string {
+  return frame({ choices: [{ index: 0, delta: {}, finish_reason: reason }] })
+}
+
+// A two-part chat_completions tool-call stream. The args split across deltas so
+// the test also covers index-based continuation accumulation.
+function chatToolCallDeltas(): string[] {
+  return [
+    chatToolDelta({ index: 0, id: 'call_1', name: 'edit', args: '{"path":' }),
+    chatToolDelta({ index: 0, args: '"a.txt"}' })
+  ]
+}
+
+function makeClient(fetchImpl: typeof fetch, modelCapabilities?: (model: string) => ModelCapabilityMetadata) {
+  return new CompatModelClient({
+    baseUrl: 'https://provider.example/v1/chat/completions',
+    apiKey: 'sk-test',
+    model: 'test-model',
+    endpointFormat: 'chat_completions',
+    fetchImpl,
+    ...(modelCapabilities ? { modelCapabilities } : {})
+  })
+}
+
+describe('CompatModelClient streaming tool-call finalization', () => {
+  it('emits a tool call when chat_completions ends with finish_reason "tool_calls" (no double emit)', async () => {
+    const frames = [...chatToolCallDeltas(), chatFinish('tool_calls'), 'data: [DONE]\n\n']
+    const chunks = await drain(makeClient(streamingFetch(frames)).stream(request()))
+    const calls = toolCallCompletes(chunks)
+    expect(calls).toHaveLength(1)
+    expect(calls[0].toolName).toBe('edit')
+    expect(calls[0].arguments).toEqual({ path: 'a.txt' })
+    expect(completed(chunks).stopReason).toBe('tool_calls')
+  })
+
+  it('recovers a tool call the provider mislabeled as finish_reason "stop"', async () => {
+    // Regression: previously dropped silently because finishReason !== 'tool_calls'.
+    const frames = [...chatToolCallDeltas(), chatFinish('stop'), 'data: [DONE]\n\n']
+    const chunks = await drain(makeClient(streamingFetch(frames)).stream(request()))
+    const calls = toolCallCompletes(chunks)
+    expect(calls).toHaveLength(1)
+    expect(calls[0].arguments).toEqual({ path: 'a.txt' })
+    // A recovered call means it was really a tool-call turn.
+    expect(completed(chunks).stopReason).toBe('tool_calls')
+  })
+
+  it('recovers a tool call when the stream ends with a bare [DONE] and no finish_reason', async () => {
+    const frames = [...chatToolCallDeltas(), 'data: [DONE]\n\n']
+    const chunks = await drain(makeClient(streamingFetch(frames)).stream(request()))
+    expect(toolCallCompletes(chunks)).toHaveLength(1)
+    expect(completed(chunks).stopReason).toBe('tool_calls')
+  })
+
+  it('surfaces truncated arguments as __raw (instead of dropping) on finish_reason "length"', async () => {
+    // Only the first (incomplete) delta arrives, then the model hits its cap.
+    const frames = [
+      chatToolDelta({ index: 0, id: 'call_1', name: 'edit', args: '{"path":' }),
+      chatFinish('length'),
+      'data: [DONE]\n\n'
+    ]
+    const chunks = await drain(makeClient(streamingFetch(frames)).stream(request()))
+    const calls = toolCallCompletes(chunks)
+    expect(calls).toHaveLength(1)
+    expect(calls[0].arguments).toHaveProperty('__raw', '{"path":')
+    // Truncation stays visible as 'length' so the loop can warn the user.
+    expect(completed(chunks).stopReason).toBe('length')
+  })
+
+  it('does not emit a tool call when no tool deltas were streamed', async () => {
+    const frames = [
+      frame({ choices: [{ index: 0, delta: { content: 'hello' } }] }),
+      chatFinish('stop'),
+      'data: [DONE]\n\n'
+    ]
+    const chunks = await drain(makeClient(streamingFetch(frames)).stream(request()))
+    expect(toolCallCompletes(chunks)).toHaveLength(0)
+    expect(completed(chunks).stopReason).toBe('stop')
+  })
+
+  it('recovers an Anthropic Messages tool_use block cut off before content_block_stop', async () => {
+    const frames = [
+      frame({ type: 'message_start', message: { usage: { input_tokens: 10 } } }),
+      frame({ type: 'content_block_start', index: 0, content_block: { type: 'tool_use', id: 'toolu_1', name: 'edit' } }),
+      frame({ type: 'content_block_delta', index: 0, delta: { type: 'input_json_delta', partial_json: '{"path":"a.txt"}' } }),
+      // No content_block_stop — stream is cut off, then the message ends.
+      frame({ type: 'message_delta', delta: { stop_reason: 'max_tokens' } }),
+      frame({ type: 'message_stop' })
+    ]
+    const client = new CompatModelClient({
+      baseUrl: 'https://provider.example/anthropic',
+      apiKey: 'sk-test',
+      model: 'test-model',
+      endpointFormat: 'messages',
+      fetchImpl: streamingFetch(frames)
+    })
+    const chunks = await drain(client.stream(request()))
+    const calls = toolCallCompletes(chunks)
+    expect(calls).toHaveLength(1)
+    expect(calls[0].toolName).toBe('edit')
+    expect(calls[0].arguments).toEqual({ path: 'a.txt' })
+  })
+})
+
+describe('CompatModelClient output-token cap', () => {
+  function captureMessagesBody(
+    cap: (model: string) => ModelCapabilityMetadata,
+    req: Partial<ModelRequest> = {}
+  ): Promise<Record<string, unknown>> {
+    const calls: CapturedCall[] = []
+    const frames = [frame({ type: 'message_start', message: { usage: {} } }), frame({ type: 'message_stop' })]
+    const client = new CompatModelClient({
+      baseUrl: 'https://provider.example/anthropic',
+      apiKey: 'sk-test',
+      model: 'test-model',
+      endpointFormat: 'messages',
+      fetchImpl: streamingFetch(frames, calls),
+      modelCapabilities: cap
+    })
+    return drain(client.stream(request(req))).then(() => calls[0].body)
+  }
+
+  it('gives reasoning (anthropic-thinking) models a large messages max_tokens default', async () => {
+    const body = await captureMessagesBody(
+      capability({ reasoning: { supportedEfforts: ['auto', 'off'], defaultEffort: 'auto', requestProtocol: 'anthropic-thinking' } }),
+      { reasoningEffort: 'auto' }
+    )
+    expect(body.max_tokens).toBe(32_768)
+  })
+
+  it('uses the smaller messages default for non-reasoning models', async () => {
+    const body = await captureMessagesBody(capability())
+    expect(body.max_tokens).toBe(8_192)
+  })
+
+  it('lets a per-model maxOutputTokens capability override the default', async () => {
+    const body = await captureMessagesBody(
+      capability({
+        maxOutputTokens: 5_000,
+        reasoning: { supportedEfforts: ['auto', 'off'], defaultEffort: 'auto', requestProtocol: 'anthropic-thinking' }
+      }),
+      { reasoningEffort: 'auto' }
+    )
+    expect(body.max_tokens).toBe(5_000)
+  })
+
+  it('lets an explicit request.maxTokens win over everything', async () => {
+    const body = await captureMessagesBody(capability({ maxOutputTokens: 5_000 }), { maxTokens: 1_234 })
+    expect(body.max_tokens).toBe(1_234)
+  })
+})
diff --git a/kun/src/adapters/model/compat-model-client.tool-images.test.ts b/kun/src/adapters/model/compat-model-client.tool-images.test.ts
index 5ed5c193b..07cebd33f 100644
--- a/kun/src/adapters/model/compat-model-client.tool-images.test.ts
+++ b/kun/src/adapters/model/compat-model-client.tool-images.test.ts
@@ -62,6 +62,56 @@ function screenshotHistory(): TurnItem[] {
   return [toolCall, toolResult]
 }
 
+// Two parallel tool calls in a single assistant turn, each with its own
+// tool_result — the shape that triggered issue #574 (each tool_result must
+// land in the SAME user message under the Anthropic Messages protocol).
+function parallelToolHistory(): TurnItem[] {
+  const base = { turnId: 'u2', threadId: 't1', status: 'completed' as const, createdAt: '2026-01-01T00:00:00.000Z' }
+  const callA: TurnItem = {
+    ...base,
+    id: 'pc1',
+    role: 'assistant',
+    kind: 'tool_call',
+    toolName: 'read_file',
+    callId: 'call_a',
+    toolKind: 'command_execution',
+    arguments: { path: 'a.txt' }
+  }
+  const callB: TurnItem = {
+    ...base,
+    id: 'pc2',
+    role: 'assistant',
+    kind: 'tool_call',
+    toolName: 'read_file',
+    callId: 'call_b',
+    toolKind: 'command_execution',
+    arguments: { path: 'b.txt' }
+  }
+  const resultA: TurnItem = {
+    ...base,
+    id: 'pr1',
+    role: 'tool',
+    kind: 'tool_result',
+    toolName: 'read_file',
+    callId: 'call_a',
+    toolKind: 'command_execution',
+    isError: false,
+    output: { kind: 'text', text: 'contents-a' }
+  }
+  const resultB: TurnItem = {
+    ...base,
+    id: 'pr2',
+    role: 'tool',
+    kind: 'tool_result',
+    toolName: 'read_file',
+    callId: 'call_b',
+    toolKind: 'command_execution',
+    isError: false,
+    output: { kind: 'text', text: 'contents-b' }
+  }
+  return [callA, callB, resultA, resultB]
+}
+
 function request(model: string): ModelRequest {
   return {
     threadId: 't1',
@@ -75,6 +125,13 @@ function request(model: string): ModelRequest {
   }
 }
 
+function parallelRequest(model: string): ModelRequest {
+  return {
+    ...request(model),
+    history: parallelToolHistory()
+  }
+}
+
 async function drain(iterable: AsyncIterable<ModelStreamChunk>): Promise<void> {
   for await (const _ of iterable) void _
 }
@@ -160,4 +217,41 @@ describe('CompatModelClient tool-result image forwarding', () => {
     // Metadata (the screen size) still reaches the model as text.
     expect(body).toContain('computer_screenshot')
   })
+
+  it('merges parallel tool_results into one user message (anthropic messages)', async () => {
+    // Regression for issue #574: parallel tool calls must answer with a
+    // single user message holding both tool_result blocks, not two separate
+    // user messages (which trips Anthropic's tool_result-immediately-after
+    // rule and yields HTTP 400 on compat providers).
+    const calls: CapturedCall[] = []
+    const client = new CompatModelClient({
+      baseUrl: 'https://api.example.com/v1',
+      apiKey: 'sk',
+      model: 'claude-parallel',
+      endpointFormat: 'messages',
+      nonStreaming: true,
+      fetchImpl: fakeFetch(calls),
+      modelCapabilities: caps(false, 'messages')
+    })
+    await drain(client.stream(parallelRequest('claude-parallel')))
+    expect(calls[0].url).toMatch(/\/messages$/)
+    const messages = calls[0].body.messages as Array<{
+      role: string
+      content: Array<{ type: string; tool_use_id?: string }>
+    }>
+    const toolResultUserMessages = messages.filter(
+      (m) =>
+        m.role === 'user' &&
+        Array.isArray(m.content) &&
+        m.content.some((b) => b.type === 'tool_result')
+    )
+    // Exactly ONE user message carries the tool_result blocks.
+    expect(toolResultUserMessages).toHaveLength(1)
+    const merged = toolResultUserMessages[0]!
+    const toolResultIds = merged.content
+      .filter((b) => b.type === 'tool_result')
+      .map((b) => b.tool_use_id)
+      .sort()
+    expect(toolResultIds).toEqual(['call_a', 'call_b'])
+  })
 })
diff --git a/kun/src/adapters/model/compat-model-client.ts b/kun/src/adapters/model/compat-model-client.ts
index 611f8b72a..79b718a40 100644
--- a/kun/src/adapters/model/compat-model-client.ts
+++ b/kun/src/adapters/model/compat-model-client.ts
@@ -143,7 +143,13 @@ type StreamReadResult =
   | { kind: 'error'; message: string }
 
 const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 45_000
-const DEFAULT_MESSAGES_MAX_TOKENS = 4096
+// Anthropic Messages requires an explicit `max_tokens`. The old 4096 default
+// was far too small for reasoning models: their thinking tokens are drawn from
+// the SAME output budget, so a long think left almost nothing for the tool
+// call, truncating its arguments into invalid JSON. Give thinking models much
+// more headroom; a per-model `maxOutputTokens` capability still overrides both.
+const DEFAULT_MESSAGES_MAX_TOKENS = 8192
+const DEFAULT_MESSAGES_REASONING_MAX_TOKENS = 32_768
 
 /**
  * Multi-provider HTTP model client.
@@ -368,6 +374,23 @@ export class CompatModelClient implements ModelClient {
     return this.config.modelCapabilities?.(model).reasoning
   }
 
+  /** Per-model output-token cap from capability metadata, if declared. */
+  private maxOutputTokensFor(model: string): number | undefined {
+    return this.config.modelCapabilities?.(model).maxOutputTokens
+  }
+
+  /**
+   * Resolves the output-token cap for a request: an explicit request value
+   * wins, then the per-model capability override, then the supplied default.
+   */
+  private resolveMaxTokens(
+    request: ModelRequest,
+    model: string,
+    fallback?: number
+  ): number | undefined {
+    return request.maxTokens ?? this.maxOutputTokensFor(model) ?? fallback
+  }
+
   private async postChatCompletion(
     url: string,
     headers: Record<string, string>,
@@ -480,8 +503,9 @@ export class CompatModelClient implements ModelClient {
       stream,
       messages: splitToolImageMessagesForOpenAi(messages)
     }
-    if (request.maxTokens !== undefined) {
-      body.max_tokens = request.maxTokens
+    const maxTokens = this.resolveMaxTokens(request, model)
+    if (maxTokens !== undefined) {
+      body.max_tokens = maxTokens
     }
     if (request.temperature !== undefined) {
       body.temperature = request.temperature
@@ -536,8 +560,9 @@ export class CompatModelClient implements ModelClient {
       stream,
       input: messagesToResponsesInput(splitToolImageMessagesForOpenAi(messages))
     }
-    if (request.maxTokens !== undefined) {
-      body.max_output_tokens = request.maxTokens
+    const maxTokens = this.resolveMaxTokens(request, model)
+    if (maxTokens !== undefined) {
+      body.max_output_tokens = maxTokens
     }
     if (request.temperature !== undefined) {
       body.temperature = request.temperature
@@ -576,10 +601,24 @@ export class CompatModelClient implements ModelClient {
       this.modelReasoningFor(model)?.requestProtocol === 'anthropic-thinking'
     )
     applyAnthropicCacheControl(converted.messages)
+    // Thinking tokens are billed against the same output budget, so reasoning
+    // models need a much larger default cap or their tool-call arguments get
+    // truncated. A per-model `maxOutputTokens` (or an explicit request value)
+    // still wins over these defaults.
+    const reasoning = this.modelReasoningFor(model)
+    const resolvedEffort =
+      reasoning?.requestProtocol === 'anthropic-thinking'
+        ? resolveReasoningEffort(request.reasoningEffort, reasoning)
+        : undefined
+    const thinkingEnabled = resolvedEffort !== undefined && resolvedEffort !== 'off'
     const body: Record<string, unknown> = {
       model,
       stream,
-      max_tokens: request.maxTokens ?? DEFAULT_MESSAGES_MAX_TOKENS,
+      max_tokens: this.resolveMaxTokens(
+        request,
+        model,
+        thinkingEnabled ? DEFAULT_MESSAGES_REASONING_MAX_TOKENS : DEFAULT_MESSAGES_MAX_TOKENS
+      ),
       messages: converted.messages
     }
     const systemText = request.responseFormat === 'json_object'
@@ -937,6 +976,27 @@ export class CompatModelClient implements ModelClient {
       yield { kind: 'error', message: 'request was aborted' }
       return
     }
+    // Safety net: finalize any tool call whose arguments finished streaming but
+    // was never emitted because the stream ended without a per-call "done"
+    // signal. The chat_completions branch only finalizes on
+    // `finish_reason === 'tool_calls'`, so a provider that ends with 'stop',
+    // 'length', or a bare `[DONE]` while a tool call is still pending would
+    // otherwise DROP the call silently. Truncated arguments surface here as
+    // `{ __raw }` (a tool error the model can react to) instead of vanishing.
+    let flushedPendingToolCall = false
+    for (const [callId, pending] of pendingArguments) {
+      if (!pending.name) continue
+      if (completedToolCalls.has(callId)) continue
+      flushedPendingToolCall = true
+      completedToolCalls.add(callId)
+      yield {
+        kind: 'tool_call_complete',
+        callId,
+        toolName: pending.name,
+        arguments: this.parseToolArguments(pending.arguments || '{}')
+      }
+    }
+    pendingArguments.clear()
     if (usage) yield { kind: 'usage', usage }
     stopReason = ((): ModelStopReason => {
       switch (finishReason) {
@@ -947,7 +1007,9 @@ export class CompatModelClient implements ModelClient {
         case 'error':
           return 'error'
         default:
-          return 'stop'
+          // A recovered tool call means this was really a tool-call turn the
+          // provider mislabeled (e.g. finish_reason 'stop' or bare `[DONE]`).
+          return flushedPendingToolCall ? 'tool_calls' : 'stop'
       }
     })()
     yield { kind: 'completed', stopReason }
@@ -1614,7 +1676,24 @@ function messagesToAnthropic(
           if (image) blocks.push({ type: 'image', source: image })
         }
       }
-      out.push({ role: 'user', content: blocks })
+      // Parallel tool calls arrive as N consecutive `role: 'tool'` messages.
+      // Anthropic requires every tool_use from a single assistant turn to be
+      // answered by tool_result blocks inside ONE user message — emitting N
+      // separate user messages trips "tool_use ids were found without
+      // tool_result blocks immediately after" on compat providers. Real user
+      // turns never carry a tool_result block, so its presence marks the run
+      // we are still folding into.
+      const last = out[out.length - 1]
+      if (
+        last &&
+        last.role === 'user' &&
+        Array.isArray(last.content) &&
+        (last.content as AnthropicContentBlock[]).some((b) => b.type === 'tool_result')
+      ) {
+        last.content.push(...blocks)
+      } else {
+        out.push({ role: 'user', content: blocks })
+      }
       continue
     }
     const content = chatContentToAnthropicContent(message.content)
diff --git a/kun/src/adapters/tool/builtin-file-tools.ts b/kun/src/adapters/tool/builtin-file-tools.ts
index 07a14585a..2b9a89dcb 100644
--- a/kun/src/adapters/tool/builtin-file-tools.ts
+++ b/kun/src/adapters/tool/builtin-file-tools.ts
@@ -60,7 +60,7 @@ export function createWriteLocalTool(_options: WriteLocalToolOptions = {}): Loca
       if (!rawPath.trim() || content == null) {
         return { output: { error: 'path and content are required' }, isError: true }
       }
-      const { absolutePath, relativePath } = resolveWorkspacePath(rawPath, context)
+      const { absolutePath, relativePath } = await resolveWorkspacePath(rawPath, context)
       assertCanWritePath(absolutePath, context)
       return withFileMutationQueue(absolutePath, async () => {
         await mkdirOp(dirname(absolutePath))
@@ -118,7 +118,7 @@ export function createEditLocalTool(_options: EditLocalToolOptions = {}): LocalT
       if (!rawPath.trim() || edits.length === 0) {
         return { output: { error: 'path and at least one edit are required' }, isError: true }
       }
-      const { absolutePath, relativePath } = resolveWorkspacePath(rawPath, context)
+      const { absolutePath, relativePath } = await resolveWorkspacePath(rawPath, context)
       assertCanWritePath(absolutePath, context)
       return withFileMutationQueue(absolutePath, async () => {
         const rawSource = await readFileOp(absolutePath)
diff --git a/kun/src/adapters/tool/builtin-lsp-tool.ts b/kun/src/adapters/tool/builtin-lsp-tool.ts
index 39c2bdf58..9205ffbb3 100644
--- a/kun/src/adapters/tool/builtin-lsp-tool.ts
+++ b/kun/src/adapters/tool/builtin-lsp-tool.ts
@@ -111,7 +111,7 @@ export function createLspLocalTool(): LocalTool {
           return { output: { error: `Unknown operation: ${operation}` }, isError: true }
         }
 
-        const { absolutePath, workspaceRoot } = resolveWorkspacePath(rawPath, context)
+        const { absolutePath, workspaceRoot } = await resolveWorkspacePath(rawPath, context)
         const server = findLanguageServerForFile(absolutePath)
         if (!server) {
           const supported = listLanguageServers()
diff --git a/kun/src/adapters/tool/builtin-read-tool.ts b/kun/src/adapters/tool/builtin-read-tool.ts
index 125c30f98..d3c5c8817 100644
--- a/kun/src/adapters/tool/builtin-read-tool.ts
+++ b/kun/src/adapters/tool/builtin-read-tool.ts
@@ -49,7 +49,7 @@ export function createReadLocalTool(options: ReadLocalToolOptions = {}): LocalTo
           isError: true
         }
       }
-      const { absolutePath, relativePath } = resolveWorkspacePath(rawPath, context)
+      const { absolutePath, relativePath } = await resolveWorkspacePath(rawPath, context)
       await statOp(absolutePath)
       const fileBuffer = await readFileOp(absolutePath)
       const classification = getReadClassification(absolutePath, context.workspace)
diff --git a/kun/src/adapters/tool/builtin-search-tools.ts b/kun/src/adapters/tool/builtin-search-tools.ts
index 9cf2fa70d..a07f36bab 100644
--- a/kun/src/adapters/tool/builtin-search-tools.ts
+++ b/kun/src/adapters/tool/builtin-search-tools.ts
@@ -43,7 +43,7 @@ export function createLsLocalTool(options: LsLocalToolOptions = {}): LocalTool {
     execute: async (args, context) => withToolBoundary(async () => {
       const rawPath = typeof args.path === 'string' && args.path.trim() ? args.path : '.'
       const limit = normalizePositiveInteger(args.limit, options.defaultLimit ?? DEFAULT_LIST_LIMIT)
-      const { workspaceRoot: root, absolutePath, relativePath } = resolveWorkspacePath(rawPath, context)
+      const { workspaceRoot: root, absolutePath, relativePath } = await resolveWorkspacePath(rawPath, context)
       const targetStat = await statOp(absolutePath)
       if (!targetStat.isDirectory()) {
         return {
@@ -95,7 +95,7 @@ export function createFindLocalTool(options: FindLocalToolOptions = {}): LocalTo
       if (!pattern) return { output: { error: 'pattern is required' }, isError: true }
       const rawPath = typeof args.path === 'string' && args.path.trim() ? args.path : '.'
       const limit = normalizePositiveInteger(args.limit, options.defaultLimit ?? DEFAULT_FIND_LIMIT)
-      const { workspaceRoot: root, absolutePath, relativePath } = resolveWorkspacePath(rawPath, context)
+      const { workspaceRoot: root, absolutePath, relativePath } = await resolveWorkspacePath(rawPath, context)
       const matcher = globToRegExp(pattern.includes('/') ? pattern : `**/${pattern}`)
       if (options.operations?.glob) {
         const matches = await options.operations.glob({ pattern, path: absolutePath, limit })
@@ -213,7 +213,7 @@ export function createGrepLocalTool(options: GrepLocalToolOptions = {}): LocalTo
         ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags)
         : new RegExp(pattern, flags)
       const globMatcher = glob ? globToRegExp(glob.includes('/') ? glob : `**/${glob}`) : null
-      const { workspaceRoot: root, absolutePath, relativePath } = resolveWorkspacePath(rawPath, context)
+      const { workspaceRoot: root, absolutePath, relativePath } = await resolveWorkspacePath(rawPath, context)
       if (options.operations?.search) {
         const matches = await options.operations.search({
           pattern,
diff --git a/kun/src/adapters/tool/builtin-tool-utils.symlink.test.ts b/kun/src/adapters/tool/builtin-tool-utils.symlink.test.ts
new file mode 100644
index 000000000..a3270f08d
--- /dev/null
+++ b/kun/src/adapters/tool/builtin-tool-utils.symlink.test.ts
@@ -0,0 +1,76 @@
+import { mkdtemp, mkdir, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import type { ToolHostContext } from '../../ports/tool-host.js'
+import { resolveWorkspacePath } from './builtin-tool-utils.js'
+
+function context(workspace: string): ToolHostContext {
+  return {
+    threadId: 'thread_symlink',
+    turnId: 'turn_symlink',
+    workspace,
+    approvalPolicy: 'always',
+    sandboxMode: 'workspace-write',
+    abortSignal: new AbortController().signal,
+    awaitApproval: async () => 'allow'
+  }
+}
+
+describe('resolveWorkspacePath symlink escape', () => {
+  let base: string
+  let workspace: string
+  let outside: string
+
+  beforeEach(async () => {
+    base = await mkdtemp(join(tmpdir(), 'kun-symlink-'))
+    workspace = join(base, 'ws')
+    outside = join(base, 'outside')
+    await mkdir(workspace, { recursive: true })
+  })
+
+  afterEach(async () => {
+    await rm(base, { recursive: true, force: true })
+  })
+
+  it('rejects a DANGLING symlink whose target is outside the workspace (write/create case)', async () => {
+    // `outside` deliberately does NOT exist — realpath() reports ENOENT for the
+    // link exactly as for a missing file. This is the hole the fix closes.
+    await symlink(outside, join(workspace, 'evil'))
+    await expect(resolveWorkspacePath('evil', context(workspace))).rejects.toThrow(/escapes the workspace root/)
+  })
+
+  it('rejects a path that traverses through a dangling symlink to an outside dir', async () => {
+    await symlink(outside, join(workspace, 'dlink'))
+    await expect(resolveWorkspacePath('dlink/sub/new.txt', context(workspace))).rejects.toThrow(
+      /escapes the workspace root/
+    )
+  })
+
+  it('rejects an EXISTING symlink that points outside the workspace', async () => {
+    await mkdir(outside, { recursive: true })
+    await symlink(outside, join(workspace, 'link'))
+    await expect(resolveWorkspacePath('link/file.txt', context(workspace))).rejects.toThrow(
+      /escapes the workspace root/
+    )
+  })
+
+  it('allows a dangling symlink that stays inside the workspace', async () => {
+    // Link target is absent but in-workspace — a legitimate write/create target.
+    await symlink(join(workspace, 'data', 'note.txt'), join(workspace, 'good'))
+    const resolved = await resolveWorkspacePath('good', context(workspace))
+    expect(resolved.absolutePath).toBe(join(workspace, 'good'))
+  })
+
+  it('allows creating a new nested file with no symlinks involved', async () => {
+    const resolved = await resolveWorkspacePath('sub/dir/new.txt', context(workspace))
+    expect(resolved.absolutePath).toBe(join(workspace, 'sub', 'dir', 'new.txt'))
+  })
+
+  it('allows reading an existing in-workspace file', async () => {
+    await writeFile(join(workspace, 'real.txt'), 'hi')
+    const resolved = await resolveWorkspacePath('real.txt', context(workspace))
+    expect(resolved.absolutePath).toBe(join(workspace, 'real.txt'))
+    expect(resolved.relativePath).toBe('real.txt')
+  })
+})
diff --git a/kun/src/adapters/tool/builtin-tool-utils.ts b/kun/src/adapters/tool/builtin-tool-utils.ts
index 4099c155f..4d8907e47 100644
--- a/kun/src/adapters/tool/builtin-tool-utils.ts
+++ b/kun/src/adapters/tool/builtin-tool-utils.ts
@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs'
-import { readFile, readdir, stat } from 'node:fs/promises'
+import { lstat, readFile, readdir, readlink, realpath, stat } from 'node:fs/promises'
 import { spawn, spawnSync, type ChildProcess } from 'node:child_process'
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
 import type { ToolHostContext } from '../../ports/tool-host.js'
@@ -57,24 +57,98 @@ export function workspaceRoot(workspace: string): string {
   return isAbsolute(workspace) ? resolve(workspace) : resolve(process.cwd(), workspace)
 }
 
-export function resolveWorkspacePath(inputPath: string, context: ToolHostContext): {
+export async function resolveWorkspacePath(inputPath: string, context: ToolHostContext): Promise<{
   workspaceRoot: string
   absolutePath: string
   relativePath: string
-} {
+}> {
   const root = workspaceRoot(context.workspace)
-  const absolutePath = isAbsolute(inputPath) ? resolve(inputPath) : resolve(root, inputPath)
-  const relativePath = relative(root, absolutePath)
-  if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+  const lexicalAbsolutePath = isAbsolute(inputPath) ? resolve(inputPath) : resolve(root, inputPath)
+  const resolvedRoot = await safeRealpath(root)
+  if (resolvedRoot === null) {
+    // Workspace root itself does not exist; nothing to anchor the escape
+    // check against. This is distinct from an actual escape (handled below).
+    throw new Error(`workspace root does not exist: ${root}`)
+  }
+  const resolvedAbsolute = await resolveSymlinkSafe(lexicalAbsolutePath)
+  const resolvedRelative = relative(resolvedRoot, resolvedAbsolute)
+  if (resolvedRelative === '..' || resolvedRelative.startsWith(`..${sep}`) || isAbsolute(resolvedRelative)) {
     throw new Error(`path escapes the workspace root: ${inputPath}`)
   }
+  // Return LEXICAL paths to callers. The realpath-resolved pair is only used
+  // for the escape check above; downstream code (subprocess cwd, display
+  // paths, language-server init) expects the user-facing workspace path,
+  // which on symlinked roots (e.g. macOS `/tmp` -> `/private/tmp`) would
+  // otherwise diverge from what the user typed and break display layers.
   return {
     workspaceRoot: root,
-    absolutePath,
-    relativePath: relativePath || '.'
+    absolutePath: lexicalAbsolutePath,
+    relativePath: relative(root, lexicalAbsolutePath) || '.'
   }
 }
 
+async function safeRealpath(target: string): Promise<string | null> {
+  try {
+    return await realpath(target)
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code
+    if (code === 'ENOENT') return null
+    if (code === 'EACCES' || code === 'ELOOP' || code === 'ENOTDIR') return null
+    throw error
+  }
+}
+
+// Whether `target` is itself a symbolic link, without following it. Returns
+// false when the entry is absent or cannot be stat-ed (treated as "not a link"
+// — the escape check still anchors against the nearest existing ancestor).
+async function isSymlink(target: string): Promise<boolean> {
+  try {
+    return (await lstat(target)).isSymbolicLink()
+  } catch {
+    return false
+  }
+}
+
+async function resolveSymlinkSafe(lexicalPath: string, depth = 0): Promise<string> {
+  // Guard against symlink loops (dangling link A -> B -> A never resolves).
+  if (depth > 40) {
+    throw new Error(`too many symbolic links resolving: ${lexicalPath}`)
+  }
+  const direct = await safeRealpath(lexicalPath)
+  if (direct !== null) return direct
+  // Target doesn't fully resolve — either a genuinely missing path (write/create
+  // case) or a *dangling* symlink whose target is absent. `realpath` reports
+  // both as ENOENT, so we must walk the components ourselves: anchor on the
+  // nearest existing ancestor, but if a non-resolving component is actually a
+  // symlink, follow it explicitly so the redirection is reflected in the escape
+  // check. Re-anchoring a dangling symlink lexically (the old behavior) let a
+  // planted link like `<ws>/evil -> /etc/passwd` (target absent) pass as an
+  // in-workspace path and escape on the subsequent write.
+  const segments: string[] = []
+  let current = lexicalPath
+  // Guard against pathological component counts.
+  for (let i = 0; i < 128 && current !== dirname(current); i += 1) {
+    const resolved = await safeRealpath(current)
+    if (resolved !== null) {
+      return segments.length > 0 ? resolve(resolved, ...segments) : resolved
+    }
+    if (await isSymlink(current)) {
+      // Dangling (or otherwise non-resolving) symlink: follow its target so the
+      // redirection is reflected, then re-resolve the target plus the suffix
+      // collected below this component.
+      const linkTarget = await readlink(current)
+      const resolvedParent = (await safeRealpath(dirname(current))) ?? dirname(current)
+      const followed = isAbsolute(linkTarget) ? resolve(linkTarget) : resolve(resolvedParent, linkTarget)
+      const rejoined = segments.length > 0 ? resolve(followed, ...segments) : followed
+      return resolveSymlinkSafe(rejoined, depth + 1)
+    }
+    segments.unshift(basename(current))
+    current = dirname(current)
+  }
+  // Nothing on the path exists; treat as escape.
+  throw new Error(`path escapes the workspace root: ${lexicalPath}`)
+}
+
 export function isBinaryBuffer(buffer: Buffer): boolean {
   const sample = buffer.subarray(0, Math.min(buffer.length, 4096))
   for (const byte of sample) {
diff --git a/kun/src/adapters/tool/capability-registry.ts b/kun/src/adapters/tool/capability-registry.ts
index 65552bb6f..ecabc78a4 100644
--- a/kun/src/adapters/tool/capability-registry.ts
+++ b/kun/src/adapters/tool/capability-registry.ts
@@ -116,6 +116,7 @@ export class CapabilityRegistry {
 
   private canUseProvider(provider: ToolProviderPolicy, context?: ToolHostContext): boolean {
     if (!provider.enabled || !provider.available) return false
+    if (context?.blockedProviderIds?.includes(provider.id)) return false
     const allowed = context?.allowedProviderIds
     if (allowed && !allowed.includes(provider.id)) return false
     return true
@@ -125,6 +126,7 @@ export class CapabilityRegistry {
     if (isPlanModeContext(context) && !PLAN_MODE_ALLOWED_TOOL_NAMES.has(toolName)) {
       return false
     }
+    if (context?.blockedToolNames?.includes(toolName)) return false
     const allowed = context?.allowedToolNames
     return !allowed || allowed.includes(toolName)
   }
diff --git a/kun/src/adapters/tool/delegation-tool-provider.ts b/kun/src/adapters/tool/delegation-tool-provider.ts
index 5e91553db..f4000ed3b 100644
--- a/kun/src/adapters/tool/delegation-tool-provider.ts
+++ b/kun/src/adapters/tool/delegation-tool-provider.ts
@@ -4,7 +4,9 @@ import { LocalToolHost } from './local-tool-host.js'
 
 export function buildDelegationToolProviders(runtime: DelegationRuntime | undefined): CapabilityToolProvider[] {
   if (!runtime) return []
-  const profiles = runtime.listProfiles()
+  // Only subagent/all roles are delegation targets; primary-only personas
+  // are for starting a session, not for delegate_task.
+  const profiles = runtime.listProfiles().filter((profile) => profile.mode !== 'primary')
   const profileNames = profiles.map((profile) => profile.name)
   return [{
     id: 'delegation',
@@ -18,13 +20,17 @@ export function buildDelegationToolProviders(runtime: DelegationRuntime | undefi
         inputSchema: {
           type: 'object',
           properties: {
-            label: { type: 'string', description: 'Short label for this subagent run.' },
+            label: { type: 'string', description: 'A 2-4 word name for this subagent, shown in the UI as its title (e.g. "审查登录流程", "fix failing test", "greet user"). ALWAYS provide it so the user can tell subagents apart, especially when delegating several in parallel. Prefer a distinct label per call.' },
             prompt: { type: 'string', description: 'The task for the child agent.' },
             workspace: { type: 'string' },
             model: { type: 'string', description: 'Override the child model. Defaults to the profile model or server default.' },
             profile: profileNames.length
               ? { type: 'string', enum: profileNames, description: 'Subagent role to apply (model, preamble, tool policy).' }
-              : { type: 'string', description: 'Subagent role to apply (model, preamble, tool policy).' }
+              : { type: 'string', description: 'Subagent role to apply (model, preamble, tool policy).' },
+            detach: {
+              type: 'boolean',
+              description: 'Fire-and-forget. The call returns immediately with a queued/running record; the child keeps executing in the background and can be checked via diagnostics or aborted from the GUI.'
+            }
           },
           required: ['prompt'],
           additionalProperties: false
@@ -41,6 +47,7 @@ export function buildDelegationToolProviders(runtime: DelegationRuntime | undefi
             workspace: typeof args.workspace === 'string' ? args.workspace : context.workspace,
             ...(typeof args.model === 'string' ? { model: args.model } : {}),
             ...(typeof args.profile === 'string' ? { profile: args.profile } : {}),
+            ...(args.detach === true ? { detach: true } : {}),
             signal: context.abortSignal
           })
           return {
@@ -66,7 +73,7 @@ export function buildDelegationToolProviders(runtime: DelegationRuntime | undefi
 
 function buildDelegateTaskDescription(
   runtime: DelegationRuntime,
-  profiles: { name: string; toolPolicy: string; model?: string }[]
+  profiles: { name: string; mode: string; toolPolicy: string; model?: string; providerId?: string; description?: string }[]
 ): string {
   const lines = [
     'Run a bounded child agent task and return its summary.',
@@ -75,7 +82,7 @@ function buildDelegateTaskDescription(
   ]
   if (profiles.length) {
     const summary = profiles
-      .map((profile) => `${profile.name} (${profile.toolPolicy}${profile.model ? `, ${profile.model}` : ''})`)
+      .map((profile) => `${profile.name} (${profile.toolPolicy}${profile.model ? `, ${profile.model}` : ''}${profile.providerId ? ` @${profile.providerId}` : ''})${profile.description ? ` — ${profile.description}` : ''}`)
       .join('; ')
     lines.push(`Available profiles: ${summary}.`)
   }
diff --git a/kun/src/adapters/tool/mcp-tool-provider.ts b/kun/src/adapters/tool/mcp-tool-provider.ts
index d02a2a32e..99220f734 100644
--- a/kun/src/adapters/tool/mcp-tool-provider.ts
+++ b/kun/src/adapters/tool/mcp-tool-provider.ts
@@ -463,13 +463,16 @@ async function createSdkMcpClient(serverId: string, server: McpServerConfig): Pr
 
 function createTransport(server: McpServerConfig): Transport {
   switch (server.transport) {
-    case 'stdio':
+    case 'stdio': {
+      const cwd = resolveMcpServerCwd(server)
       return new StdioClientTransport({
         command: server.command ?? '',
         args: server.args,
         env: buildMcpStdioEnvironment(server.env),
+        ...(cwd ? { cwd } : {}),
         stderr: 'pipe'
       })
+    }
     case 'streamable-http':
       return new StreamableHTTPClientTransport(new URL(server.url ?? ''), {
         requestInit: { headers: server.headers }
@@ -482,6 +485,14 @@ function createTransport(server: McpServerConfig): Transport {
   }
 }
 
+export function resolveMcpServerCwd(server: McpServerConfig): string | undefined {
+  if (server.transport !== 'stdio') return undefined
+  const configured = server.cwd?.trim()
+  if (configured) return configured
+  if (server.trustScope !== 'workspace') return undefined
+  return server.trustedWorkspaceRoots.map((root) => root.trim()).find(Boolean)
+}
+
 function fetchWithHeaders(headers: Record<string, string>): typeof fetch {
   return (input, init) => {
     const mergedHeaders = new Headers(init?.headers)
diff --git a/kun/src/adapters/tool/mcp-tool-search.ts b/kun/src/adapters/tool/mcp-tool-search.ts
index 255396601..20989f486 100644
--- a/kun/src/adapters/tool/mcp-tool-search.ts
+++ b/kun/src/adapters/tool/mcp-tool-search.ts
@@ -319,7 +319,16 @@ function createMcpSearchTools(options: McpSearchProviderOptions): LocalTool[] {
 }
 
 function trustedRecords(options: McpSearchProviderOptions, context: ToolHostContext): McpSearchCatalogRecord[] {
-  return options.state.records.filter((record) => options.isServerTrusted(record.server, context.workspace))
+  const blocked = context.blockedProviderIds
+  return options.state.records.filter((record) =>
+    options.isServerTrusted(record.server, context.workspace)
+    // Honor the per-turn provider deny-list (e.g. a subagent's blockedMcpServers).
+    // In search mode the per-server `mcp:<id>` provider is never registered, so
+    // CapabilityRegistry.canUseProvider can't gate it — this is the single
+    // chokepoint shared by mcp_search/mcp_describe/mcp_call, so filtering here
+    // blocks enumeration, schema disclosure, AND execution of a blocked server.
+    && !blocked?.includes(`mcp:${record.serverId}`)
+  )
 }
 
 function resolveTrustedRecord(
diff --git a/kun/src/adapters/tool/skill-tool-provider.ts b/kun/src/adapters/tool/skill-tool-provider.ts
index b24b265bd..b76c44b0d 100644
--- a/kun/src/adapters/tool/skill-tool-provider.ts
+++ b/kun/src/adapters/tool/skill-tool-provider.ts
@@ -15,7 +15,7 @@ import type { SkillRuntime } from '../../skills/skill-runtime.js'
 export function buildSkillToolProviders(
   skillRuntime: SkillRuntime | undefined
 ): CapabilityToolProvider[] {
-  if (!skillRuntime || skillRuntime.count() === 0) return []
+  if (!skillRuntime || !skillRuntime.enabled()) return []
   return [{
     id: 'skill',
     kind: 'skill',
@@ -43,10 +43,10 @@ export function buildSkillToolProviders(
           additionalProperties: false
         },
         policy: 'auto',
-        execute: async (args) => {
+        execute: async (args, context) => {
           const skillId = typeof args.skill_id === 'string' ? args.skill_id : ''
           if (!skillId.trim()) return { output: { error: 'skill_id is required' }, isError: true }
-          const result = skillRuntime.loadSkillById(skillId)
+          const result = await skillRuntime.loadSkillById(skillId, context.workspace, context.blockedSkillIds)
           if ('error' in result) return { output: result, isError: true }
           return { output: result }
         }
diff --git a/kun/src/cli/cli-options.ts b/kun/src/cli/cli-options.ts
index 3bce14730..33f9b993a 100644
--- a/kun/src/cli/cli-options.ts
+++ b/kun/src/cli/cli-options.ts
@@ -11,6 +11,7 @@ import {
   DEFAULT_STORAGE_CONFIG,
   ModelConfigSchema,
   QualityConfigSchema,
+  RolesConfigSchema,
   RuntimeTuningConfigSchema,
   ServeProviderConfigSchema,
   StorageConfigSchema,
@@ -59,6 +60,7 @@ export const ServeOptionsSchema = z.object({
   models: ModelConfigSchema.optional(),
   contextCompaction: ContextCompactionConfigSchema.optional(),
   runtime: RuntimeTuningConfigSchema.optional(),
+  roles: RolesConfigSchema.optional(),
   capabilities: KunCapabilitiesConfig.default(DEFAULT_KUN_CAPABILITIES_CONFIG),
   hooks: HooksConfigSchema.optional(),
   quality: QualityConfigSchema.optional()
diff --git a/kun/src/cli/serve-entry.ts b/kun/src/cli/serve-entry.ts
index 6944d03ff..7467c43a5 100644
--- a/kun/src/cli/serve-entry.ts
+++ b/kun/src/cli/serve-entry.ts
@@ -61,6 +61,7 @@ async function serveMain(argv: readonly string[]): Promise<number> {
   installServeCrashHandlers(() => handle)
   const server = await startKunServe(parsed.options)
   handle = server
+  await selfVerifyHealth(server.host, server.port)
   const info = server.runtime.info()
   const startupInfo = {
     service: 'kun',
@@ -112,6 +113,31 @@ async function hideMacosDockIfRunningAsElectron(): Promise<void> {
   }
 }
 
+const SELF_VERIFY_TIMEOUT_MS = 5_000
+const SELF_VERIFY_POLL_MS = 100
+
+async function selfVerifyHealth(host: string, port: number): Promise<void> {
+  const url = `http://${host}:${port}/health`
+  const deadline = Date.now() + SELF_VERIFY_TIMEOUT_MS
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, {
+        signal: AbortSignal.timeout(1_000)
+      })
+      if (res.ok) {
+        const body = (await res.json()) as { status?: string }
+        if (body?.status === 'ok') return
+      }
+    } catch {
+      // retry
+    }
+    await new Promise<void>((r) => setTimeout(r, SELF_VERIFY_POLL_MS))
+  }
+  process.stderr.write(
+    `[kun] warning: self-health-probe on http://${host}:${port}/health did not pass within ${SELF_VERIFY_TIMEOUT_MS}ms — proceeding anyway\n`
+  )
+}
+
 export async function main(argv: readonly string[]): Promise<number> {
   await hideMacosDockIfRunningAsElectron()
   const command = splitKunCliCommand(argv)
diff --git a/kun/src/cli/serve.ts b/kun/src/cli/serve.ts
index 4cfd303df..6b80bf92c 100644
--- a/kun/src/cli/serve.ts
+++ b/kun/src/cli/serve.ts
@@ -143,6 +143,7 @@ export function parseServeOptions(
     models: loadedConfig?.config.models,
     contextCompaction: loadedConfig?.config.contextCompaction,
     runtime: loadedConfig?.config.runtime,
+    roles: loadedConfig?.config.roles,
     capabilities: loadedConfig?.config.capabilities ?? DEFAULT_SERVE_OPTIONS.capabilities,
     hooks: loadedConfig?.config.hooks,
     quality: loadedConfig?.config.quality
diff --git a/kun/src/config/kun-config.ts b/kun/src/config/kun-config.ts
index 91ccdfb47..5eb1b4621 100644
--- a/kun/src/config/kun-config.ts
+++ b/kun/src/config/kun-config.ts
@@ -13,7 +13,8 @@ import {
   KunCapabilitiesConfig,
   ModelInputModality,
   ModelMessagePartSupport,
-  ModelReasoningCapabilityMetadata
+  ModelReasoningCapabilityMetadata,
+  ModelReasoningEffort
 } from '../contracts/capabilities.js'
 import {
   DEFAULT_MODEL_ENDPOINT_FORMAT,
@@ -107,6 +108,8 @@ export const ContextCompactionConfigSchema = z
     summaryTimeoutMs: PositiveInt.optional(),
     summaryMaxTokens: PositiveInt.optional(),
     summaryInputMaxBytes: PositiveInt.optional(),
+    summaryModel: z.string().min(1).optional(),
+    summaryProviderId: z.string().min(1).optional(),
     modelProfiles: z.record(z.string().min(1), ModelContextProfileConfigSchema).optional()
   })
   .strict()
@@ -248,12 +251,39 @@ export const KunServeConfigSchema = z
   })
   .strict()
 
+/**
+ * Internal-LLM role model routing. The global `smallModel` slot is the default
+ * for cheap internal one-shot calls (thread title, whole-session summary). Each
+ * role can override with its own model/provider. Empty/absent => fall back to
+ * smallModel, then the main conversation model. Compaction is intentionally NOT
+ * here: it reuses the main conversation model for prompt-cache reasons and only
+ * exposes its heuristic/model toggle via contextCompaction.summaryMode.
+ */
+export const RolesConfigSchema = z
+  .object({
+    smallModel: z.string().min(1).optional(),
+    smallModelProviderId: z.string().min(1).optional(),
+    titleModel: z.string().min(1).optional(),
+    titleProviderId: z.string().min(1).optional(),
+    summaryModel: z.string().min(1).optional(),
+    summaryProviderId: z.string().min(1).optional(),
+    codeReviewModel: z.string().min(1).optional(),
+    codeReviewProviderId: z.string().min(1).optional(),
+    // Per-role reasoning depth. Default 'off' (the GUI omits it entirely).
+    titleReasoningEffort: ModelReasoningEffort.optional(),
+    summaryReasoningEffort: ModelReasoningEffort.optional(),
+    codeReviewReasoningEffort: ModelReasoningEffort.optional()
+  })
+  .strict()
+export type RolesConfig = z.infer<typeof RolesConfigSchema>
+
 export const KunConfigSchema = z
   .object({
     serve: KunServeConfigSchema.optional(),
     models: ModelConfigSchema.optional(),
     contextCompaction: ContextCompactionConfigSchema.optional(),
     runtime: RuntimeTuningConfigSchema.optional(),
+    roles: RolesConfigSchema.optional(),
     capabilities: KunCapabilitiesConfig.default(DEFAULT_KUN_CAPABILITIES_CONFIG),
     hooks: HooksConfigSchema.optional(),
     quality: QualityConfigSchema.optional()
diff --git a/kun/src/contracts/approvals.ts b/kun/src/contracts/approvals.ts
index e8a8b9576..b8f64cf82 100644
--- a/kun/src/contracts/approvals.ts
+++ b/kun/src/contracts/approvals.ts
@@ -10,6 +10,7 @@ export type ApprovalDecisionRequest = z.infer<typeof ApprovalDecisionRequest>
 export const ApprovalDecisionResponse = z.object({
   approvalId: z.string().min(1),
   decision: z.enum(['allow', 'deny']),
-  status: z.enum(['allowed', 'denied', 'expired'])
+  status: z.enum(['allowed', 'denied', 'expired']),
+  alreadyResolved: z.boolean().optional()
 })
 export type ApprovalDecisionResponse = z.infer<typeof ApprovalDecisionResponse>
diff --git a/kun/src/contracts/capabilities.ts b/kun/src/contracts/capabilities.ts
index 062ba3e00..c46ffde67 100644
--- a/kun/src/contracts/capabilities.ts
+++ b/kun/src/contracts/capabilities.ts
@@ -51,6 +51,11 @@ export const ModelCapabilityMetadata = z
     outputModalities: z.array(ModelInputModality).min(1),
     supportsToolCalling: z.boolean(),
     contextWindowTokens: z.number().int().positive().optional(),
+    // Maximum tokens the model may emit per response. When set it caps the
+    // request's output budget (max_tokens / max_output_tokens). Absent means
+    // "use the runtime default" — which is reasoning-aware for the Anthropic
+    // Messages format so thinking models don't truncate their tool calls.
+    maxOutputTokens: z.number().int().positive().optional(),
     messageParts: z.array(ModelMessagePartSupport).min(1),
     reasoning: ModelReasoningCapabilityMetadata.optional(),
     // Per-model wire-format override. Lets one provider route some models to
@@ -112,6 +117,7 @@ export const McpServerConfig = z
     transport: McpTransportKind,
     command: z.string().min(1).optional(),
     args: z.array(z.string()).default([]),
+    cwd: z.string().min(1).optional(),
     url: z.string().min(1).optional(),
     headers: StringRecord.default({}),
     env: StringRecord.default({}),
@@ -182,6 +188,16 @@ export type WebCapabilityConfig = z.infer<typeof WebCapabilityConfig>
 
 export const SkillsCapabilityConfig = CapabilityToggleConfig.extend({
   roots: z.array(z.string().min(1)).default([]),
+  workspaceRoots: z.array(z.string().min(1)).default([]),
+  /** Global skill roots (e.g. ~/.kun/skills). Scanned after project roots. */
+  globalRoots: z.array(z.string().min(1)).default([]),
+  /**
+   * Skill ids the user disabled in the GUI. Excluded everywhere a skill can
+   * surface (catalog, auto-match, load_skill, diagnostics) so a disabled skill
+   * is truly gone from the runtime, not merely hidden in the UI. Compared after
+   * `slug()` normalization on both sides.
+   */
+  disabledIds: z.array(z.string().min(1)).default([]),
   legacySkillMd: z.boolean().default(true)
 }).strict()
 export type SkillsCapabilityConfig = z.infer<typeof SkillsCapabilityConfig>
@@ -189,6 +205,10 @@ export type SkillsCapabilityConfig = z.infer<typeof SkillsCapabilityConfig>
 export const SubagentToolPolicy = z.enum(['readOnly', 'inherit'])
 export type SubagentToolPolicy = z.infer<typeof SubagentToolPolicy>
 
+/** Where an agent can be used: a delegated subagent, a primary session persona, or both. */
+export const SubagentMode = z.enum(['subagent', 'primary', 'all'])
+export type SubagentMode = z.infer<typeof SubagentMode>
+
 /**
  * Tools a `readOnly` subagent may call. The list is enforced twice: the
  * child loop advertises only these names (schema filter) and the
@@ -200,12 +220,43 @@ export const SUBAGENT_READ_ONLY_TOOL_NAMES = ['read', 'grep', 'find', 'ls'] as c
 
 export const SubagentProfileConfig = z
   .object({
+    /** Display name for the GUI roster and pickers (falls back to the profile key). */
+    name: z.string().min(1).optional(),
+    /** When-to-use description shown in the delegate_task schema and the GUI. */
+    description: z.string().min(1).optional(),
+    /** UI accent color (hex) for the agent's chip/avatar. */
+    color: z.string().min(1).optional(),
+    /** Where the agent can be used: delegated subagent, primary session persona, or both. */
+    mode: SubagentMode.default('subagent'),
     /** Overrides the child model for this role (falls back to the server default). */
     model: z.string().min(1).optional(),
+    /** Routes this role's child to a specific provider id (falls back to the runtime default provider). */
+    providerId: z.string().min(1).optional(),
+    /** Persona/instructions appended to the base system prompt for this role (not a full replace). */
+    systemPrompt: z.string().min(1).optional(),
     /** Short instruction prepended to the delegated task prompt. */
     promptPreamble: z.string().min(1).optional(),
-    /** Whether the child is restricted to read-only tools or inherits the full set. */
-    toolPolicy: SubagentToolPolicy.default('readOnly')
+    /**
+     * Whether the child is restricted to read-only tools or inherits the
+     * parent agent's full tool set + approval policy. Defaults to `inherit`
+     * (follow the main agent); a profile that needs read-only must say so
+     * explicitly (e.g. the built-in reviewers).
+     */
+    toolPolicy: SubagentToolPolicy.default('inherit'),
+    /** Exact tool allow-list; overrides toolPolicy when set (e.g. ['read','grep','bash']). */
+    allowedTools: z.array(z.string().min(1)).min(1).optional(),
+    /** Built-in tool names blocked for this profile (deny-list, layered on `inherit`; e.g. ['bash','write']). */
+    blockedTools: z.array(z.string().min(1)).optional(),
+    /** MCP server ids blocked for this profile (deny-list; the server's entire toolset is hidden from the child). */
+    blockedMcpServers: z.array(z.string().min(1)).optional(),
+    /** Skill ids blocked for this profile (deny-list; default inherits every available skill). */
+    blockedSkills: z.array(z.string().min(1)).optional(),
+    /**
+     * Reasoning depth applied to this profile's child model requests. Default
+     * 'off' (cheap); a profile opts into deeper thinking explicitly. Flows to
+     * the child agent's ModelRequest.reasoningEffort.
+     */
+    reasoningEffort: ModelReasoningEffort.optional()
   })
   .strict()
 export type SubagentProfileConfig = z.infer<typeof SubagentProfileConfig>
@@ -215,8 +266,16 @@ export const SubagentsCapabilityConfig = CapabilityToggleConfig.extend({
   maxParallel: z.number().int().nonnegative().default(0),
   /** Hard cap on total children per parent thread. */
   maxChildRuns: z.number().int().nonnegative().default(0),
-  /** Tool policy applied to children that do not resolve a profile. */
-  defaultToolPolicy: SubagentToolPolicy.default('readOnly'),
+  /**
+   * Tool policy applied to children that do not resolve a profile. Defaults to
+   * `inherit` so a delegated subagent follows the MAIN agent's tools AND
+   * approval/permission policy (it can edit/run shell iff the parent can).
+   * `inherit` never escalates beyond the parent: the child loop runs under the
+   * parent thread's approvalPolicy/sandboxMode, so a read-only parent yields a
+   * read-only child. Per-profile `toolPolicy` (e.g. the built-in read-only
+   * reviewers) still wins over this default.
+   */
+  defaultToolPolicy: SubagentToolPolicy.default('inherit'),
   /** Profile chosen when `delegate_task` omits an explicit profile. */
   defaultProfile: z.string().min(1).optional(),
   /** Named subagent roles (e.g. researcher/reviewer/verifier). */
diff --git a/kun/src/contracts/events.ts b/kun/src/contracts/events.ts
index 835274873..45e0c4797 100644
--- a/kun/src/contracts/events.ts
+++ b/kun/src/contracts/events.ts
@@ -78,6 +78,7 @@ const RuntimeEventBase = z.object({
     // the GUI can show prefix reuse, tool fan-out, timing, and cost per
     // subagent without a separate diagnostics fetch.
     childModel: z.string().optional(),
+    childProviderId: z.string().optional(),
     childProfile: z.string().optional(),
     childToolPolicy: SubagentToolPolicy.optional(),
     prefixReused: z.boolean().optional(),
@@ -109,6 +110,7 @@ export type ItemEvent = z.infer<typeof ItemEvent>
 export const ThreadLifecycleEvent = RuntimeEventBase.extend({
   kind: z.enum(['thread_created', 'thread_updated']),
   title: z.string().optional(),
+  titleAuto: z.boolean().optional(),
   status: z.string().optional()
 })
 export type ThreadLifecycleEvent = z.infer<typeof ThreadLifecycleEvent>
diff --git a/kun/src/contracts/threads.ts b/kun/src/contracts/threads.ts
index 5eee0a1e1..4948a64d3 100644
--- a/kun/src/contracts/threads.ts
+++ b/kun/src/contracts/threads.ts
@@ -93,6 +93,20 @@ export type ThreadTodoList = z.infer<typeof ThreadTodoListSchema>
 export const ThreadSchema = z.object({
   id: z.string().min(1),
   title: z.string(),
+  /**
+   * Whether the current title was auto-derived (client-side first-message
+   * heuristic or the backend LLM titler) rather than set by the user.
+   * - `true`  → provisional/auto title; the backend LLM titler may upgrade it.
+   * - `false` → the user renamed it manually; never auto-overwrite.
+   * - absent  → legacy/unknown; the backend only upgrades placeholder titles.
+   */
+  titleAuto: z.boolean().optional(),
+  /**
+   * Optional whole-conversation summary (~1 paragraph) produced on demand by
+   * the Summary internal-LLM role. Surfaced as the conversation's hover /
+   * subtitle in the thread list. Absent until the user runs "summarize".
+   */
+  summary: z.string().optional(),
   workspace: z.string(),
   model: z.string(),
   /**
@@ -102,10 +116,24 @@ export const ThreadSchema = z.object({
    * bridges pin a non-runtime provider per thread.
    */
   providerId: z.string().optional(),
+  /**
+   * Optional subagent profile id this thread is bound to. When set, the
+   * thread persona (model / providerId / systemPrompt below) is a snapshot
+   * of the agent at thread-create time so later agent edits don't drift
+   * historical conversations.
+   */
+  agentId: z.string().optional(),
+  /**
+   * Optional thread-level systemPrompt override. When non-empty, it
+   * replaces the runtime's base systemPrompt in every ModelRequest on this
+   * thread (primary-agent persona snapshot path).
+   */
+  systemPrompt: z.string().optional(),
   mode: ThreadMode,
   status: ThreadStatus,
   approvalPolicy: ApprovalPolicySchema.default(DEFAULT_APPROVAL_POLICY),
   sandboxMode: SandboxModeSchema.default(DEFAULT_SANDBOX_MODE),
+  pinned: z.boolean().optional(),
   costBudgetUsd: z.number().positive().optional(),
   costBudgetWarningSent: z.boolean().optional(),
   relation: ThreadRelation.default('primary'),
@@ -126,13 +154,18 @@ export type ThreadRecord = z.infer<typeof ThreadSchema>
 export const ThreadSummarySchema = ThreadSchema.pick({
   id: true,
   title: true,
+  titleAuto: true,
+  summary: true,
   workspace: true,
   model: true,
   providerId: true,
+  agentId: true,
+  systemPrompt: true,
   mode: true,
   status: true,
   approvalPolicy: true,
   sandboxMode: true,
+  pinned: true,
   costBudgetUsd: true,
   costBudgetWarningSent: true,
   relation: true,
@@ -151,6 +184,8 @@ export type ThreadSummary = z.infer<typeof ThreadSummarySchema>
 
 export const CreateThreadRequest = z.object({
   title: z.string().optional(),
+  /** Marks the provided title as an auto/provisional title (see ThreadSchema.titleAuto). */
+  titleAuto: z.boolean().optional(),
   workspace: z.string().min(1),
   model: z.string().min(1),
   /**
@@ -160,6 +195,10 @@ export const CreateThreadRequest = z.object({
    * provider's HTTP client.
    */
   providerId: z.string().optional(),
+  /** Optional subagent profile id to bind this thread to. */
+  agentId: z.string().optional(),
+  /** Optional persona systemPrompt snapshot applied to every ModelRequest on this thread. */
+  systemPrompt: z.string().optional(),
   mode: ThreadMode.default('agent'),
   approvalPolicy: ApprovalPolicySchema.optional(),
   sandboxMode: SandboxModeSchema.optional(),
@@ -242,10 +281,13 @@ export type ClearThreadTodosResponse = z.infer<typeof ClearThreadTodosResponse>
 export const UpdateThreadRequest = z
   .object({
     title: z.string().optional(),
+    /** Marks the new title as auto/provisional (true) or user-set/locked (false). */
+    titleAuto: z.boolean().optional(),
     workspace: z.string().min(1).optional(),
     status: ThreadStatus.optional(),
     approvalPolicy: ApprovalPolicySchema.optional(),
     sandboxMode: SandboxModeSchema.optional(),
+    pinned: z.boolean().optional(),
     costBudgetUsd: z.number().positive().nullable().optional(),
     costBudgetWarningSent: z.boolean().optional(),
     relation: ThreadRelation.optional()
@@ -253,10 +295,12 @@ export const UpdateThreadRequest = z
   .refine(
     (value) =>
       value.title !== undefined ||
+      value.titleAuto !== undefined ||
       value.workspace !== undefined ||
       value.status !== undefined ||
       value.approvalPolicy !== undefined ||
       value.sandboxMode !== undefined ||
+      value.pinned !== undefined ||
       value.costBudgetUsd !== undefined ||
       value.costBudgetWarningSent !== undefined ||
       value.relation !== undefined,
diff --git a/kun/src/delegation/builtin-profiles.ts b/kun/src/delegation/builtin-profiles.ts
index ac90973c7..8d34b789e 100644
--- a/kun/src/delegation/builtin-profiles.ts
+++ b/kun/src/delegation/builtin-profiles.ts
@@ -18,6 +18,7 @@ import type {
  * is `readOnly`, enforced by the delegation runtime and tool registry).
  */
 export const DESIGN_REVIEWER_PROFILE: SubagentProfileConfig = {
+  mode: 'subagent',
   toolPolicy: 'readOnly',
   promptPreamble: [
     '你是 Kun 内置的设计审查者，以只读方式审查前端代码与原型的视觉与交互质量。',
@@ -37,6 +38,7 @@ export const DESIGN_REVIEWER_PROFILE: SubagentProfileConfig = {
  * a normal review pass) and never edits files (toolPolicy is `readOnly`).
  */
 export const OVER_ENGINEERING_REVIEWER_PROFILE: SubagentProfileConfig = {
+  mode: 'subagent',
   toolPolicy: 'readOnly',
   promptPreamble: [
     '你是 Kun 内置的「过度设计审查者」，以只读方式审查代码的过度设计与不必要的复杂度——只找“能删什么、能用标准库/平台能力替换什么”，',
@@ -56,8 +58,43 @@ export const OVER_ENGINEERING_REVIEWER_PROFILE: SubagentProfileConfig = {
   ].join('')
 }
 
+/**
+ * General-purpose agent: full tool access (inherits the parent's tools and
+ * approval policy), so it can research and carry out multi-step work including
+ * editing files. The default target for "do this independent unit of work"
+ * delegations, including several in parallel.
+ */
+export const GENERAL_PROFILE: SubagentProfileConfig = {
+  mode: 'subagent',
+  toolPolicy: 'inherit',
+  description: '通用代理:研究复杂问题、执行多步骤任务,可读写文件、运行命令,可并行。',
+  promptPreamble: [
+    '你是 Kun 内置的「通用代理」(General)。你能研究复杂问题并执行多步骤任务,',
+    '拥有与主代理一致的完整工具访问权限(todo 除外),因此可以在需要时读写文件、运行命令。',
+    '适合被派去并行承担一个独立的工作单元。聚焦交给你的具体任务,完成后简洁汇报结果与关键改动。'
+  ].join('')
+}
+
+/**
+ * Fast read-only explorer: finds files, greps for keywords and answers
+ * questions about the codebase. Never edits (toolPolicy `readOnly`).
+ */
+export const EXPLORE_PROFILE: SubagentProfileConfig = {
+  mode: 'subagent',
+  toolPolicy: 'readOnly',
+  description: '只读探索代理:快速查找文件、搜索关键字、回答关于代码库的问题,不修改任何文件。',
+  promptPreamble: [
+    '你是 Kun 内置的「探索代理」(Explore),一个快速的只读代码库代理。',
+    '你只读取/搜索/列目录,绝不修改任何文件。',
+    '当需要按模式快速查找文件、搜索代码关键字、或回答关于代码库的问题时使用你。',
+    '高效定位相关位置,返回结论(文件:行 + 简要说明),不做与任务无关的展开。'
+  ].join('')
+}
+
 /** All builtin profiles, keyed by their `delegate_task` profile name. */
 export const BUILTIN_SUBAGENT_PROFILES: Readonly<Record<string, SubagentProfileConfig>> = {
+  general: GENERAL_PROFILE,
+  explore: EXPLORE_PROFILE,
   'design-reviewer': DESIGN_REVIEWER_PROFILE,
   'over-engineering-reviewer': OVER_ENGINEERING_REVIEWER_PROFILE
 }
@@ -66,8 +103,16 @@ export const BUILTIN_SUBAGENT_PROFILES: Readonly<Record<string, SubagentProfileC
 export function mergeBuiltinSubagentProfiles(
   config: SubagentsCapabilityConfig
 ): SubagentsCapabilityConfig {
-  return {
-    ...config,
-    profiles: { ...BUILTIN_SUBAGENT_PROFILES, ...config.profiles }
+  // Per-id DEEP merge (builtin base < user override), NOT a shallow replace.
+  // The GUI persists a builtin override carrying only the edited fields (a
+  // model pick, a reasoning level, or a deny-list) and drops the localized
+  // name; a shallow `{ ...builtins, ...config.profiles }` would let that thin
+  // override clobber the builtin's promptPreamble/description/systemPrompt.
+  // Merging per id keeps those as fallbacks while the user's fields still win.
+  const profiles: Record<string, SubagentProfileConfig> = { ...config.profiles }
+  for (const [id, builtin] of Object.entries(BUILTIN_SUBAGENT_PROFILES)) {
+    const override = config.profiles[id]
+    profiles[id] = override ? { ...builtin, ...override } : builtin
   }
+  return { ...config, profiles }
 }
diff --git a/kun/src/delegation/child-agent-executor.ts b/kun/src/delegation/child-agent-executor.ts
index a8eb0e15b..e07ffe2d9 100644
--- a/kun/src/delegation/child-agent-executor.ts
+++ b/kun/src/delegation/child-agent-executor.ts
@@ -3,12 +3,13 @@ import { InMemoryEventBus } from '../adapters/in-memory-event-bus.js'
 import { InMemorySessionStore } from '../adapters/in-memory-session-store.js'
 import { InMemoryThreadStore } from '../adapters/in-memory-thread-store.js'
 import { InMemoryUserInputGate } from '../adapters/in-memory-user-input-gate.js'
-import type { ImmutablePrefix } from '../cache/immutable-prefix.js'
+import { setSystemPrompt, type ImmutablePrefix } from '../cache/immutable-prefix.js'
 import { SUBAGENT_READ_ONLY_TOOL_NAMES, type ModelCapabilityMetadata } from '../contracts/capabilities.js'
 import type { TurnItem } from '../contracts/items.js'
 import type { ApprovalPolicy, SandboxMode } from '../contracts/policy.js'
 import type { RuntimeTuningConfig } from '../config/kun-config.js'
 import { AgentLoop } from '../loop/agent-loop.js'
+import { normalizeRoleReasoningEffort } from '../loop/reasoning-effort.js'
 import type { ContextCompactionConfig, ModelConfig } from '../loop/model-context-profile.js'
 import { ContextCompactor } from '../loop/context-compactor.js'
 import { InflightTracker } from '../loop/inflight-tracker.js'
@@ -79,12 +80,38 @@ export function createChildAgentExecutor(options: ChildAgentExecutorOptions): Ch
       ids,
       nowIso
     })
-    // Read-only children advertise only investigation tools. The allow-list
-    // is enforced twice by the capability registry: tools outside it are
-    // dropped from the model's tool schema and rejected at execute time.
-    const forcedAllowedToolNames = input.toolPolicy === 'readOnly'
-      ? [...SUBAGENT_READ_ONLY_TOOL_NAMES]
+    // Tool gating, most-specific first: an explicit allow-list wins; else a
+    // read-only policy restricts to investigation tools; else (inherit) the
+    // child sees the parent agent's FULL tool set — no forced allow-list, so
+    // it can edit/run shell exactly like the parent. The capability registry
+    // enforces an explicit list twice (dropped from the model's tool schema
+    // and rejected at execute), but `inherit` leaves it undefined so nothing
+    // is forced. The child is not an escalation: it runs under the parent
+    // thread's approvalPolicy/sandboxMode (set on the thread below from
+    // options.approvalPolicy/sandboxMode, which the runtime factory threads
+    // from the parent runtime), so a read-only parent still yields a
+    // read-only child.
+    const forcedAllowedToolNames = input.allowedTools
+      ? [...input.allowedTools]
+      : input.toolPolicy === 'readOnly'
+        ? [...SUBAGENT_READ_ONLY_TOOL_NAMES]
+        : undefined
+    // GUI "custom" capability scope: deny-lists layered on top of inherit.
+    // Built-in tools block by name; MCP servers block at the provider level
+    // (`mcp:<serverId>`, drift-proof — new tools from a blocked server stay
+    // hidden); skills block by id. All three only REMOVE access, so they
+    // compose with the parent intersection and can never escalate the child.
+    const blockedToolNames = input.blockedTools?.length ? [...input.blockedTools] : undefined
+    const blockedProviderIds = input.blockedMcpServers?.length
+      ? input.blockedMcpServers.map((serverId) => `mcp:${serverId}`)
       : undefined
+    const blockedSkillIds = input.blockedSkills?.length ? [...input.blockedSkills] : undefined
+    // A custom system prompt augments the base prefix (kun tool/safety
+    // conventions stay) on a distinct fingerprint, so same-agent calls still
+    // hit the prompt cache; cross-agent reuse is intentionally given up.
+    const childPrefix = input.systemPrompt?.trim()
+      ? setSystemPrompt(options.prefix, `${options.prefix.systemPrompt}\n\n${input.systemPrompt.trim()}`.trim())
+      : options.prefix
     const loop = new AgentLoop({
       threadStore,
       sessionStore,
@@ -98,10 +125,13 @@ export function createChildAgentExecutor(options: ChildAgentExecutorOptions): Ch
       inflight,
       steering,
       compactor,
-      prefix: options.prefix,
+      prefix: childPrefix,
       ids,
       nowIso,
       ...(forcedAllowedToolNames ? { forcedAllowedToolNames } : {}),
+      ...(blockedToolNames ? { blockedToolNames } : {}),
+      ...(blockedProviderIds ? { blockedProviderIds } : {}),
+      ...(blockedSkillIds ? { blockedSkillIds } : {}),
       ...(options.modelCapabilities ? { modelCapabilities: options.modelCapabilities } : {}),
       ...(options.skillRuntime ? { skillRuntime: options.skillRuntime } : {}),
       ...(options.memoryStore ? { memoryStore: options.memoryStore } : {}),
@@ -118,7 +148,11 @@ export function createChildAgentExecutor(options: ChildAgentExecutorOptions): Ch
       model,
       mode: 'agent',
       approvalPolicy: options.approvalPolicy ?? 'auto',
-      ...(options.sandboxMode ? { sandboxMode: options.sandboxMode } : {})
+      ...(options.sandboxMode ? { sandboxMode: options.sandboxMode } : {}),
+      // Route the child to the profile's provider. ThreadService threads
+      // providerId into every ModelRequest, and the executor's model is the
+      // MultiProviderModelClient, so this single field is all routing needs.
+      ...(input.providerId ? { providerId: input.providerId } : {})
     }, {
       id: input.childId,
       title: childThreadTitle(input.childId, input.label)
@@ -134,6 +168,7 @@ export function createChildAgentExecutor(options: ChildAgentExecutorOptions): Ch
         prompt,
         model,
         mode: 'agent',
+        reasoningEffort: normalizeRoleReasoningEffort(input.reasoningEffort),
         // Children have no GUI surface to answer structured input prompts.
         disableUserInput: true
       }
diff --git a/kun/src/delegation/delegation-runtime.ts b/kun/src/delegation/delegation-runtime.ts
index 306986fbc..6b218aac1 100644
--- a/kun/src/delegation/delegation-runtime.ts
+++ b/kun/src/delegation/delegation-runtime.ts
@@ -1,9 +1,10 @@
 import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { z } from 'zod'
-import { SubagentToolPolicy, type SubagentsCapabilityConfig } from '../contracts/capabilities.js'
+import { SubagentToolPolicy, type SubagentMode, type SubagentProfileConfig, type SubagentsCapabilityConfig } from '../contracts/capabilities.js'
 import type { RuntimeEventRecorder } from '../services/runtime-event-recorder.js'
 import type { UsageSnapshot } from '../contracts/usage.js'
+import { loadWorkspaceAgentProfiles } from './workspace-agents.js'
 
 const ChildRunUsage = z.object({
   promptTokens: z.number().int().nonnegative().default(0),
@@ -31,6 +32,8 @@ export const ChildRunRecord = z.object({
   prompt: z.string().min(1),
   workspace: z.string().optional(),
   model: z.string().optional(),
+  /** Resolved provider id the child routed through, when one was selected. */
+  providerId: z.string().optional(),
   /** Resolved subagent profile name, when one was selected. */
   profile: z.string().optional(),
   /** Effective tool policy applied to the child (read-only vs inherited). */
@@ -64,8 +67,19 @@ export type ChildRunExecutor = (input: {
   prompt: string
   workspace?: string
   model?: string
+  providerId?: string
+  systemPrompt?: string
+  allowedTools?: string[]
+  /** Built-in tool names blocked for this child (deny-list layered on inherit). */
+  blockedTools?: string[]
+  /** MCP server ids blocked for this child (deny-list; whole server toolset hidden). */
+  blockedMcpServers?: string[]
+  /** Skill ids blocked for this child (deny-list; catalog + activation + load_skill). */
+  blockedSkills?: string[]
   toolPolicy: SubagentToolPolicy
   promptPreamble?: string
+  /** Reasoning depth for this profile's child model requests (default 'off'). */
+  reasoningEffort?: string
   signal: AbortSignal
 }) => Promise<{
   summary: string
@@ -132,6 +146,12 @@ export class DelegationRuntime {
   private readonly threadCounts = new Map<string, number>()
   /** Cached per-thread seed reads so concurrent first-spawns don't double-count. */
   private readonly threadSeeds = new Map<string, Promise<void>>()
+  /**
+   * Background (detached) child runs keyed by childId, exposing an
+   * AbortController so the user can cancel a long-running task from the
+   * GUI even after the parent turn finished.
+   */
+  private readonly detachedAborts = new Map<string, AbortController>()
 
   constructor(private readonly options: {
     config: SubagentsCapabilityConfig
@@ -150,7 +170,15 @@ export class DelegationRuntime {
     prompt: string
     workspace?: string
     model?: string
+    providerId?: string
     profile?: string
+    /**
+     * When true, runChild returns the queued ChildRunRecord immediately and
+     * continues execution in the background. The detached run gets its own
+     * AbortController so the user can cancel it via `abortChild(id)` even
+     * after the parent turn finishes. Default: false (synchronous).
+     */
+    detach?: boolean
     signal: AbortSignal
   }): Promise<ChildRunRecord> {
     const config = this.options.config
@@ -159,13 +187,28 @@ export class DelegationRuntime {
     // Resolve the profile up front so model/preamble/tool-policy are
     // captured on the record even if the child later fails.
     const profileName = input.profile?.trim() || config.defaultProfile
-    const profile = profileName ? config.profiles[profileName] : undefined
+    // Workspace overlay: `.kun/agents/*.md` in the call's workspace wins
+    // over the static `config.profiles` map. Loaded fresh per call so the
+    // user can edit overlays without restarting the runtime.
+    let profile: SubagentProfileConfig | undefined = profileName ? config.profiles[profileName] : undefined
+    if (profileName && input.workspace) {
+      const overlay = await loadWorkspaceAgentProfiles(input.workspace)
+      const hit = overlay.find((entry) => entry.id === profileName)
+      if (hit) profile = hit.profile
+    }
     if (profileName && !profile) {
       throw new Error(`unknown subagent profile: ${profileName}`)
     }
     const toolPolicy = profile?.toolPolicy ?? config.defaultToolPolicy
     const resolvedModel = input.model?.trim() || profile?.model
+    const resolvedProviderId = input.providerId?.trim() || profile?.providerId
+    const resolvedSystemPrompt = profile?.systemPrompt
+    const resolvedAllowedTools = profile?.allowedTools
+    const resolvedBlockedTools = profile?.blockedTools
+    const resolvedBlockedMcpServers = profile?.blockedMcpServers
+    const resolvedBlockedSkills = profile?.blockedSkills
     const promptPreamble = profile?.promptPreamble
+    const resolvedReasoningEffort = profile?.reasoningEffort
 
     // Reserve against the per-thread budget before persisting anything.
     await this.ensureSeeded(input.parentThreadId)
@@ -183,6 +226,7 @@ export class DelegationRuntime {
       prompt: input.prompt,
       workspace: input.workspace,
       model: resolvedModel,
+      providerId: resolvedProviderId,
       profile: profileName,
       toolPolicy,
       status: 'queued',
@@ -192,6 +236,38 @@ export class DelegationRuntime {
     await this.options.store.upsert(record)
     await this.recordChildEvent(record)
 
+    if (input.detach) {
+      // Spawn an independent signal so the parent turn's signal aborting
+      // doesn't reach into the background run. The user can still cancel
+      // via abortChild(id).
+      const detachedController = new AbortController()
+      this.detachedAborts.set(record.id, detachedController)
+      // Surface ChildRunExecutor's resolved fields via the closure shared with
+      // the synchronous path. The same executor block runs inside executeChild.
+      void this.executeChild({
+        record,
+        queuedAt,
+        profileName,
+        toolPolicy,
+        resolvedModel,
+        resolvedProviderId,
+        resolvedSystemPrompt,
+        resolvedAllowedTools,
+        resolvedBlockedTools,
+        resolvedBlockedMcpServers,
+        resolvedBlockedSkills,
+        promptPreamble,
+        resolvedReasoningEffort,
+        workspace: input.workspace,
+        label: input.label,
+        parentThreadId: input.parentThreadId,
+        parentTurnId: input.parentTurnId,
+        prompt: input.prompt,
+        signal: detachedController.signal
+      }).finally(() => this.detachedAborts.delete(record.id))
+      return record
+    }
+
     try {
       await this.acquireSlot(input.signal)
     } catch (error) {
@@ -222,8 +298,15 @@ export class DelegationRuntime {
         prompt: input.prompt,
         workspace: input.workspace,
         model: resolvedModel,
+        ...(resolvedProviderId ? { providerId: resolvedProviderId } : {}),
+        ...(resolvedSystemPrompt ? { systemPrompt: resolvedSystemPrompt } : {}),
+        ...(resolvedAllowedTools ? { allowedTools: resolvedAllowedTools } : {}),
+        ...(resolvedBlockedTools ? { blockedTools: resolvedBlockedTools } : {}),
+        ...(resolvedBlockedMcpServers ? { blockedMcpServers: resolvedBlockedMcpServers } : {}),
+        ...(resolvedBlockedSkills ? { blockedSkills: resolvedBlockedSkills } : {}),
         toolPolicy,
         ...(promptPreamble ? { promptPreamble } : {}),
+        ...(resolvedReasoningEffort ? { reasoningEffort: resolvedReasoningEffort } : {}),
         signal: input.signal
       })
       const finishedAt = this.now()
@@ -259,6 +342,120 @@ export class DelegationRuntime {
     }
   }
 
+  /**
+   * Run the queue-acquire + execute + result-recording block for a child
+   * that was already persisted with status='queued'. Shared by the
+   * synchronous path (via inline code in runChild) and the detached path.
+   * Failures are recorded on the record rather than re-thrown — for
+   * detached runs nobody is awaiting them anyway.
+   */
+  private async executeChild(args: {
+    record: ChildRunRecord
+    queuedAt: string
+    profileName: string | undefined
+    toolPolicy: SubagentToolPolicy
+    resolvedModel: string | undefined
+    resolvedProviderId: string | undefined
+    resolvedSystemPrompt: string | undefined
+    resolvedAllowedTools: string[] | undefined
+    resolvedBlockedTools: string[] | undefined
+    resolvedBlockedMcpServers: string[] | undefined
+    resolvedBlockedSkills: string[] | undefined
+    promptPreamble: string | undefined
+    resolvedReasoningEffort: string | undefined
+    workspace: string | undefined
+    label: string | undefined
+    parentThreadId: string
+    parentTurnId: string
+    prompt: string
+    signal: AbortSignal
+  }): Promise<ChildRunRecord> {
+    let record = args.record
+    try {
+      await this.acquireSlot(args.signal)
+    } catch (error) {
+      record = ChildRunRecord.parse({
+        ...record,
+        status: 'aborted',
+        error: errorMessage(error),
+        updatedAt: this.now()
+      })
+      await this.options.store.upsert(record)
+      await this.recordChildEvent(record)
+      return record
+    }
+
+    const startedAt = this.now()
+    const queuedMs = elapsedMs(args.queuedAt, startedAt)
+    record = ChildRunRecord.parse({ ...record, status: 'running', startedAt, queuedMs, updatedAt: startedAt })
+    await this.options.store.upsert(record)
+    await this.recordChildEvent(record)
+    try {
+      const executor: ChildRunExecutor = this.options.executor ?? defaultExecutor
+      const result = await executor({
+        childId: record.id,
+        parentThreadId: args.parentThreadId,
+        parentTurnId: args.parentTurnId,
+        ...(args.label ? { label: args.label } : {}),
+        prompt: args.prompt,
+        workspace: args.workspace,
+        model: args.resolvedModel,
+        ...(args.resolvedProviderId ? { providerId: args.resolvedProviderId } : {}),
+        ...(args.resolvedSystemPrompt ? { systemPrompt: args.resolvedSystemPrompt } : {}),
+        ...(args.resolvedAllowedTools ? { allowedTools: args.resolvedAllowedTools } : {}),
+        ...(args.resolvedBlockedTools ? { blockedTools: args.resolvedBlockedTools } : {}),
+        ...(args.resolvedBlockedMcpServers ? { blockedMcpServers: args.resolvedBlockedMcpServers } : {}),
+        ...(args.resolvedBlockedSkills ? { blockedSkills: args.resolvedBlockedSkills } : {}),
+        toolPolicy: args.toolPolicy,
+        ...(args.promptPreamble ? { promptPreamble: args.promptPreamble } : {}),
+        ...(args.resolvedReasoningEffort ? { reasoningEffort: args.resolvedReasoningEffort } : {}),
+        signal: args.signal
+      })
+      const finishedAt = this.now()
+      record = ChildRunRecord.parse({
+        ...record,
+        status: 'completed',
+        summary: result.summary,
+        usage: result.usage ?? record.usage,
+        toolInvocations: result.toolInvocations,
+        prefixReused: result.prefixReused,
+        inheritedHistoryItems: result.inheritedHistoryItems,
+        durationMs: elapsedMs(startedAt, finishedAt),
+        updatedAt: finishedAt
+      })
+      await this.options.store.upsert(record)
+      await this.recordChildEvent(record)
+      this.recordExternalUsage(record)
+      return record
+    } catch (error) {
+      const finishedAt = this.now()
+      record = ChildRunRecord.parse({
+        ...record,
+        status: args.signal.aborted ? 'aborted' : 'failed',
+        error: errorMessage(error),
+        durationMs: elapsedMs(startedAt, finishedAt),
+        updatedAt: finishedAt
+      })
+      await this.options.store.upsert(record)
+      await this.recordChildEvent(record)
+      return record
+    } finally {
+      this.releaseSlot()
+    }
+  }
+
+  /**
+   * Abort a detached child by id. Returns `true` when a running detached
+   * job was signalled, `false` otherwise. Synchronous (in-flight) runs
+   * are unaffected — the caller can abort their own parent signal instead.
+   */
+  abortChild(childId: string): boolean {
+    const controller = this.detachedAborts.get(childId)
+    if (!controller) return false
+    controller.abort()
+    return true
+  }
+
   /** Concurrency ceiling; clamps to at least 1 so an enabled runtime never deadlocks. */
   private get parallelLimit(): number {
     return Math.max(1, this.options.config.maxParallel)
@@ -324,11 +521,14 @@ export class DelegationRuntime {
   }
 
   /** Configured profiles, surfaced to the delegate_task tool schema/UI. */
-  listProfiles(): { name: string; toolPolicy: SubagentToolPolicy; model?: string }[] {
+  listProfiles(): { name: string; mode: SubagentMode; toolPolicy: SubagentToolPolicy; model?: string; providerId?: string; description?: string }[] {
     return Object.entries(this.options.config.profiles).map(([name, profile]) => ({
       name,
+      mode: profile.mode,
       toolPolicy: profile.toolPolicy,
-      ...(profile.model ? { model: profile.model } : {})
+      ...(profile.model ? { model: profile.model } : {}),
+      ...(profile.providerId ? { providerId: profile.providerId } : {}),
+      ...(profile.description ? { description: profile.description } : {})
     }))
   }
 
@@ -371,6 +571,7 @@ export class DelegationRuntime {
         childStatus: record.status,
         childSeq: ++this.childSeq,
         ...(record.model ? { childModel: record.model } : {}),
+        ...(record.providerId ? { childProviderId: record.providerId } : {}),
         ...(record.profile ? { childProfile: record.profile } : {}),
         ...(record.toolPolicy ? { childToolPolicy: record.toolPolicy } : {}),
         ...(record.prefixReused !== undefined ? { prefixReused: record.prefixReused } : {}),
diff --git a/kun/src/delegation/workspace-agents.ts b/kun/src/delegation/workspace-agents.ts
new file mode 100644
index 000000000..2519aa224
--- /dev/null
+++ b/kun/src/delegation/workspace-agents.ts
@@ -0,0 +1,151 @@
+import { readdir, readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { SubagentProfileConfig, type SubagentMode, type SubagentToolPolicy } from '../contracts/capabilities.js'
+
+/**
+ * Workspace-level agent overlay.
+ *
+ * Loads `<workspace>/.kun/agents/*.md` and produces a profile map that
+ * the delegation runtime overlays on top of (`internal < GUI < workspace`).
+ * Frontmatter format:
+ *
+ *     ---
+ *     id: code-reviewer       # optional, defaults to filename stem
+ *     name: Code Reviewer
+ *     description: One-line "when to use"
+ *     mode: subagent          # subagent | primary | all
+ *     model: deepseek-chat
+ *     providerId: deepseek
+ *     toolPolicy: inherit     # readOnly | inherit (default: inherit = follow main agent)
+ *     allowedTools: [read, grep]
+ *     color: "#3b82f6"
+ *     ---
+ *     Body becomes the systemPrompt verbatim (kun's base prompt is
+ *     prepended unless omit_base_prompt: true).
+ *
+ * Files with invalid frontmatter or missing required fields are dropped
+ * silently so a single broken file doesn't take down delegation.
+ */
+export type WorkspaceAgentProfile = {
+  id: string
+  source: 'workspace'
+  filePath: string
+  profile: SubagentProfileConfig
+}
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/
+
+export async function loadWorkspaceAgentProfiles(workspace: string): Promise<WorkspaceAgentProfile[]> {
+  if (!workspace) return []
+  const dir = join(workspace, '.kun', 'agents')
+  let entries: string[]
+  try {
+    entries = await readdir(dir)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []
+    if ((error as NodeJS.ErrnoException).code === 'ENOTDIR') return []
+    throw error
+  }
+  const results: WorkspaceAgentProfile[] = []
+  for (const entry of entries) {
+    if (!entry.endsWith('.md')) continue
+    const filePath = join(dir, entry)
+    try {
+      const text = await readFile(filePath, 'utf8')
+      const parsed = parseAgentMarkdown(text, entry.replace(/\.md$/i, ''))
+      if (parsed) results.push({ ...parsed, filePath, source: 'workspace' })
+    } catch {
+      // Skip unreadable / malformed files; do not bubble — overlay should
+      // never break the parent delegate_task call.
+    }
+  }
+  return results
+}
+
+function parseAgentMarkdown(text: string, defaultId: string): { id: string; profile: SubagentProfileConfig } | null {
+  const match = FRONTMATTER_RE.exec(text)
+  if (!match) return null
+  const yamlRaw = match[1] ?? ''
+  const body = text.slice(match[0].length).trim()
+  const fields = parseSimpleYaml(yamlRaw)
+  const id = fields.id?.trim() || defaultId
+  if (!id) return null
+  const omitBase = boolField(fields, 'omit_base_prompt') === true || boolField(fields, 'omitBasePrompt') === true
+  const systemPromptFromBody = body || undefined
+  const raw: Record<string, unknown> = {
+    ...(fields.name ? { name: fields.name } : {}),
+    ...(fields.description ? { description: fields.description } : {}),
+    ...(fields.color ? { color: fields.color } : {}),
+    mode: normalizeMode(fields.mode),
+    ...(fields.model ? { model: fields.model } : {}),
+    ...(fields.providerId ? { providerId: fields.providerId } : {}),
+    ...(fields.systemPrompt ? { systemPrompt: fields.systemPrompt } : systemPromptFromBody ? { systemPrompt: systemPromptFromBody } : {}),
+    ...(fields.promptPreamble ? { promptPreamble: fields.promptPreamble } : {}),
+    toolPolicy: normalizeToolPolicy(fields.toolPolicy),
+    ...(parseListField(fields, 'allowedTools') ? { allowedTools: parseListField(fields, 'allowedTools') } : {}),
+    ...(parseListField(fields, 'blockedTools') ? { blockedTools: parseListField(fields, 'blockedTools') } : {}),
+    ...(parseListField(fields, 'blockedMcpServers') ? { blockedMcpServers: parseListField(fields, 'blockedMcpServers') } : {}),
+    ...(parseListField(fields, 'blockedSkills') ? { blockedSkills: parseListField(fields, 'blockedSkills') } : {}),
+    // Reasoning depth (off|low|medium|high|max). SubagentProfileConfig validates;
+    // an invalid value would fail safeParse, so only known values survive.
+    ...(fields.reasoningEffort ? { reasoningEffort: fields.reasoningEffort } : {})
+  }
+  // omit_base_prompt is a hint to the augment strategy; we model it as a
+  // marker the runtime can check if it ever needs to. For now we just keep
+  // the systemPrompt as-is and let the executor's augment-base behavior
+  // append the base prefix.
+  void omitBase
+  const parsed = SubagentProfileConfig.safeParse(raw)
+  if (!parsed.success) return null
+  return { id, profile: parsed.data }
+}
+
+function normalizeMode(value: string | undefined): SubagentMode {
+  if (value === 'primary' || value === 'all') return value
+  return 'subagent'
+}
+
+function normalizeToolPolicy(value: string | undefined): SubagentToolPolicy {
+  // Default follows the main agent (inherit); an overlay must say
+  // `toolPolicy: readOnly` explicitly to restrict the child.
+  if (value === 'readOnly') return 'readOnly'
+  return 'inherit'
+}
+
+function boolField(fields: Record<string, string>, key: string): boolean | undefined {
+  const raw = fields[key]?.trim().toLowerCase()
+  if (raw === 'true' || raw === 'yes') return true
+  if (raw === 'false' || raw === 'no') return false
+  return undefined
+}
+
+function parseListField(fields: Record<string, string>, key: string): string[] | undefined {
+  const raw = fields[key]?.trim()
+  if (!raw) return undefined
+  // Support both inline `[a, b, c]` and comma-separated `a, b, c`.
+  const stripped = raw.replace(/^\[/, '').replace(/\]$/, '')
+  const items = stripped.split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
+  return items.length ? items : undefined
+}
+
+/**
+ * Lean YAML key:value parser. Only supports flat scalars, lists, and
+ * double-quoted strings — sufficient for agent frontmatter without pulling
+ * in a YAML dependency.
+ */
+function parseSimpleYaml(raw: string): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const line = rawLine.replace(/\s+#.*$/, '').trim()
+    if (!line || line.startsWith('#')) continue
+    const colon = line.indexOf(':')
+    if (colon < 0) continue
+    const key = line.slice(0, colon).trim()
+    let value = line.slice(colon + 1).trim()
+    if (!key) continue
+    if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1)
+    else if (value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1)
+    result[key] = value
+  }
+  return result
+}
diff --git a/kun/src/domain/thread.ts b/kun/src/domain/thread.ts
index 8abf76be2..aa359e8fa 100644
--- a/kun/src/domain/thread.ts
+++ b/kun/src/domain/thread.ts
@@ -23,13 +23,17 @@ export type ThreadEntity = ThreadRecord
 export function createThreadRecord(input: {
   id: string
   title: string
+  titleAuto?: boolean
   workspace: string
   model: string
   providerId?: string
+  agentId?: string
+  systemPrompt?: string
   mode?: ThreadMode
   status?: ThreadStatus
   approvalPolicy?: ApprovalPolicy
   sandboxMode?: SandboxMode
+  pinned?: boolean
   costBudgetUsd?: number
   costBudgetWarningSent?: boolean
   relation?: ThreadRelation
@@ -47,13 +51,17 @@ export function createThreadRecord(input: {
   return {
     id: input.id,
     title: input.title,
+    ...(input.titleAuto !== undefined ? { titleAuto: input.titleAuto } : {}),
     workspace: input.workspace,
     model: input.model,
     ...(input.providerId ? { providerId: input.providerId } : {}),
+    ...(input.agentId ? { agentId: input.agentId } : {}),
+    ...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
     mode: input.mode ?? 'agent',
     status: input.status ?? 'idle',
     approvalPolicy: input.approvalPolicy ?? DEFAULT_APPROVAL_POLICY,
     sandboxMode: input.sandboxMode ?? DEFAULT_SANDBOX_MODE,
+    ...(input.pinned !== undefined ? { pinned: input.pinned } : {}),
     ...(input.costBudgetUsd !== undefined ? { costBudgetUsd: input.costBudgetUsd } : {}),
     ...(input.costBudgetWarningSent !== undefined ? { costBudgetWarningSent: input.costBudgetWarningSent } : {}),
     relation: input.relation ?? 'primary',
@@ -79,7 +87,7 @@ export function toThreadSummary(
   thread: ThreadEntity
 ): Pick<
   ThreadEntity,
-  'id' | 'title' | 'workspace' | 'model' | 'providerId' | 'mode' | 'status' | 'approvalPolicy' | 'sandboxMode' | 'createdAt' | 'updatedAt'
+  'id' | 'title' | 'titleAuto' | 'summary' | 'workspace' | 'model' | 'providerId' | 'agentId' | 'systemPrompt' | 'mode' | 'status' | 'approvalPolicy' | 'sandboxMode' | 'pinned' | 'createdAt' | 'updatedAt'
   | 'costBudgetUsd' | 'costBudgetWarningSent'
   | 'relation' | 'parentThreadId'
   | 'forkedFromThreadId' | 'forkedFromTitle' | 'forkedAt' | 'forkedFromMessageCount' | 'forkedFromTurnCount'
@@ -88,13 +96,18 @@ export function toThreadSummary(
   return {
     id: thread.id,
     title: thread.title,
+    ...(thread.titleAuto !== undefined ? { titleAuto: thread.titleAuto } : {}),
+    ...(thread.summary ? { summary: thread.summary } : {}),
     workspace: thread.workspace,
     model: thread.model,
     ...(thread.providerId ? { providerId: thread.providerId } : {}),
+    ...(thread.agentId ? { agentId: thread.agentId } : {}),
+    ...(thread.systemPrompt ? { systemPrompt: thread.systemPrompt } : {}),
     mode: thread.mode,
     status: thread.status,
     approvalPolicy: thread.approvalPolicy,
     sandboxMode: thread.sandboxMode,
+    ...(thread.pinned !== undefined ? { pinned: thread.pinned } : {}),
     ...(thread.costBudgetUsd !== undefined ? { costBudgetUsd: thread.costBudgetUsd } : {}),
     ...(thread.costBudgetWarningSent !== undefined ? { costBudgetWarningSent: thread.costBudgetWarningSent } : {}),
     relation: thread.relation ?? 'primary',
diff --git a/kun/src/loop/agent-loop.ts b/kun/src/loop/agent-loop.ts
index 77ac92b51..9d3f84b79 100644
--- a/kun/src/loop/agent-loop.ts
+++ b/kun/src/loop/agent-loop.ts
@@ -28,7 +28,9 @@ import {
   insertCompactionIntoVisibleHistory,
   placeCompactionsAtTurnEnd
 } from './compaction-history.js'
-import { summarizeCompactionWithModel } from './compaction-summary.js'
+import { resolveCompactionModel, summarizeCompactionWithModel } from './compaction-summary.js'
+import { generateThreadTitle, resolveRoleModel } from './title-generator.js'
+import type { RolesConfig } from '../config/kun-config.js'
 import { InflightTracker } from './inflight-tracker.js'
 import { SteeringQueue } from './steering-queue.js'
 import {
@@ -133,6 +135,37 @@ const GOAL_RESUME_PROMPT = [
 function goalResumeKey(threadId: string, goal: ThreadGoal): string {
   return `${threadId}::${goal.createdAt}::${goal.objective}`
 }
+
+/**
+ * Placeholder titles the GUI assigns to a fresh thread. When a thread still
+ * carries one of these (or an empty title), the title is considered
+ * auto-generatable; a user-set title never matches and is preserved. Mirrors
+ * the renderer's `shouldAutoTitleThread` placeholder set so backend title
+ * generation only fills in genuinely-default titles.
+ */
+const PLACEHOLDER_THREAD_TITLES = new Set(['New Thread', '新会话', 'Untitled', '未命名'])
+const CODEX_PLACEHOLDER_TITLE = /^__codex_[a-z0-9_]+__$/i
+
+function isAutoTitleableThreadTitle(title: string | null | undefined): boolean {
+  const raw = title?.trim() ?? ''
+  if (!raw) return true
+  if (PLACEHOLDER_THREAD_TITLES.has(raw)) return true
+  if (CODEX_PLACEHOLDER_TITLE.test(raw)) return true
+  return false
+}
+
+/**
+ * Whether the backend LLM titler may (re)generate a thread's title.
+ *
+ * - `titleAuto === false` → user renamed it manually; never overwrite.
+ * - `titleAuto === true`  → client set a provisional first-message title; upgrade it.
+ * - absent (legacy)       → only upgrade placeholder titles, never a real one.
+ */
+export function canUpgradeThreadTitle(thread: { title?: string | null; titleAuto?: boolean }): boolean {
+  if (thread.titleAuto === false) return false
+  if (thread.titleAuto === true) return true
+  return isAutoTitleableThreadTitle(thread.title)
+}
 const MAX_TOOL_CATALOG_SNAPSHOTS = 256
 
 type TurnFailure = {
@@ -580,6 +613,8 @@ export type AgentLoopOptions = {
   memoryStore?: MemoryStore
   tokenEconomy?: TokenEconomyConfig
   contextCompaction?: ContextCompactionConfig
+  /** Internal-LLM role model routing (smallModel slot + title/summary/codeReview overrides). */
+  roles?: RolesConfig
   toolStorm?: ToolStormBreakerOptions & { enabled?: boolean }
   toolArgumentRepair?: {
     maxStringBytes?: number
@@ -599,6 +634,23 @@ export type AgentLoopOptions = {
    * tools — enforced at both the schema (listTools) and execute layers.
    */
   forcedAllowedToolNames?: readonly string[]
+  /**
+   * Provider ids hard-blocked for this loop (e.g. a subagent profile's blocked
+   * MCP servers, as `mcp:<serverId>`). Deny-list layered on top of inherit and
+   * enforced at both the schema and execute layers.
+   */
+  blockedProviderIds?: readonly string[]
+  /**
+   * Tool names hard-blocked for this loop (e.g. a subagent profile's blocked
+   * built-in tools). Deny-list layered on top of inherit; enforced at both layers.
+   */
+  blockedToolNames?: readonly string[]
+  /**
+   * Skill ids hard-blocked for this loop's turns (e.g. a subagent profile's
+   * blockedSkills). Hidden from the catalog + auto-activation and rejected by
+   * `load_skill`, without mutating the shared skill runtime.
+   */
+  blockedSkillIds?: readonly string[]
   /**
    * Lifecycle hooks (UserPromptSubmit, TurnStart, TurnEnd, PreCompact).
    * Tool phases are handled by the tool host; the loop ignores them.
@@ -749,6 +801,11 @@ export class AgentLoop {
       })
       finalStatus = status
       finalError = failure?.error
+      if (status === 'completed') {
+        // Fire-and-forget: generate an LLM title after the FIRST assistant
+        // reply completes, only when the thread still has a default title.
+        void this.maybeGenerateThreadTitle(threadId, turnId, signal).catch(() => {})
+      }
       return status
     } catch (error) {
       const raw = error instanceof Error ? error.message : String(error)
@@ -879,6 +936,68 @@ export class AgentLoop {
     await this.opts.turns.finishTurn({ threadId, turnId, status: 'failed', error: message })
   }
 
+  /**
+   * After the FIRST assistant reply completes, generate a concise LLM title for
+   * the thread — but only when the thread still carries a default/placeholder
+   * title (so a user-set or already-generated title is never overwritten) and
+   * only on the first completed turn. Model precedence: titleModel -> smallModel
+   * -> main conversation model. Persists the title to the thread store and emits
+   * a `thread_updated` event so the renderer's list refreshes. Best-effort: any
+   * failure is swallowed by the fire-and-forget caller.
+   */
+  private async maybeGenerateThreadTitle(threadId: string, turnId: string, signal?: AbortSignal): Promise<void> {
+    const thread = await this.opts.threadStore.get(threadId)
+    if (!thread) return
+    // Only on the first completed turn so we don't re-title on every reply.
+    const completedTurns = thread.turns.filter((t) => t.status === 'completed').length
+    if (completedTurns > 1) return
+    if (!canUpgradeThreadTitle(thread)) return
+
+    const items = await this.opts.sessionStore.loadItems(threadId)
+    const userText = items.find((item) => item.kind === 'user_message')?.text ?? ''
+    if (!userText.trim()) return
+    const assistantText = items.find((item) => item.kind === 'assistant_text')?.text
+
+    const resolved = resolveRoleModel({
+      roleModel: this.opts.roles?.titleModel,
+      roleProviderId: this.opts.roles?.titleProviderId,
+      roles: this.opts.roles,
+      mainModel: thread.model || this.opts.model.model,
+      mainProviderId: thread.providerId
+    })
+    if (!resolved) return
+
+    const title = await generateThreadTitle({
+      threadId,
+      turnId,
+      modelClient: this.opts.model,
+      model: resolved.model,
+      ...(resolved.providerId ? { providerId: resolved.providerId } : {}),
+      userText,
+      ...(assistantText ? { assistantText } : {}),
+      ...(this.opts.roles?.titleReasoningEffort
+        ? { reasoningEffort: this.opts.roles.titleReasoningEffort }
+        : {}),
+      ...(signal ? { abortSignal: signal } : {})
+    })
+    if (!title) return
+
+    // Re-check the title is still upgradeable (no user rename raced us).
+    const latest = await this.opts.threadStore.get(threadId)
+    if (!latest || !canUpgradeThreadTitle(latest)) return
+    // Keep titleAuto:true — the LLM title is still auto-generated, so a later
+    // user rename can still lock it, but we won't re-title (gated by turn count).
+    const updated = touchThread({ ...latest, title, titleAuto: true }, this.opts.nowIso())
+    await this.opts.threadStore.upsert(updated)
+    await this.opts.events.record({
+      kind: 'thread_updated',
+      threadId,
+      title: updated.title,
+      titleAuto: true,
+      status: updated.status
+    })
+  }
+
   private rememberTurnFailure(turnId: string, failure: TurnFailure): void {
     if (!failure.error.trim()) return
     this.turnFailures.set(turnId, failure)
@@ -1192,9 +1311,10 @@ export class AgentLoop {
       workspace: thread?.workspace ?? '',
       modelCapabilities
     })
-    const skillResolution = this.opts.skillRuntime?.resolveTurn({
+    const skillResolution = await this.opts.skillRuntime?.resolveTurn({
       prompt: turn?.prompt ?? '',
-      workspace: thread?.workspace ?? ''
+      workspace: thread?.workspace ?? '',
+      ...(this.opts.blockedSkillIds ? { blockedSkillIds: this.opts.blockedSkillIds } : {})
     }) ?? {
       activeSkillIds: [],
       activations: [],
@@ -1237,6 +1357,9 @@ export class AgentLoop {
       memoryPolicy: { enabled: Boolean(this.opts.memoryStore) },
       delegationPolicy: { enabled: false },
       ...(allowedToolNames ? { allowedToolNames } : {}),
+      ...(this.opts.blockedProviderIds ? { blockedProviderIds: this.opts.blockedProviderIds } : {}),
+      ...(this.opts.blockedToolNames ? { blockedToolNames: this.opts.blockedToolNames } : {}),
+      ...(this.opts.blockedSkillIds ? { blockedSkillIds: this.opts.blockedSkillIds } : {}),
       approvalPolicy,
       sandboxMode,
       abortSignal: signal,
@@ -1340,6 +1463,7 @@ export class AgentLoop {
         tools: effectiveToolSpecs
       }),
       ...memoryInstructions(memories),
+      ...(skillResolution.catalogInstruction ? [skillResolution.catalogInstruction] : []),
       ...skillResolution.instructions,
       ...(userInputDisabled ? [userInputUnavailableInstruction()] : []),
       ...(effectiveToolSpecs.some((tool) => tool.name === 'bash') ? [shellRuntimeInstruction()] : []),
@@ -1355,7 +1479,15 @@ export class AgentLoop {
       turnId,
       model,
       ...(thread?.providerId?.trim() ? { providerId: thread.providerId.trim() } : {}),
-      systemPrompt: this.opts.prefix.systemPrompt,
+      // Thread-level systemPrompt (primary-agent persona snapshot) is
+      // appended to the runtime base — same augment strategy as child agents
+      // (child-agent-executor) — so the agent keeps kun's tool/safety
+      // conventions and skill catalog instead of losing them to the persona.
+      // Empty/whitespace falls back to the immutable prefix verbatim so
+      // unbound threads keep the prompt-cache fingerprint.
+      systemPrompt: thread?.systemPrompt?.trim()
+        ? `${this.opts.prefix.systemPrompt}\n\n${thread.systemPrompt.trim()}`
+        : this.opts.prefix.systemPrompt,
       ...(planTurnActive ? { modeInstruction: PLAN_MODE_INSTRUCTION } : {}),
       ...(contextInstructions.length ? { contextInstructions } : {}),
       prefix: this.opts.prefix.fewShots,
@@ -1766,6 +1898,34 @@ export class AgentLoop {
         this.lastNoToolTextByTurn.set(turnId, textAccumulator.value)
         return 'continue'
       }
+      if (stopReason === 'length') {
+        // The model hit its output-token ceiling and was cut off without a tool
+        // call. Don't report this as a clean completion — surface a warning so
+        // the truncation is visible instead of looking like the model "gave up".
+        const message =
+          'The model reached its maximum output length and the response was truncated. ' +
+          'Raise the model’s max output tokens, or ask it to continue or split the work into smaller steps.'
+        await this.opts.events.record({
+          kind: 'error',
+          threadId,
+          turnId,
+          message,
+          code: 'output_truncated',
+          severity: 'warning'
+        })
+        await this.opts.turns.applyItem(
+          threadId,
+          makeErrorItem({
+            id: this.opts.ids.next('item_error'),
+            turnId,
+            threadId,
+            message,
+            code: 'output_truncated',
+            severity: 'warning'
+          })
+        )
+        return 'stop'
+      }
       return 'stop'
     }
     // Tool calls mean the turn is making progress again; reset the no-tool
@@ -1961,6 +2121,9 @@ export class AgentLoop {
       memoryPolicy: { enabled: Boolean(this.opts.memoryStore) },
       delegationPolicy: { enabled: false },
       ...(input.allowedToolNames ? { allowedToolNames: input.allowedToolNames } : {}),
+      ...(this.opts.blockedProviderIds ? { blockedProviderIds: this.opts.blockedProviderIds } : {}),
+      ...(this.opts.blockedToolNames ? { blockedToolNames: this.opts.blockedToolNames } : {}),
+      ...(this.opts.blockedSkillIds ? { blockedSkillIds: this.opts.blockedSkillIds } : {}),
       approvalPolicy: input.approvalPolicy,
       sandboxMode: input.sandboxMode,
       abortSignal: input.signal,
@@ -2342,10 +2505,15 @@ export class AgentLoop {
       keepRecent: plan.keepRecent
     })
     if (result.replacedTokens > 0 && this.opts.contextCompaction?.summaryMode === 'model') {
+      const compactionModel = resolveCompactionModel({
+        contextCompaction: this.opts.contextCompaction,
+        fallbackModel: model
+      })
       const modelSummary = await summarizeCompactionWithModel({
         threadId,
         turnId,
-        model,
+        model: compactionModel.model,
+        ...(compactionModel.providerId ? { providerId: compactionModel.providerId } : {}),
         modelClient: this.opts.model,
         prefix: this.opts.prefix,
         contextCompaction: this.opts.contextCompaction,
@@ -2358,7 +2526,7 @@ export class AgentLoop {
             kind: 'usage',
             threadId,
             turnId,
-            model,
+            model: compactionModel.model,
             usage
           })
         },
diff --git a/kun/src/loop/compaction-summary.ts b/kun/src/loop/compaction-summary.ts
index 6e8d52136..fe7a9992e 100644
--- a/kun/src/loop/compaction-summary.ts
+++ b/kun/src/loop/compaction-summary.ts
@@ -2,16 +2,93 @@ import type { ImmutablePrefix } from '../cache/immutable-prefix.js'
 import type { TurnItem } from '../contracts/items.js'
 import type { UsageSnapshot } from '../contracts/usage.js'
 import type { ModelClient } from '../ports/model-client.js'
+import { trimTrailingToolCalls } from './context-compactor.js'
 import type { ContextCompactionConfig } from './model-context-profile.js'
 
 export const DEFAULT_COMPACTION_SUMMARY_TIMEOUT_MS = 15_000
-export const DEFAULT_COMPACTION_SUMMARY_MAX_TOKENS = 1_200
+export const DEFAULT_COMPACTION_SUMMARY_MAX_TOKENS = 2_048
+/** @deprecated The compaction-mode path feeds real conversation messages, not a byte-capped transcript. Kept for config back-compat. */
 export const DEFAULT_COMPACTION_SUMMARY_INPUT_MAX_BYTES = 96 * 1024
 
+/**
+ * System prompt for the dedicated "compaction mode" turn. Ported from
+ * opencode's compaction agent (`agent/prompt/compaction.txt`) and adapted
+ * for kun's coding-agent context: the model reads the actual conversation
+ * (fed as real messages, not a serialized transcript) and writes a free-form
+ * handoff summary so work can continue past the context window.
+ */
+export const COMPACTION_SYSTEM_PROMPT = [
+  'You are summarizing a long coding-agent conversation so the work can continue past the context window.',
+  '',
+  'Provide a detailed but concise summary. Focus on information that would be helpful for continuing the work, including:',
+  '- What was requested and the overall goal',
+  '- What has been done and the decisions that were made (and why)',
+  '- Which files are being created, edited, or inspected (with their paths)',
+  '- Key technical findings: root causes, data values, API shapes, commands run and their results',
+  '- What still needs to be done next',
+  '- User requests, constraints, and preferences that must persist',
+  '',
+  'Preserve concrete identifiers verbatim: file paths, function and variable names, commands, URLs, IDs, and error messages.',
+  'Do not invent facts and do not add generic advice. Write in the same language as the conversation.',
+  'Your summary should be comprehensive enough to provide full context but concise enough to be quickly understood.'
+].join('\n')
+
+/**
+ * Free-form continuation prompt appended as the final user message of the
+ * compaction turn. Ported from opencode's default compaction prompt; the new
+ * session has no access to the conversation above, so the model is asked to
+ * write a self-contained handoff. Optional pinned constraints are appended so
+ * durable rules survive even in the free-form summary text.
+ */
+export function buildCompactionContinuationMessage(pinnedConstraints?: readonly string[]): string {
+  const lines = [
+    'Provide a detailed summary of our conversation above, written so a new session with no access to ' +
+      'this history can continue the work seamlessly. Cover what we set out to do, what has been done, ' +
+      'which files and locations are involved, the key findings and decisions, and what remains to be done next. ' +
+      'Preserve concrete identifiers (file paths, function/variable names, commands, URLs, IDs, error messages) verbatim.'
+  ]
+  const pins = (pinnedConstraints ?? []).map((pin) => pin.trim()).filter((pin) => pin.length > 0)
+  if (pins.length > 0) {
+    lines.push('')
+    lines.push('Durable constraints that MUST be preserved in your summary:')
+    for (const pin of pins) lines.push(`- ${pin}`)
+  }
+  return lines.join('\n')
+}
+
+/**
+ * Resolve the model + provider for the compaction-mode turn. Mirrors
+ * opencode's compaction agent precedence: an explicit compaction model
+ * override (`contextCompaction.summaryModel`) wins, otherwise it falls back to
+ * the main conversation model. Unlike one-shot roles (title/session-summary)
+ * it does NOT drop to the small model — a faithful handoff summary wants the
+ * same capability as the conversation it is folding.
+ */
+export function resolveCompactionModel(input: {
+  contextCompaction?: ContextCompactionConfig
+  fallbackModel: string
+}): { model: string; providerId?: string } {
+  const override = input.contextCompaction?.summaryModel?.trim()
+  if (override) {
+    const providerId = input.contextCompaction?.summaryProviderId?.trim()
+    return { model: override, ...(providerId ? { providerId } : {}) }
+  }
+  return { model: input.fallbackModel }
+}
+
+/**
+ * Run the dedicated compaction-mode turn. The real conversation `items` are
+ * fed to the model as messages (mirroring opencode's compaction agent),
+ * followed by a free-form continuation prompt; the model returns a natural
+ * handoff summary. Returns `undefined` on timeout / error / empty output so
+ * the caller falls back to the heuristic summary.
+ */
 export async function summarizeCompactionWithModel(input: {
   threadId: string
   turnId: string
   model: string
+  /** Optional per-provider routing id paired with `model`. */
+  providerId?: string
   modelClient: ModelClient
   prefix: ImmutablePrefix
   contextCompaction?: ContextCompactionConfig
@@ -37,8 +114,12 @@ export async function summarizeCompactionWithModel(input: {
     await input.recordFallback?.(message)
   }
   try {
-    const requestItem = {
-      id: `item_${input.turnId}_compaction_summary_request`,
+    // Feed the real conversation as model messages (compaction mode), not a
+    // serialized transcript. Trailing tool calls without results are dropped
+    // so the request stays well-formed for OpenAI-compatible providers.
+    const conversation = trimTrailingToolCalls(input.items)
+    const continuationItem: TurnItem = {
+      id: `item_${input.turnId}_compaction_continuation`,
       turnId: input.turnId,
       threadId: input.threadId,
       role: 'user' as const,
@@ -46,23 +127,19 @@ export async function summarizeCompactionWithModel(input: {
       createdAt: new Date().toISOString(),
       finishedAt: new Date().toISOString(),
       kind: 'user_message' as const,
-      text: buildModelCompactionPrompt({
-        items: input.items,
-        heuristicSummary: input.heuristicSummary,
-        maxBytes: input.contextCompaction?.summaryInputMaxBytes ?? DEFAULT_COMPACTION_SUMMARY_INPUT_MAX_BYTES
-      })
+      text: buildCompactionContinuationMessage(input.prefix.pinnedConstraints)
     }
     let text = ''
     for await (const chunk of input.modelClient.stream({
       threadId: input.threadId,
       turnId: input.turnId,
       model: input.model,
-      systemPrompt: input.prefix.systemPrompt,
-      contextInstructions: [
-        'Summarize context for a history fold. Preserve durable task state and omit transient chatter.'
-      ],
-      prefix: input.prefix.fewShots,
-      history: [requestItem],
+      ...(input.providerId ? { providerId: input.providerId } : {}),
+      // Dedicated compaction-mode system prompt; the main agent prefix and
+      // few-shots are intentionally dropped so this is a clean summarizer turn.
+      systemPrompt: COMPACTION_SYSTEM_PROMPT,
+      prefix: [],
+      history: [...conversation, continuationItem],
       tools: [],
       stream: true,
       maxTokens: Math.max(
@@ -107,99 +184,3 @@ export async function summarizeCompactionWithModel(input: {
     input.signal.removeEventListener('abort', onAbort)
   }
 }
-
-export function buildModelCompactionPrompt(input: {
-  items: readonly TurnItem[]
-  heuristicSummary: string
-  maxBytes: number
-}): string {
-  const transcript = fitTextToBytes(
-    input.items
-      .map(compactionPromptLine)
-      .filter((line) => line.length > 0)
-      .join('\n'),
-    Math.max(1_024, input.maxBytes)
-  )
-  return [
-    'You are compacting a long agent conversation so work can continue past the context window.',
-    'Write a dense, factual handoff summary using EXACTLY the following section headers, in this order.',
-    'Keep every section; write "- (none)" when a section has no content. Use short bullets, not prose.',
-    'Do not invent facts, do not add generic advice, and preserve concrete identifiers verbatim',
-    '(file paths, function/variable names, commands, URLs, IDs, error messages).',
-    '',
-    '## Goal',
-    "- The user's overall objective and any explicit requirements or constraints.",
-    '## Completed',
-    '- Work already done and decisions made, with the concrete outcome of each.',
-    '## Key findings',
-    '- Important facts discovered (root causes, data values, API shapes) needed to continue.',
-    '## Files & locations',
-    '- Files created/edited/inspected and the relevant paths or line ranges.',
-    '## Tool & command results',
-    '- Notable tool/command outcomes, especially errors and their resolution status.',
-    '## Pending',
-    '- Unresolved next steps and anything explicitly requested but not yet done.',
-    '## Constraints & pins',
-    '- Durable rules, user preferences, and active/pinned skills that must survive.',
-    '',
-    'Existing heuristic summary to cross-check (may be incomplete):',
-    input.heuristicSummary.trim() || '(none)',
-    '',
-    'Conversation history to fold:',
-    transcript || '(empty)'
-  ].join('\n')
-}
-
-function compactionPromptLine(item: TurnItem): string {
-  switch (item.kind) {
-    case 'user_message':
-      return `[user] ${clipForPrompt(item.text, 2_000)}`
-    case 'assistant_text':
-      return `[assistant] ${clipForPrompt(item.text, 2_000)}`
-    case 'assistant_reasoning':
-      return ''
-    case 'tool_call':
-      return `[tool_call:${item.toolName}] ${clipForPrompt(item.summary || stringifyForPrompt(item.arguments), 1_200)}`
-    case 'tool_result':
-      return `[tool_result:${item.toolName}${item.isError ? ':error' : ''}] ${clipForPrompt(stringifyForPrompt(item.output), 2_000)}`
-    case 'approval':
-      return `[approval:${item.status}:${item.toolName}] ${clipForPrompt(item.summary, 800)}`
-    case 'user_input':
-      return `[user_input:${item.status}] ${clipForPrompt(item.prompt, 800)}`
-    case 'compaction':
-      return item.replacedTokens > 0 ? `[compaction] ${clipForPrompt(item.summary, 2_000)}` : ''
-    case 'review':
-      return `[review:${item.title}] ${clipForPrompt(item.reviewText || stringifyForPrompt(item.output), 2_000)}`
-    case 'error':
-      return `[error${item.code ? `:${item.code}` : ''}] ${clipForPrompt(item.message, 1_200)}`
-  }
-}
-
-function stringifyForPrompt(value: unknown): string {
-  if (typeof value === 'string') return value
-  if (value == null) return ''
-  try {
-    return JSON.stringify(value)
-  } catch {
-    return String(value)
-  }
-}
-
-function clipForPrompt(text: string, maxChars: number): string {
-  const compact = text.replace(/\s+/g, ' ').trim()
-  if (compact.length <= maxChars) return compact
-  return `${compact.slice(0, Math.max(0, maxChars - 3)).trim()}...`
-}
-
-function fitTextToBytes(text: string, maxBytes: number): string {
-  if (Buffer.byteLength(text, 'utf8') <= maxBytes) return text
-  let used = 0
-  let out = ''
-  for (const char of text) {
-    const bytes = Buffer.byteLength(char, 'utf8')
-    if (used + bytes > maxBytes) break
-    out += char
-    used += bytes
-  }
-  return `${out.trimEnd()}\n...[truncated for model compaction summary]`
-}
diff --git a/kun/src/loop/model-context-profile.ts b/kun/src/loop/model-context-profile.ts
index fca670e38..f80a3a797 100644
--- a/kun/src/loop/model-context-profile.ts
+++ b/kun/src/loop/model-context-profile.ts
@@ -61,6 +61,10 @@ export type ContextCompactionConfig = {
   summaryTimeoutMs?: number
   summaryMaxTokens?: number
   summaryInputMaxBytes?: number
+  /** Optional model override for compaction summary (empty = follow main model). */
+  summaryModel?: string
+  /** Provider id paired with summaryModel. */
+  summaryProviderId?: string
   /**
    * @deprecated Model-specific context windows and compaction thresholds belong
    * in top-level models.profiles. This field is still read for compatibility.
diff --git a/kun/src/loop/reasoning-effort.ts b/kun/src/loop/reasoning-effort.ts
new file mode 100644
index 000000000..de3ebedce
--- /dev/null
+++ b/kun/src/loop/reasoning-effort.ts
@@ -0,0 +1,11 @@
+import { ModelReasoningEffort } from '../contracts/capabilities.js'
+
+/**
+ * Normalize a configured per-role reasoning-depth value into a valid
+ * ModelReasoningEffort. Invalid or missing values fall back to 'off' so the
+ * cheap default never accidentally escalates a title/summary/review call.
+ */
+export function normalizeRoleReasoningEffort(value: string | undefined): ModelReasoningEffort {
+  const parsed = ModelReasoningEffort.safeParse(typeof value === 'string' ? value.trim() : value)
+  return parsed.success ? parsed.data : 'off'
+}
diff --git a/kun/src/loop/session-summary.ts b/kun/src/loop/session-summary.ts
new file mode 100644
index 000000000..46d01edbb
--- /dev/null
+++ b/kun/src/loop/session-summary.ts
@@ -0,0 +1,150 @@
+import type { TurnItem } from '../contracts/items.js'
+import type { ModelClient, ModelRequest } from '../ports/model-client.js'
+import { normalizeRoleReasoningEffort } from './reasoning-effort.js'
+
+export const DEFAULT_SESSION_SUMMARY_TIMEOUT_MS = 20_000
+export const DEFAULT_SESSION_SUMMARY_MAX_TOKENS = 400
+export const DEFAULT_SESSION_SUMMARY_INPUT_MAX_BYTES = 96 * 1024
+
+const SESSION_SUMMARY_SYSTEM_PROMPT = [
+  'You write a short, neutral summary of an entire chat conversation.',
+  'Output rules:',
+  '- Output ONE paragraph (roughly 2-4 sentences). No headings, no bullet lists, no markdown.',
+  "- Describe what the user wanted and what was accomplished or concluded.",
+  '- Do not invent facts. Do not include tool names or raw code.',
+  "- Write in the same language as the conversation."
+].join('\n')
+
+/**
+ * One-shot internal LLM call producing a ~1-paragraph whole-conversation
+ * summary from the full transcript. Mirrors the compaction-summary one-shot
+ * pattern. Returns undefined on any failure / empty output.
+ */
+export async function generateSessionSummary(input: {
+  threadId: string
+  modelClient: ModelClient
+  /** Resolved model id for the summary role (see resolveRoleModel). */
+  model: string
+  /** Optional per-provider routing id. */
+  providerId?: string
+  systemPrompt?: string
+  /** Full conversation transcript items, oldest first. */
+  items: readonly TurnItem[]
+  /** Reasoning depth for the summary call. Invalid/missing => 'off'. */
+  reasoningEffort?: string
+  timeoutMs?: number
+  maxTokens?: number
+  inputMaxBytes?: number
+  abortSignal?: AbortSignal
+}): Promise<string | undefined> {
+  if (input.abortSignal?.aborted) return undefined
+  const transcript = buildSessionTranscript(input.items, input.inputMaxBytes ?? DEFAULT_SESSION_SUMMARY_INPUT_MAX_BYTES)
+  if (!transcript.trim()) return undefined
+
+  const timeoutMs = Math.max(1, Math.floor(input.timeoutMs ?? DEFAULT_SESSION_SUMMARY_TIMEOUT_MS))
+  const controller = new AbortController()
+  const onAbort = (): void => controller.abort()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  input.abortSignal?.addEventListener('abort', onAbort, { once: true })
+
+  try {
+    const turnId = `${input.threadId}_session_summary`
+    const requestItem: TurnItem = {
+      id: `item_${turnId}_request`,
+      turnId,
+      threadId: input.threadId,
+      role: 'user',
+      status: 'completed',
+      createdAt: new Date().toISOString(),
+      finishedAt: new Date().toISOString(),
+      kind: 'user_message',
+      text: ['Conversation transcript:', transcript, '', 'Write the one-paragraph summary now.'].join('\n')
+    }
+    const request: ModelRequest = {
+      threadId: input.threadId,
+      turnId,
+      model: input.model,
+      ...(input.providerId ? { providerId: input.providerId } : {}),
+      ...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
+      contextInstructions: [SESSION_SUMMARY_SYSTEM_PROMPT],
+      prefix: [],
+      history: [requestItem],
+      tools: [],
+      stream: true,
+      maxTokens: Math.max(1, Math.floor(input.maxTokens ?? DEFAULT_SESSION_SUMMARY_MAX_TOKENS)),
+      temperature: 0,
+      reasoningEffort: normalizeRoleReasoningEffort(input.reasoningEffort),
+      abortSignal: controller.signal
+    }
+    let text = ''
+    for await (const chunk of input.modelClient.stream(request)) {
+      if (input.abortSignal?.aborted || controller.signal.aborted) return undefined
+      if (chunk.kind === 'assistant_text_delta') text += chunk.text
+      if (chunk.kind === 'error') return undefined
+    }
+    const summary = text.replace(/\s+/g, ' ').trim()
+    return summary || undefined
+  } catch {
+    return undefined
+  } finally {
+    clearTimeout(timeout)
+    input.abortSignal?.removeEventListener('abort', onAbort)
+  }
+}
+
+export function buildSessionTranscript(items: readonly TurnItem[], maxBytes: number): string {
+  const text = items
+    .map(transcriptLine)
+    .filter((line) => line.length > 0)
+    .join('\n')
+  return fitTextToBytes(text, Math.max(1_024, maxBytes))
+}
+
+function transcriptLine(item: TurnItem): string {
+  switch (item.kind) {
+    case 'user_message':
+      return `[user] ${clip(item.text, 2_000)}`
+    case 'assistant_text':
+      return `[assistant] ${clip(item.text, 2_000)}`
+    case 'tool_call':
+      return `[tool_call:${item.toolName}] ${clip(item.summary || stringify(item.arguments), 600)}`
+    case 'tool_result':
+      return `[tool_result:${item.toolName}${item.isError ? ':error' : ''}] ${clip(stringify(item.output), 800)}`
+    case 'compaction':
+      return item.replacedTokens > 0 ? `[earlier summary] ${clip(item.summary, 2_000)}` : ''
+    case 'review':
+      return `[review:${item.title}] ${clip(item.reviewText || stringify(item.output), 1_200)}`
+    case 'error':
+      return `[error${item.code ? `:${item.code}` : ''}] ${clip(item.message, 600)}`
+    default:
+      return ''
+  }
+}
+
+function stringify(value: unknown): string {
+  if (typeof value === 'string') return value
+  if (value == null) return ''
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+
+function clip(text: string, maxChars: number): string {
+  const compact = text.replace(/\s+/g, ' ').trim()
+  return compact.length <= maxChars ? compact : `${compact.slice(0, Math.max(0, maxChars - 3)).trim()}...`
+}
+
+function fitTextToBytes(text: string, maxBytes: number): string {
+  if (Buffer.byteLength(text, 'utf8') <= maxBytes) return text
+  let used = 0
+  let out = ''
+  for (const char of text) {
+    const bytes = Buffer.byteLength(char, 'utf8')
+    if (used + bytes > maxBytes) break
+    out += char
+    used += bytes
+  }
+  return `${out.trimEnd()}\n...[truncated]`
+}
diff --git a/kun/src/loop/title-generator.ts b/kun/src/loop/title-generator.ts
new file mode 100644
index 000000000..00425ef11
--- /dev/null
+++ b/kun/src/loop/title-generator.ts
@@ -0,0 +1,157 @@
+import type { TurnItem } from '../contracts/items.js'
+import type { ModelClient, ModelRequest } from '../ports/model-client.js'
+import type { RolesConfig } from '../config/kun-config.js'
+import { normalizeRoleReasoningEffort } from './reasoning-effort.js'
+
+export const DEFAULT_TITLE_TIMEOUT_MS = 12_000
+export const DEFAULT_TITLE_MAX_TOKENS = 64
+export const MAX_TITLE_CHARS = 50
+const MAX_TITLE_INPUT_CHARS = 4_000
+
+const TITLE_SYSTEM_PROMPT = [
+  'You generate a concise title for a chat conversation.',
+  'Output rules:',
+  '- Output ONLY the title text on a single line. No quotes, no markdown, no prefix like "Title:".',
+  `- Maximum ${MAX_TITLE_CHARS} characters.`,
+  '- Summarize the user\'s intent, not the assistant\'s actions.',
+  '- Never include tool names, file paths, code, or punctuation-only output.',
+  '- Write in the same language as the user\'s message.'
+].join('\n')
+
+/**
+ * Resolve the model + providerId for a one-shot internal role call using the
+ * precedence: role override -> global smallModel -> main conversation model.
+ * Returns undefined when no model is resolvable at all.
+ */
+export function resolveRoleModel(input: {
+  roleModel?: string
+  roleProviderId?: string
+  roles?: RolesConfig
+  mainModel?: string
+  mainProviderId?: string
+}): { model: string; providerId?: string } | undefined {
+  const role = trim(input.roleModel)
+  if (role) {
+    return { model: role, ...(trim(input.roleProviderId) ? { providerId: trim(input.roleProviderId) } : {}) }
+  }
+  const small = trim(input.roles?.smallModel)
+  if (small) {
+    return { model: small, ...(trim(input.roles?.smallModelProviderId) ? { providerId: trim(input.roles?.smallModelProviderId) } : {}) }
+  }
+  const main = trim(input.mainModel)
+  if (main) {
+    return { model: main, ...(trim(input.mainProviderId) ? { providerId: trim(input.mainProviderId) } : {}) }
+  }
+  return undefined
+}
+
+/**
+ * One-shot internal LLM call that produces a single-line thread title.
+ * Mirrors the compaction-summary one-shot pattern (timeout + abort + collect
+ * text). Returns undefined on any failure so callers can silently keep the
+ * existing default title.
+ */
+export async function generateThreadTitle(input: {
+  threadId: string
+  turnId: string
+  modelClient: ModelClient
+  /** Resolved model id for the title role (see resolveRoleModel). */
+  model: string
+  /** Optional per-provider routing id. */
+  providerId?: string
+  systemPrompt?: string
+  /** First user message text (intent). Required for a meaningful title. */
+  userText: string
+  /** First assistant reply text. Optional supporting context. */
+  assistantText?: string
+  /** Reasoning depth for the title call. Invalid/missing => 'off'. */
+  reasoningEffort?: string
+  timeoutMs?: number
+  abortSignal?: AbortSignal
+}): Promise<string | undefined> {
+  const userText = trim(input.userText)
+  if (!userText) return undefined
+  if (input.abortSignal?.aborted) return undefined
+
+  const timeoutMs = Math.max(1, Math.floor(input.timeoutMs ?? DEFAULT_TITLE_TIMEOUT_MS))
+  const controller = new AbortController()
+  const onAbort = (): void => controller.abort()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  input.abortSignal?.addEventListener('abort', onAbort, { once: true })
+
+  try {
+    const promptText = buildTitlePrompt(userText, input.assistantText)
+    const requestItem: TurnItem = {
+      id: `item_${input.turnId}_title_request`,
+      turnId: input.turnId,
+      threadId: input.threadId,
+      role: 'user',
+      status: 'completed',
+      createdAt: new Date().toISOString(),
+      finishedAt: new Date().toISOString(),
+      kind: 'user_message',
+      text: promptText
+    }
+    const request: ModelRequest = {
+      threadId: input.threadId,
+      turnId: `${input.turnId}_title`,
+      model: input.model,
+      ...(input.providerId ? { providerId: input.providerId } : {}),
+      ...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
+      contextInstructions: [TITLE_SYSTEM_PROMPT],
+      prefix: [],
+      history: [requestItem],
+      tools: [],
+      stream: true,
+      maxTokens: DEFAULT_TITLE_MAX_TOKENS,
+      temperature: 0,
+      reasoningEffort: normalizeRoleReasoningEffort(input.reasoningEffort),
+      abortSignal: controller.signal
+    }
+    let text = ''
+    for await (const chunk of input.modelClient.stream(request)) {
+      if (input.abortSignal?.aborted || controller.signal.aborted) return undefined
+      if (chunk.kind === 'assistant_text_delta') text += chunk.text
+      if (chunk.kind === 'error') return undefined
+    }
+    return sanitizeTitle(text)
+  } catch {
+    return undefined
+  } finally {
+    clearTimeout(timeout)
+    input.abortSignal?.removeEventListener('abort', onAbort)
+  }
+}
+
+function buildTitlePrompt(userText: string, assistantText?: string): string {
+  const lines = ['User message:', clip(userText, MAX_TITLE_INPUT_CHARS)]
+  const assistant = trim(assistantText)
+  if (assistant) {
+    lines.push('', 'Assistant reply (for context only):', clip(assistant, 1_000))
+  }
+  lines.push('', `Title (single line, <= ${MAX_TITLE_CHARS} chars):`)
+  return lines.join('\n')
+}
+
+/** Strip quotes/markdown/leading "Title:" and clamp to the char cap. */
+export function sanitizeTitle(raw: string): string | undefined {
+  let title = raw.replace(/\r/g, '').split('\n').map((line) => line.trim()).find((line) => line.length > 0) ?? ''
+  title = title.replace(/^title\s*[:：]\s*/i, '')
+  title = title.replace(/^["'“”『』「」]+|["'“”『』「」]+$/g, '')
+  title = title.replace(/^#+\s*/, '').replace(/^\*+|\*+$/g, '')
+  title = title.replace(/\s+/g, ' ').trim()
+  if (!title) return undefined
+  if (title.length > MAX_TITLE_CHARS) {
+    title = title.slice(0, MAX_TITLE_CHARS).trim()
+  }
+  return title || undefined
+}
+
+function clip(text: string, maxChars: number): string {
+  const compact = text.replace(/\s+/g, ' ').trim()
+  return compact.length <= maxChars ? compact : `${compact.slice(0, Math.max(0, maxChars - 3)).trim()}...`
+}
+
+function trim(value: string | undefined): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
diff --git a/kun/src/ports/tool-host.ts b/kun/src/ports/tool-host.ts
index d849a5c33..2dd1669be 100644
--- a/kun/src/ports/tool-host.ts
+++ b/kun/src/ports/tool-host.ts
@@ -82,6 +82,12 @@ export type ToolHostContext = {
   allowedProviderIds?: readonly string[]
   /** Optional tool-name allow-list. When set, other tools are not advertised or executed. */
   allowedToolNames?: readonly string[]
+  /** Optional provider deny-list. Providers listed here are never advertised or executed (deny-list layered on inherit). */
+  blockedProviderIds?: readonly string[]
+  /** Optional tool-name deny-list. Tools listed here are never advertised or executed (deny-list layered on inherit). */
+  blockedToolNames?: readonly string[]
+  /** Optional skill-id deny-list for this turn: hides skills from the catalog + auto-activation and rejects `load_skill`. */
+  blockedSkillIds?: readonly string[]
   approvalPolicy: ApprovalPolicy
   /** Filesystem/command sandbox selected for this turn. Defaults at execution time for old callers. */
   sandboxMode?: SandboxMode
diff --git a/kun/src/server/routes/approvals.ts b/kun/src/server/routes/approvals.ts
index 43157c19e..6ae8d6534 100644
--- a/kun/src/server/routes/approvals.ts
+++ b/kun/src/server/routes/approvals.ts
@@ -28,6 +28,24 @@ export async function decideApproval(input: {
   if (!approval) {
     return ERRORS.notFound(`approval not found: ${input.approvalId}`)
   }
+  if (approval.status !== 'pending') {
+    const resolvedDecision =
+      approval.status === 'allowed'
+        ? 'allow'
+        : approval.status === 'denied'
+          ? 'deny'
+          : null
+    if (resolvedDecision && resolvedDecision === parsed.data.decision) {
+      const response: ApprovalDecisionResponse = {
+        approvalId: input.approvalId,
+        decision: parsed.data.decision,
+        status: approval.status,
+        alreadyResolved: true
+      }
+      return jsonResponse(response)
+    }
+    return ERRORS.conflict(`approval already decided: ${input.approvalId}`)
+  }
   const ok = input.gate.decide(input.approvalId, parsed.data.decision, parsed.data.reason)
   if (!ok) {
     return ERRORS.conflict(`approval already decided: ${input.approvalId}`)
diff --git a/kun/src/server/routes/delegation.ts b/kun/src/server/routes/delegation.ts
new file mode 100644
index 000000000..ce8b0b141
--- /dev/null
+++ b/kun/src/server/routes/delegation.ts
@@ -0,0 +1,65 @@
+import type { DelegationRuntime } from '../../delegation/delegation-runtime.js'
+import { jsonResponse, type JsonResponse } from '../response.js'
+import { ERRORS } from './runtime-error.js'
+
+/**
+ * GET /v1/delegation/diagnostics
+ *
+ * Returns a snapshot of all child runs (queued/running/completed/failed/
+ * aborted) tracked by the delegation runtime. Optional `parentThreadId`
+ * query param filters by parent thread.
+ *
+ * Used by the GUI SubagentsView to show realtime status per profile.
+ */
+export async function delegationDiagnostics(
+  runtime: DelegationRuntime | undefined,
+  request: Request
+): Promise<JsonResponse> {
+  if (!runtime) {
+    return jsonResponse({
+      enabled: false,
+      active: 0,
+      childRuns: [],
+      aggregates: []
+    })
+  }
+  const url = new URL(request.url)
+  const parent = url.searchParams.get('parent_thread_id') ?? undefined
+  return jsonResponse(await runtime.diagnostics(parent))
+}
+
+/**
+ * GET /v1/delegation/profiles
+ *
+ * Returns the merged profile roster (builtin + GUI + future workspace
+ * markdown overlay). Lighter than diagnostics — pure config snapshot.
+ */
+export async function delegationProfiles(
+  runtime: DelegationRuntime | undefined
+): Promise<JsonResponse> {
+  if (!runtime) {
+    return jsonResponse({ profiles: [], defaultProfile: undefined })
+  }
+  return jsonResponse({
+    profiles: runtime.listProfiles(),
+    defaultProfile: runtime.defaultProfileName
+  })
+}
+
+/**
+ * POST /v1/delegation/abort/:childId
+ *
+ * Cancel a detached (background) child run. Synchronous runs are
+ * unaffected — abort their parent turn instead.
+ */
+export async function delegationAbort(
+  runtime: DelegationRuntime | undefined,
+  childId: string
+): Promise<JsonResponse> {
+  if (!runtime) return ERRORS.unavailable('delegation runtime is unavailable')
+  if (!childId.trim()) return ERRORS.validation('childId is required', [])
+  const aborted = runtime.abortChild(childId)
+  return jsonResponse({ childId, aborted })
+}
+
+export { ERRORS as DelegationErrors }
diff --git a/kun/src/server/routes/index.ts b/kun/src/server/routes/index.ts
index 9c30c5fe5..72e5cb3dc 100644
--- a/kun/src/server/routes/index.ts
+++ b/kun/src/server/routes/index.ts
@@ -15,6 +15,7 @@ import {
   setThreadTodos,
   updateThread
 } from './threads.js'
+import { summarizeThread } from './threads-summarize.js'
 import {
   compactTurn,
   getTurn,
@@ -45,6 +46,11 @@ import {
   memoryDiagnostics,
   updateMemory
 } from './memory.js'
+import {
+  delegationAbort,
+  delegationDiagnostics,
+  delegationProfiles
+} from './delegation.js'
 import { isAuthorized, bearerToken } from '../auth.js'
 import { ERRORS } from './runtime-error.js'
 import type { ServerRuntime } from './server-runtime.js'
@@ -59,10 +65,13 @@ import type { ServerRuntime } from './server-runtime.js'
  * - `GET /v1/attachments/diagnostics` (auth)
  * - `GET /v1/attachments/{id}` and `{id}/content` (auth)
  * - `GET/POST /v1/memory`, `PATCH/DELETE /v1/memory/{id}`, diagnostics (auth)
+ * - `GET /v1/delegation/diagnostics` and `/v1/delegation/profiles` (auth)
+ * - `POST /v1/delegation/abort/{childId}` (auth)
  * - `GET /v1/workspace/status` (auth)
  * - `GET/POST /v1/threads` (auth)
  * - `GET/PATCH/DELETE /v1/threads/{id}` (auth)
  * - `POST /v1/threads/{id}/fork` (auth)
+ * - `POST /v1/threads/{id}/summarize` (auth)
  * - `GET/POST/DELETE /v1/threads/{id}/goal` (auth)
  * - `GET/POST/DELETE /v1/threads/{id}/todos` (auth)
  * - `POST /v1/threads/{id}/turns` (auth)
@@ -129,6 +138,18 @@ export function buildRouter(runtime: ServerRuntime): Router {
     if (!authorize(request, runtime)) return ERRORS.unauthorized()
     return deleteMemory(runtime.memoryStore, ctx.params.id, request)
   })
+  router.add('GET', '/v1/delegation/diagnostics', async (request) => {
+    if (!authorize(request, runtime)) return ERRORS.unauthorized()
+    return delegationDiagnostics(runtime.delegationRuntime, request)
+  })
+  router.add('GET', '/v1/delegation/profiles', async (request) => {
+    if (!authorize(request, runtime)) return ERRORS.unauthorized()
+    return delegationProfiles(runtime.delegationRuntime)
+  })
+  router.add('POST', '/v1/delegation/abort/:childId', async (request, ctx) => {
+    if (!authorize(request, runtime)) return ERRORS.unauthorized()
+    return delegationAbort(runtime.delegationRuntime, ctx.params.childId)
+  })
   router.add('GET', '/v1/workspace/status', async (request) => {
     if (!authorize(request, runtime)) return ERRORS.unauthorized()
     const url = new URL(request.url)
@@ -159,6 +180,10 @@ export function buildRouter(runtime: ServerRuntime): Router {
     if (!authorize(request, runtime)) return ERRORS.unauthorized()
     return forkThread(runtime.threadService, ctx.params.id, request)
   })
+  router.add('POST', '/v1/threads/:id/summarize', async (request, ctx) => {
+    if (!authorize(request, runtime)) return ERRORS.unauthorized()
+    return summarizeThread(runtime, ctx.params.id, request)
+  })
   router.add('GET', '/v1/threads/:id/goal', async (request, ctx) => {
     if (!authorize(request, runtime)) return ERRORS.unauthorized()
     return getThreadGoal(runtime.threadService, ctx.params.id)
diff --git a/kun/src/server/routes/server-runtime.ts b/kun/src/server/routes/server-runtime.ts
index cf5e212d5..74ca31329 100644
--- a/kun/src/server/routes/server-runtime.ts
+++ b/kun/src/server/routes/server-runtime.ts
@@ -26,6 +26,10 @@ import type { AttachmentStore } from '../../attachments/attachment-store.js'
 import type { MemoryDiagnostics } from '../../contracts/memory.js'
 import type { MemoryStore } from '../../memory/memory-store.js'
 import type { ReviewTarget } from '../../contracts/review.js'
+import type { DelegationRuntime } from '../../delegation/delegation-runtime.js'
+import type { ModelClient } from '../../ports/model-client.js'
+import type { RolesConfig } from '../../config/kun-config.js'
+import type { ImmutablePrefix } from '../../cache/immutable-prefix.js'
 
 export type RuntimeToolDiagnostics = {
   providers: ToolProviderPolicy[]
@@ -62,6 +66,29 @@ export type ServerRuntime = {
   toolHost?: ToolHost
   attachmentStore?: AttachmentStore
   memoryStore?: MemoryStore
+  /**
+   * Active delegation runtime exposed for diagnostics + agent profile
+   * listing. Optional so test scaffolds can omit it.
+   */
+  delegationRuntime?: DelegationRuntime
+  /**
+   * Default ModelClient + model id for one-shot completions outside the
+   * agent loop (e.g. AI-generated subagent profiles). Optional so test
+   * scaffolds can omit it.
+   */
+  modelClient?: ModelClient
+  defaultModel?: string
+  /**
+   * Internal-LLM role model routing. Used by on-demand routes (e.g. session
+   * summary) to resolve the summary/title/codeReview model precedence
+   * (role override -> smallModel -> defaultModel). Optional for test scaffolds.
+   */
+  roles?: RolesConfig
+  /**
+   * Immutable prefix (systemPrompt + few-shots + fingerprint). Exposed so
+   * one-shot internal routes can reuse the runtime's systemPrompt. Optional.
+   */
+  immutablePrefix?: ImmutablePrefix
   runTurn(threadId: string, turnId: string): Promise<'completed' | 'failed' | 'aborted'> | void
   /**
    * Relaunch goal continuation turns for threads whose in-flight turn was
diff --git a/kun/src/server/routes/threads-summarize.ts b/kun/src/server/routes/threads-summarize.ts
new file mode 100644
index 000000000..d1d6bfba0
--- /dev/null
+++ b/kun/src/server/routes/threads-summarize.ts
@@ -0,0 +1,89 @@
+import { z } from 'zod'
+import { jsonResponse, type JsonResponse } from '../response.js'
+import { readJsonBody } from '../read-json-body.js'
+import { ERRORS } from './runtime-error.js'
+import { generateSessionSummary } from '../../loop/session-summary.js'
+import { resolveRoleModel } from '../../loop/title-generator.js'
+import type { ServerRuntime } from './server-runtime.js'
+
+const SummarizeThreadRequest = z
+  .object({
+    /** Optional per-request model override (falls back to summary role precedence). */
+    model: z.string().min(1).optional(),
+    providerId: z.string().min(1).optional()
+  })
+  .optional()
+
+export const SummarizeThreadResponse = z.object({
+  id: z.string(),
+  summary: z.string()
+})
+export type SummarizeThreadResponse = z.infer<typeof SummarizeThreadResponse>
+
+/**
+ * On-demand whole-session summary. Reads the full transcript, runs the Summary
+ * internal-LLM role (precedence: summaryModel -> smallModel -> main model),
+ * persists the result onto the thread (`summary` field) and returns it. NOT
+ * triggered automatically — the renderer calls this from a "summarize" action.
+ *
+ * Route: POST /v1/threads/:id/summarize
+ */
+export async function summarizeThread(
+  runtime: ServerRuntime,
+  threadId: string,
+  request: Request
+): Promise<JsonResponse | Response> {
+  const body = await readJsonBody(request)
+  if (!body.ok) return body.response
+  // An empty object body is valid (no overrides); coerce {} -> undefined.
+  const rawBody = body.value && typeof body.value === 'object' && Object.keys(body.value).length === 0
+    ? undefined
+    : body.value
+  const parsed = SummarizeThreadRequest.safeParse(rawBody)
+  if (!parsed.success) return ERRORS.validation('invalid summarize body', parsed.error.issues)
+
+  if (!runtime.modelClient) return ERRORS.unavailable('model client is unavailable')
+
+  const thread = await runtime.threadService.get(threadId)
+  if (!thread) return ERRORS.notFound(`thread not found: ${threadId}`)
+
+  const items = await runtime.sessionStore.loadItems(threadId)
+  if (!items.some((item) => item.kind === 'user_message' || item.kind === 'assistant_text')) {
+    return ERRORS.validation('thread has no conversation to summarize')
+  }
+
+  const resolved = resolveRoleModel({
+    roleModel: parsed.data?.model ?? runtime.roles?.summaryModel,
+    roleProviderId: parsed.data?.providerId ?? runtime.roles?.summaryProviderId,
+    roles: runtime.roles,
+    mainModel: thread.model || runtime.defaultModel,
+    mainProviderId: thread.providerId
+  })
+  if (!resolved) return ERRORS.unavailable('no model is configured for session summary')
+
+  const abortController = new AbortController()
+  const onAbort = (): void => abortController.abort()
+  request.signal?.addEventListener('abort', onAbort)
+
+  let summary: string | undefined
+  try {
+    summary = await generateSessionSummary({
+      threadId,
+      modelClient: runtime.modelClient,
+      model: resolved.model,
+      ...(resolved.providerId ? { providerId: resolved.providerId } : {}),
+      ...(runtime.immutablePrefix?.systemPrompt ? { systemPrompt: runtime.immutablePrefix.systemPrompt } : {}),
+      items,
+      ...(runtime.roles?.summaryReasoningEffort
+        ? { reasoningEffort: runtime.roles.summaryReasoningEffort }
+        : {}),
+      abortSignal: abortController.signal
+    })
+  } finally {
+    request.signal?.removeEventListener('abort', onAbort)
+  }
+  if (!summary) return ERRORS.unavailable('session summary returned no content')
+
+  const updated = await runtime.threadService.update(threadId, { summary })
+  return jsonResponse(SummarizeThreadResponse.parse({ id: updated.id, summary: updated.summary ?? summary }))
+}
diff --git a/kun/src/server/runtime-factory.ts b/kun/src/server/runtime-factory.ts
index 8e9bc6896..a51335261 100644
--- a/kun/src/server/runtime-factory.ts
+++ b/kun/src/server/runtime-factory.ts
@@ -28,7 +28,7 @@ import {
   buildVideoGenToolProviders
 } from '../adapters/tool/media-gen-tool-provider.js'
 import { LocalWorkspaceInspector } from '../adapters/workspace/local-workspace-inspector.js'
-import { createImmutablePrefix, setSystemPrompt } from '../cache/immutable-prefix.js'
+import { createImmutablePrefix } from '../cache/immutable-prefix.js'
 import {
   buildRuntimeCapabilityManifest,
   type KunCapabilitiesConfig
@@ -48,6 +48,7 @@ import {
   DEFAULT_STORAGE_CONFIG,
   expandHomePath,
   type QualityConfig,
+  type RolesConfig,
   type RuntimeTuningConfig,
   type ServeProviderConfig,
   type StorageConfig
@@ -105,6 +106,8 @@ export type KunServeRuntimeOptions = {
   models?: ModelConfig
   contextCompaction?: ContextCompactionConfig
   runtime?: RuntimeTuningConfig
+  /** Internal-LLM role model routing (small-model slot + title/summary/codeReview overrides). */
+  roles?: RolesConfig
   storage?: StorageConfig
   capabilities?: KunCapabilitiesConfig
   /** Command hooks from config.json; resolved and wired into tool hosts and the loop. */
@@ -211,13 +214,6 @@ export async function createKunServeRuntime(
     SkillRuntime.create(options.capabilities?.skills),
     seedUsageCarryover({ threadStore, sessionStore, usageService })
   ])
-  // Fold the available-skills catalog into the stable prefix once per session so
-  // the model knows which skills exist (and where to read them) even when no
-  // trigger fires. Stays byte-stable across turns, preserving prompt-cache reuse.
-  const skillCatalog = skillRuntime.catalogInstruction()
-  if (skillCatalog) {
-    prefix = setSystemPrompt(prefix, `${KUN_SYSTEM_PROMPT}\n\n${skillCatalog}`)
-  }
   const turnService = new TurnService({
     threadStore,
     sessionStore,
@@ -243,7 +239,10 @@ export async function createKunServeRuntime(
     ...(options.models ? { models: options.models } : {}),
     ...(options.contextCompaction ? { contextCompaction: options.contextCompaction } : {}),
     ...(tokenEconomy ? { tokenEconomy } : {}),
-    ...(options.runtime ? { runtime: options.runtime } : {})
+    ...(options.runtime ? { runtime: options.runtime } : {}),
+    ...(options.roles?.codeReviewReasoningEffort
+      ? { reasoningEffort: options.roles.codeReviewReasoningEffort }
+      : {})
   })
   const webProviders = buildWebToolProviders(options.capabilities?.web)
   const attachmentStore = options.capabilities?.attachments.enabled
@@ -445,6 +444,7 @@ export async function createKunServeRuntime(
     skillRuntime,
     tokenEconomy,
     contextCompaction: options.contextCompaction,
+    ...(options.roles ? { roles: options.roles } : {}),
     ...(options.runtime?.toolStorm ? { toolStorm: options.runtime.toolStorm } : {}),
     ...(options.runtime?.toolArgumentRepair ? { toolArgumentRepair: options.runtime.toolArgumentRepair } : {}),
     ...(resolvedHooks.length ? { hooks: resolvedHooks } : {}),
@@ -475,6 +475,11 @@ export async function createKunServeRuntime(
     toolHost,
     ...(attachmentStore ? { attachmentStore } : {}),
     ...(memoryStore ? { memoryStore } : {}),
+    ...(delegationRuntime ? { delegationRuntime } : {}),
+    modelClient,
+    defaultModel: options.model,
+    ...(options.roles ? { roles: options.roles } : {}),
+    immutablePrefix: prefix,
     runTurn(threadId, turnId) {
       return loop.runTurn(threadId, turnId)
     },
diff --git a/kun/src/services/review-service.ts b/kun/src/services/review-service.ts
index 8d8435c7e..4b6f8d187 100644
--- a/kun/src/services/review-service.ts
+++ b/kun/src/services/review-service.ts
@@ -6,6 +6,7 @@ import { InMemoryUserInputGate } from '../adapters/in-memory-user-input-gate.js'
 import { buildReadOnlyBuiltinLocalTools } from '../adapters/tool/builtin-tools.js'
 import { LocalToolHost } from '../adapters/tool/local-tool-host.js'
 import { createImmutablePrefix } from '../cache/immutable-prefix.js'
+import { normalizeRoleReasoningEffort } from '../loop/reasoning-effort.js'
 import type { ModelCapabilityMetadata } from '../contracts/capabilities.js'
 import type { TurnItem } from '../contracts/items.js'
 import type { ReviewTarget } from '../contracts/review.js'
@@ -39,6 +40,8 @@ export type ReviewServiceDeps = {
   tokenEconomy?: TokenEconomyConfig
   runtime?: RuntimeTuningConfig
   modelCapabilities?: (model: string) => ModelCapabilityMetadata
+  /** Reasoning depth for the code-review model call. Invalid/missing => 'off'. */
+  reasoningEffort?: string
 }
 
 export class ReviewService {
@@ -194,7 +197,8 @@ export class ReviewService {
       request: {
         prompt: input.prompt,
         model: input.model,
-        mode: 'agent'
+        mode: 'agent',
+        reasoningEffort: normalizeRoleReasoningEffort(this.deps.reasoningEffort)
       }
     })
     const abortChild = (): void => {
diff --git a/kun/src/services/thread-service.ts b/kun/src/services/thread-service.ts
index a99814e41..ed2ed2c40 100644
--- a/kun/src/services/thread-service.ts
+++ b/kun/src/services/thread-service.ts
@@ -119,9 +119,12 @@ export class ThreadService {
     const thread = createThreadRecord({
       id,
       title: options.title ?? (request.title?.trim() || 'New chat'),
+      ...(request.titleAuto !== undefined ? { titleAuto: request.titleAuto } : {}),
       workspace: request.workspace,
       model: request.model,
       ...(request.providerId?.trim() ? { providerId: request.providerId.trim() } : {}),
+      ...(request.agentId?.trim() ? { agentId: request.agentId.trim() } : {}),
+      ...(request.systemPrompt?.trim() ? { systemPrompt: request.systemPrompt.trim() } : {}),
       mode: request.mode,
       approvalPolicy: request.approvalPolicy,
       sandboxMode: request.sandboxMode,
@@ -139,10 +142,13 @@ export class ThreadService {
 
   async update(threadId: string, patch: {
     title?: string
+    titleAuto?: boolean
+    summary?: string
     workspace?: string
     status?: ThreadStatus
     approvalPolicy?: ApprovalPolicy
     sandboxMode?: SandboxMode
+    pinned?: boolean
     costBudgetUsd?: number | null
     costBudgetWarningSent?: boolean
     relation?: ThreadRelation
@@ -171,6 +177,7 @@ export class ThreadService {
       kind: 'thread_updated',
       threadId,
       title: updated.title,
+      ...(updated.titleAuto !== undefined ? { titleAuto: updated.titleAuto } : {}),
       status: updated.status
     })
     return updated
diff --git a/kun/src/services/turn-service.test.ts b/kun/src/services/turn-service.test.ts
index cc9f7f272..05b1316f1 100644
--- a/kun/src/services/turn-service.test.ts
+++ b/kun/src/services/turn-service.test.ts
@@ -7,6 +7,7 @@ import { makeAssistantTextItem, makeUserItem } from '../domain/item.js'
 import { createThreadRecord } from '../domain/thread.js'
 import { appendTurnItem, createTurnRecord, finishTurn } from '../domain/turn.js'
 import { ContextCompactor } from '../loop/context-compactor.js'
+import { COMPACTION_SYSTEM_PROMPT } from '../loop/compaction-summary.js'
 import { effectiveHistoryAfterLatestCompaction } from '../loop/compaction-history.js'
 import { InflightTracker } from '../loop/inflight-tracker.js'
 import { SteeringQueue } from '../loop/steering-queue.js'
@@ -124,14 +125,19 @@ describe('TurnService compact', () => {
 
     expect(model.requests).toHaveLength(1)
     expect(model.requests[0].model).toBe('thread-model')
-    expect(model.requests[0].systemPrompt).toBe(prefix.systemPrompt)
-    const summaryRequestItem = model.requests[0].history[0]
-    expect(summaryRequestItem?.kind).toBe('user_message')
-    if (!summaryRequestItem || summaryRequestItem.kind !== 'user_message') {
-      throw new Error('expected compaction summary request to be a user message')
+    // Compaction-mode turn uses the dedicated summarizer system prompt and
+    // feeds the real conversation as messages (not a serialized transcript).
+    expect(model.requests[0].systemPrompt).toBe(COMPACTION_SYSTEM_PROMPT)
+    expect(model.requests[0].prefix).toEqual([])
+    const summaryHistory = model.requests[0].history
+    expect(summaryHistory[0]?.kind === 'user_message' ? summaryHistory[0].text : '')
+      .toContain('Initial task: fix /compact.')
+    const continuationItem = summaryHistory[summaryHistory.length - 1]
+    expect(continuationItem?.kind).toBe('user_message')
+    if (!continuationItem || continuationItem.kind !== 'user_message') {
+      throw new Error('expected compaction continuation message to be a user message')
     }
-    expect(summaryRequestItem.text).toContain('Conversation history to fold:')
-    expect(summaryRequestItem.text).toContain('Initial task: fix /compact.')
+    expect(continuationItem.text).toContain('Provide a detailed summary of our conversation above')
     expect(response.summary).toContain('MODEL SUMMARY kept the durable state.')
     expect(response.pinnedConstraints).toEqual(prefix.pinnedConstraints)
 
diff --git a/kun/src/services/turn-service.ts b/kun/src/services/turn-service.ts
index a9d60bc25..e495619b0 100644
--- a/kun/src/services/turn-service.ts
+++ b/kun/src/services/turn-service.ts
@@ -23,7 +23,7 @@ import {
   insertCompactionIntoVisibleHistory,
   placeCompactionsAtTurnEnd
 } from '../loop/compaction-history.js'
-import { summarizeCompactionWithModel } from '../loop/compaction-summary.js'
+import { resolveCompactionModel, summarizeCompactionWithModel } from '../loop/compaction-summary.js'
 import type { ContextCompactionConfig } from '../loop/model-context-profile.js'
 import { makeUserItem, makeErrorItem } from '../domain/item.js'
 import { appendTurnItem, createTurnRecord, finishTurn, replaceTurnItem, startTurn as startTurnRecord } from '../domain/turn.js'
@@ -239,15 +239,21 @@ export class TurnService {
         auto: false
       })
       if (this.deps.contextCompaction?.summaryMode === 'model' && this.deps.model) {
-        const model = modelForManualCompaction({
+        const fallbackModel = modelForManualCompaction({
           threadModel: thread.model,
           defaultModel: this.deps.defaultModel,
           clientModel: this.deps.model.model
         })
+        const compactionModel = resolveCompactionModel({
+          contextCompaction: this.deps.contextCompaction,
+          fallbackModel
+        })
+        const model = compactionModel.model
         const modelSummary = await summarizeCompactionWithModel({
           threadId: input.threadId,
           turnId,
           model,
+          ...(compactionModel.providerId ? { providerId: compactionModel.providerId } : {}),
           modelClient: this.deps.model,
           prefix,
           contextCompaction: this.deps.contextCompaction,
diff --git a/kun/src/skills/skill-runtime.ts b/kun/src/skills/skill-runtime.ts
index 70a04338e..2492009d1 100644
--- a/kun/src/skills/skill-runtime.ts
+++ b/kun/src/skills/skill-runtime.ts
@@ -1,12 +1,18 @@
 import { type Dirent } from 'node:fs'
 import { readdir, readFile, stat } from 'node:fs/promises'
-import { basename, extname, join, resolve } from 'node:path'
+import { basename, extname, isAbsolute, join, relative, resolve } from 'node:path'
 import { z } from 'zod'
 import type { SkillsCapabilityConfig } from '../contracts/capabilities.js'
 
 const DEFAULT_ACTIVE_LIMIT = 3
 const DEFAULT_INSTRUCTION_BUDGET_BYTES = 24_000
 const DEFAULT_CATALOG_BUDGET_BYTES = 8_000
+const WORKSPACE_SKILL_RELATIVE_DIRS = [
+  '.agents/skills',
+  '.claude/skills',
+  '.codex/skills',
+  'skills'
+] as const
 
 const SkillTriggerManifest = z.object({
   commands: z.array(z.string().min(1)).default([]),
@@ -40,6 +46,8 @@ export type LoadedSkill = {
   assets: string[]
   priority: number
   legacy: boolean
+  /** Source of the skill: 'project' (workspace) or 'global' (user-level). */
+  source: 'project' | 'global'
 }
 
 export type SkillActivation = {
@@ -51,6 +59,7 @@ export type SkillActivation = {
 export type SkillTurnResolution = {
   activeSkillIds: string[]
   activations: SkillActivation[]
+  catalogInstruction?: string
   instructions: string[]
   allowedToolNames?: string[]
   injectedBytes: number
@@ -59,12 +68,14 @@ export type SkillTurnResolution = {
 export type SkillRuntimeDiagnostics = {
   enabled: boolean
   roots: string[]
+  globalRoots: string[]
   skills: Array<{
     id: string
     name: string
     description?: string
     version: string
     root: string
+    source: 'project' | 'global'
     legacy: boolean
     triggers: LoadedSkill['triggers']
     allowedTools: string[]
@@ -82,13 +93,18 @@ export type SkillRuntimeDiagnostics = {
 export type SkillRuntimeOptions = {
   activeLimit?: number
   instructionBudgetBytes?: number
-  /** Byte budget for the always-on available-skills catalog folded into the prefix. */
+  /** Byte budget for the per-turn available-skills catalog. */
   catalogBudgetBytes?: number
 }
 
 export class SkillRuntime {
   private skills: LoadedSkill[]
   private validationErrors: Array<{ root: string; message: string }>
+  private readonly workspaceSkillCache = new Map<string, {
+    rootsKey: string
+    skills: LoadedSkill[]
+    validationErrors: Array<{ root: string; message: string }>
+  }>()
   private lastActivations: SkillActivation[] = []
   private lastInjection: SkillRuntimeDiagnostics['lastInjection']
 
@@ -99,13 +115,18 @@ export class SkillRuntime {
   ) {
     this.skills = loaded.skills
     this.validationErrors = loaded.validationErrors
+    this.workspaceSkillCache.clear()
+  }
+
+  enabled(): boolean {
+    return this.config.enabled
   }
 
   static async create(
     config: SkillsCapabilityConfig | undefined,
     options: SkillRuntimeOptions = {}
   ): Promise<SkillRuntime> {
-    const normalized = config ?? { enabled: false, roots: [], legacySkillMd: true }
+    const normalized = config ?? { enabled: false, roots: [], workspaceRoots: [], globalRoots: [], disabledIds: [], legacySkillMd: true }
     const resolvedOptions = {
       activeLimit: options.activeLimit ?? DEFAULT_ACTIVE_LIMIT,
       instructionBudgetBytes: options.instructionBudgetBytes ?? DEFAULT_INSTRUCTION_BUDGET_BYTES,
@@ -123,18 +144,25 @@ export class SkillRuntime {
       : { skills: [], validationErrors: [] }
     this.skills = loaded.skills
     this.validationErrors = loaded.validationErrors
+    this.workspaceSkillCache.clear()
   }
 
-  resolveTurn(input: {
+  async resolveTurn(input: {
     prompt: string
     workspace: string
     filePaths?: readonly string[]
-  }): SkillTurnResolution {
+    /** Per-call skill-id deny-list (e.g. a subagent profile's blockedSkills). Hidden from catalog + auto-activation. */
+    blockedSkillIds?: readonly string[]
+  }): Promise<SkillTurnResolution> {
     if (!this.config.enabled) return emptyResolution()
-    const matches = this.matchSkills(input)
+    const skills = filterBlockedSkills(await this.skillsForWorkspace(input.workspace), input.blockedSkillIds)
+    const catalogInstruction = renderCatalogInstruction(skills, this.options.catalogBudgetBytes)
+    const matches = this.matchSkills(input, skills)
     const active = matches.slice(0, this.options.activeLimit)
     const injection = buildInjection(active, this.options.instructionBudgetBytes)
-    const blockedToolNames = blockedToolsFor(this.skills, injection.allowedToolNames)
+    const catalogBytes = catalogInstruction ? Buffer.byteLength(catalogInstruction, 'utf8') : 0
+    const injectedBytes = injection.injectedBytes + catalogBytes
+    const blockedToolNames = blockedToolsFor(skills, injection.allowedToolNames)
     this.lastActivations = active.map(({ skill, reason, score }) => ({
       skillId: skill.id,
       reason,
@@ -142,61 +170,26 @@ export class SkillRuntime {
     }))
     this.lastInjection = {
       activeSkillIds: injection.activeSkillIds,
-      injectedBytes: injection.injectedBytes,
+      injectedBytes,
       budgetBytes: this.options.instructionBudgetBytes,
       blockedToolNames
     }
     return {
       activeSkillIds: injection.activeSkillIds,
       activations: this.lastActivations,
+      ...(catalogInstruction ? { catalogInstruction } : {}),
       instructions: injection.instructions,
       ...(injection.allowedToolNames ? { allowedToolNames: injection.allowedToolNames } : {}),
-      injectedBytes: injection.injectedBytes
+      injectedBytes
     }
   }
 
   /**
-   * Renders the always-on catalog of available skills, folded once into the
-   * stable prefix at session start. Unlike {@link resolveTurn} (which only
-   * injects a skill once its triggers fire on the user prompt), the catalog
-   * lets the model learn that skills exist at all and read the linked
-   * `SKILL.md` on demand. Mirrors codex's `render_available_skills_body`.
-   * Returns `undefined` when skills are disabled or none are loaded so the
-   * prefix stays byte-identical to the no-skills case.
-   */
+   * Renders the global catalog for diagnostics and compatibility. Runtime turns
+   * use resolveTurn so workspace-local skills stay out of the immutable prefix.
+  */
   catalogInstruction(): string | undefined {
-    if (!this.config.enabled || this.skills.length === 0) return undefined
-    const budget = this.options.catalogBudgetBytes
-    const header = '## Skills\n' +
-      'A skill is a reusable set of instructions stored on disk. The skills below ' +
-      'are available in this workspace. When a user request matches one, read its ' +
-      '`SKILL.md` (the file path is listed) before acting, then follow it.'
-    const footer = '### How to use skills\n' +
-      '- A skill activates automatically when the user mentions it by id ' +
-      '(`$id`, `@id`, or `/skill:id`) or trips one of its triggers; its full ' +
-      'instructions are then injected for that turn.\n' +
-      '- Otherwise, if a request clearly matches a skill above, call the ' +
-      '`load_skill` tool with its id to pull the full instructions, then follow ' +
-      'them. (You can also read the listed file directly.)'
-    const lines: string[] = []
-    let used = Buffer.byteLength(`${header}\n\n### Available skills\n\n${footer}`, 'utf8')
-    let dropped = 0
-    for (const skill of this.skills) {
-      const desc = skill.description ? `: ${skill.description}` : ''
-      const line = `- ${skill.name} (${skill.id})${desc} (file: ${skill.entryPath})`
-      const cost = Buffer.byteLength(`${line}\n`, 'utf8')
-      if (used + cost > budget) {
-        dropped += 1
-        continue
-      }
-      lines.push(line)
-      used += cost
-    }
-    if (lines.length === 0) return undefined
-    if (dropped > 0) {
-      lines.push(`- …and ${dropped} more skill${dropped === 1 ? '' : 's'} omitted (catalog budget reached).`)
-    }
-    return `${header}\n\n### Available skills\n${lines.join('\n')}\n\n${footer}`
+    return renderCatalogInstruction(this.skills, this.options.catalogBudgetBytes)
   }
 
   /**
@@ -206,19 +199,20 @@ export class SkillRuntime {
    * Returns an error payload (never throws) so the tool can surface it to the
    * model as a normal tool result.
    */
-  loadSkillById(skillId: string): {
+  async loadSkillById(skillId: string, workspace = '', blockedIds?: readonly string[]): Promise<{
     skillId: string
     name: string
     instruction: string
     allowedTools: string[]
     truncated: boolean
-  } | { error: string } {
+  } | { error: string }> {
     if (!this.config.enabled) return { error: 'skills are disabled' }
+    const skills = filterBlockedSkills(await this.skillsForWorkspace(workspace), blockedIds)
     const normalized = slug(skillId.trim().replace(/^[$@]/, '').replace(/^skill:/i, ''))
-    const skill = this.skills.find((candidate) => candidate.id === normalized) ??
-      this.skills.find((candidate) => slug(candidate.name) === normalized)
+    const skill = skills.find((candidate) => candidate.id === normalized) ??
+      skills.find((candidate) => slug(candidate.name) === normalized)
     if (!skill) {
-      const available = this.skills.map((candidate) => candidate.id).join(', ')
+      const available = skills.map((candidate) => candidate.id).join(', ')
       return { error: `unknown skill id "${skillId}". Available: ${available || '(none)'}` }
     }
     let instruction = formatSkillInstruction(skill, 'load_skill')
@@ -242,15 +236,19 @@ export class SkillRuntime {
   }
 
   diagnostics(): SkillRuntimeDiagnostics {
+    const projectRoots = this.config.roots ?? []
+    const globalRoots = this.config.globalRoots ?? []
     return {
       enabled: this.config.enabled,
-      roots: [...this.config.roots],
+      roots: [...projectRoots],
+      globalRoots: [...globalRoots],
       skills: this.skills.map((skill) => ({
         id: skill.id,
         name: skill.name,
         ...(skill.description ? { description: skill.description } : {}),
         version: skill.version,
         root: skill.root,
+        source: skill.source,
         legacy: skill.legacy,
         triggers: skill.triggers,
         allowedTools: skill.allowedTools
@@ -265,16 +263,21 @@ export class SkillRuntime {
     return this.skills.length
   }
 
+  async countForWorkspace(workspace: string): Promise<number> {
+    if (!this.config.enabled) return 0
+    return (await this.skillsForWorkspace(workspace)).length
+  }
+
   private matchSkills(input: {
     prompt: string
     workspace: string
     filePaths?: readonly string[]
-  }): Array<SkillActivation & { skill: LoadedSkill }> {
+  }, skills: LoadedSkill[]): Array<SkillActivation & { skill: LoadedSkill }> {
     const prompt = input.prompt
     const lowerPrompt = prompt.toLowerCase()
     const fileTypes = fileTypesFrom(input.filePaths ?? [], prompt)
     const matches: Array<SkillActivation & { skill: LoadedSkill }> = []
-    for (const skill of this.skills) {
+    for (const skill of skills) {
       const explicit = explicitSkillMention(skill, prompt)
       if (explicit) {
         matches.push({ skill, skillId: skill.id, reason: explicit, score: 1_000 + skill.priority })
@@ -297,6 +300,139 @@ export class SkillRuntime {
     }
     return matches.sort((a, b) => b.score - a.score || a.skill.id.localeCompare(b.skill.id))
   }
+
+  private async skillsForWorkspace(workspace: string): Promise<LoadedSkill[]> {
+    const workspaceRoot = normalizeRoot(workspace)
+    const workspaceLoaded = workspaceRoot
+      ? await this.loadWorkspaceSkills(workspaceRoot)
+      : { skills: [], validationErrors: [] }
+    const knownWorkspaceRoots = [
+      workspaceRoot,
+      ...(this.config.workspaceRoots ?? []).map(normalizeRoot)
+    ].filter(Boolean)
+    const staticSkills = this.skills.filter((skill) =>
+      skillVisibleForWorkspace(skill.root, workspaceRoot, knownWorkspaceRoots)
+    )
+    const unique = new Map<string, LoadedSkill>()
+    for (const skill of [...workspaceLoaded.skills, ...staticSkills]) {
+      if (!unique.has(skill.id)) unique.set(skill.id, skill)
+    }
+    return [...unique.values()].sort((a, b) => a.id.localeCompare(b.id))
+  }
+
+  private async loadWorkspaceSkills(workspaceRoot: string): Promise<{
+    skills: LoadedSkill[]
+    validationErrors: Array<{ root: string; message: string }>
+  }> {
+    const discoveredRoots = await existingWorkspaceSkillRoots(workspaceRoot)
+    const configRoots = new Set((this.config.roots ?? []).map(normalizeRoot).filter(Boolean))
+    const knownWorkspaceRoots = (this.config.workspaceRoots ?? []).map(normalizeRoot).filter(Boolean)
+    const isKnownWorkspace = knownWorkspaceRoots.some((candidate) => candidate === workspaceRoot)
+    const roots = isKnownWorkspace
+      ? discoveredRoots.filter((root) => configRoots.has(normalizeRoot(root)))
+      : discoveredRoots
+    const rootsKey = roots.join('\0')
+    const cached = this.workspaceSkillCache.get(workspaceRoot)
+    if (cached?.rootsKey === rootsKey) {
+      return { skills: cached.skills, validationErrors: cached.validationErrors }
+    }
+    const loaded = roots.length > 0
+      ? await discoverSkills({ ...this.config, roots })
+      : { skills: [], validationErrors: [] }
+    this.workspaceSkillCache.set(workspaceRoot, { rootsKey, ...loaded })
+    return loaded
+  }
+}
+
+function renderCatalogInstruction(skills: LoadedSkill[], budget: number): string | undefined {
+  if (skills.length === 0) return undefined
+  const header = '## Skills\n' +
+    'A skill is a reusable set of instructions stored on disk. The skills below ' +
+    'are available in this workspace. When a user request matches one, read its ' +
+    '`SKILL.md` (the file path is listed) before acting, then follow it.'
+  const footer = '### How to use skills\n' +
+    '- A skill activates automatically when the user mentions it by id ' +
+    '(`$id`, `@id`, or `/skill:id`) or trips one of its triggers; its full ' +
+    'instructions are then injected for that turn.\n' +
+    '- Otherwise, if a request clearly matches a skill above, call the ' +
+    '`load_skill` tool with its id to pull the full instructions, then follow ' +
+    'them. (You can also read the listed file directly.)'
+  const lines: string[] = []
+  let used = Buffer.byteLength(`${header}\n\n### Available skills\n\n${footer}`, 'utf8')
+  let dropped = 0
+  for (const skill of skills) {
+    const desc = skill.description ? `: ${skill.description}` : ''
+    const line = `- ${skill.name} (${skill.id})${desc} (file: ${skill.entryPath})`
+    const cost = Buffer.byteLength(`${line}\n`, 'utf8')
+    if (used + cost > budget) {
+      dropped += 1
+      continue
+    }
+    lines.push(line)
+    used += cost
+  }
+  if (lines.length === 0) return undefined
+  if (dropped > 0) {
+    lines.push(`- ...and ${dropped} more skill${dropped === 1 ? '' : 's'} omitted (catalog budget reached).`)
+  }
+  return `${header}\n\n### Available skills\n${lines.join('\n')}\n\n${footer}`
+}
+
+function normalizeRoot(path: string | undefined): string {
+  const trimmed = path?.trim()
+  return trimmed ? resolve(trimmed) : ''
+}
+
+function isSameOrInside(parent: string, target: string): boolean {
+  if (!parent || !target) return false
+  const rel = relative(parent, target)
+  return rel === '' || (!!rel && !rel.startsWith('..') && !isAbsolute(rel))
+}
+
+function skillVisibleForWorkspace(
+  skillRoot: string,
+  workspaceRoot: string,
+  knownWorkspaceRoots: string[]
+): boolean {
+  const root = normalizeRoot(skillRoot)
+  if (workspaceRoot && isSameOrInside(workspaceRoot, root)) return true
+  const ownerWorkspace = knownWorkspaceRoots.find((candidate) => isSameOrInside(candidate, root))
+  if (ownerWorkspace) return workspaceRoot !== '' && ownerWorkspace === workspaceRoot
+  if (workspaceRoot && looksLikeWorkspaceSkillRoot(root) && !isSameOrInside(workspaceRoot, root)) {
+    return false
+  }
+  return true
+}
+
+function looksLikeWorkspaceSkillRoot(root: string): boolean {
+  const parts = root.split(/[\\/]+/)
+  if (parts.length < 2) return false
+  const tail2 = parts.slice(-2).join('/')
+  return tail2 === '.agents/skills' || tail2 === '.claude/skills' || tail2 === '.codex/skills'
+}
+
+async function existingWorkspaceSkillRoots(workspaceRoot: string): Promise<string[]> {
+  const roots: string[] = []
+  for (const relativeDir of WORKSPACE_SKILL_RELATIVE_DIRS) {
+    const root = resolve(workspaceRoot, ...relativeDir.split('/'))
+    if (await exists(root)) roots.push(root)
+  }
+  return roots
+}
+
+/**
+ * Per-call skill deny-list. Mirrors the global `disabledIds` discovery filter
+ * (slug both sides) but applies to a single resolveTurn/loadSkill call — e.g. a
+ * subagent profile that blocks specific skills — without mutating the shared
+ * runtime instance, so sibling children are unaffected.
+ */
+function filterBlockedSkills(skills: LoadedSkill[], blockedIds: readonly string[] | undefined): LoadedSkill[] {
+  if (!blockedIds || blockedIds.length === 0) return skills
+  // Normalize like loadSkillById's lookup (strip leading $/@ and a `skill:`
+  // prefix before slugging) so a `skill:gmail` / `$gmail` deny entry matches
+  // the discovered, slugged id.
+  const blocked = new Set(blockedIds.map((id) => slug(id.trim().replace(/^[$@]/, '').replace(/^skill:/i, ''))))
+  return skills.filter((skill) => !blocked.has(skill.id))
 }
 
 async function discoverSkills(config: SkillsCapabilityConfig): Promise<{
@@ -305,6 +441,13 @@ async function discoverSkills(config: SkillsCapabilityConfig): Promise<{
 }> {
   const skills: LoadedSkill[] = []
   const validationErrors: Array<{ root: string; message: string }> = []
+  // Skill ids the user disabled. Slug both sides so `gmail`, `Gmail`, and
+  // `skill:gmail` all match the discovered `slug(manifest.id)`. A disabled
+  // skill is dropped here at the single discovery chokepoint, so it stays out
+  // of the catalog, auto-match, load_skill, diagnostics, and counts alike.
+  const disabledIds = new Set((config.disabledIds ?? []).map(slug))
+
+  // Scan project roots (priority over global — loaded first)
   for (const rawRoot of config.roots) {
     const root = resolve(rawRoot)
     const candidates = await packageCandidates(root).catch((error) => {
@@ -312,15 +455,34 @@ async function discoverSkills(config: SkillsCapabilityConfig): Promise<{
       return []
     })
     for (const candidate of candidates) {
-      const loaded = await loadSkillPackage(candidate, config.legacySkillMd).catch((error) => {
+      const loaded = await loadSkillPackage(candidate, config.legacySkillMd, 'project').catch((error) => {
         validationErrors.push({ root: candidate, message: errorMessage(error) })
         return null
       })
       if (loaded) skills.push(loaded)
     }
   }
+
+  // Scan global roots (#149: global skill loading fix)
+  const globalRoots = config.globalRoots ?? []
+  for (const rawRoot of globalRoots) {
+    const root = resolve(rawRoot)
+    const candidates = await packageCandidates(root).catch((error) => {
+      validationErrors.push({ root, message: errorMessage(error) })
+      return []
+    })
+    for (const candidate of candidates) {
+      const loaded = await loadSkillPackage(candidate, config.legacySkillMd, 'global').catch((error) => {
+        validationErrors.push({ root: candidate, message: errorMessage(error) })
+        return null
+      })
+      if (loaded) skills.push(loaded)
+    }
+  }
+
   const unique = new Map<string, LoadedSkill>()
   for (const skill of skills) {
+    if (disabledIds.has(skill.id)) continue
     if (!unique.has(skill.id)) unique.set(skill.id, skill)
     else validationErrors.push({ root: skill.root, message: `duplicate Skill id: ${skill.id}` })
   }
@@ -361,7 +523,7 @@ async function entryIsDirectory(entry: Dirent, path: string): Promise<boolean> {
   }
 }
 
-async function loadSkillPackage(root: string, allowLegacy: boolean): Promise<LoadedSkill | null> {
+async function loadSkillPackage(root: string, allowLegacy: boolean, source: 'project' | 'global'): Promise<LoadedSkill | null> {
   const manifestPath = join(root, 'skill.json')
   if (await exists(manifestPath)) {
     const manifest = SkillManifest.parse(JSON.parse(await readFile(manifestPath, 'utf8')))
@@ -379,7 +541,8 @@ async function loadSkillPackage(root: string, allowLegacy: boolean): Promise<Loa
       allowedTools: manifest.allowedTools,
       assets: manifest.assets.map((asset) => resolve(root, asset)),
       priority: manifest.priority,
-      legacy: false
+      legacy: false,
+      source,
     }
   }
   if (!allowLegacy) return null
@@ -401,7 +564,8 @@ async function loadSkillPackage(root: string, allowLegacy: boolean): Promise<Loa
     allowedTools: [],
     assets: [],
     priority: 0,
-    legacy: true
+    legacy: true,
+    source,
   }
 }
 
diff --git a/kun/tests/auto-title-gate.test.ts b/kun/tests/auto-title-gate.test.ts
new file mode 100644
index 000000000..6a171ff58
--- /dev/null
+++ b/kun/tests/auto-title-gate.test.ts
@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest'
+import { canUpgradeThreadTitle } from '../src/loop/agent-loop.js'
+
+/**
+ * Guards the "placeholder → LLM-summary upgrade" titling contract: the backend
+ * LLM titler may overwrite a placeholder or an explicitly-provisional title,
+ * but must never clobber a user-renamed (locked) one. Regression coverage for
+ * the bug where the renderer's eager first-message rename pre-empted the
+ * backend titler.
+ */
+describe('canUpgradeThreadTitle', () => {
+  it('upgrades placeholder titles when titleAuto is absent (legacy)', () => {
+    expect(canUpgradeThreadTitle({ title: '新会话' })).toBe(true)
+    expect(canUpgradeThreadTitle({ title: 'New Thread' })).toBe(true)
+    expect(canUpgradeThreadTitle({ title: '' })).toBe(true)
+    expect(canUpgradeThreadTitle({ title: undefined })).toBe(true)
+  })
+
+  it('does NOT upgrade a real legacy title with no auto flag', () => {
+    expect(canUpgradeThreadTitle({ title: 'Fix the login bug' })).toBe(false)
+  })
+
+  it('upgrades a provisional (titleAuto:true) title even when it is a real string', () => {
+    // The renderer writes the raw first message with titleAuto:true; the backend
+    // must still be allowed to replace it with a summarized LLM title.
+    expect(canUpgradeThreadTitle({ title: '用三个subagent更我说你好', titleAuto: true })).toBe(true)
+  })
+
+  it('never upgrades a user-locked (titleAuto:false) title', () => {
+    expect(canUpgradeThreadTitle({ title: 'My pinned title', titleAuto: false })).toBe(false)
+    // titleAuto:false wins even over a placeholder-looking string.
+    expect(canUpgradeThreadTitle({ title: '新会话', titleAuto: false })).toBe(false)
+  })
+})
diff --git a/kun/tests/builtin-profiles.test.ts b/kun/tests/builtin-profiles.test.ts
new file mode 100644
index 000000000..efaf41e13
--- /dev/null
+++ b/kun/tests/builtin-profiles.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest'
+import { mergeBuiltinSubagentProfiles } from '../src/delegation/builtin-profiles.js'
+import { SubagentsCapabilityConfig } from '../src/contracts/capabilities.js'
+
+describe('mergeBuiltinSubagentProfiles', () => {
+  it('deep-merges a thin GUI override onto a builtin, preserving its persona', () => {
+    // The GUI persists a builtin override carrying only the edited fields (here
+    // a tool policy + a deny-list); the builtin's promptPreamble/description
+    // must survive (a shallow replace would wipe them).
+    const config = SubagentsCapabilityConfig.parse({
+      profiles: { general: { toolPolicy: 'inherit', blockedTools: ['bash'] } }
+    })
+    const general = mergeBuiltinSubagentProfiles(config).profiles.general!
+
+    // User fields win.
+    expect(general.toolPolicy).toBe('inherit')
+    expect(general.blockedTools).toEqual(['bash'])
+    // Builtin persona/description fall back instead of being clobbered.
+    expect(general.promptPreamble).toContain('通用代理')
+    expect(general.description).toBeTruthy()
+    // An un-overridden builtin is untouched.
+    expect(mergeBuiltinSubagentProfiles(config).profiles.explore!.promptPreamble).toContain('探索代理')
+  })
+
+  it('keeps user-only profiles alongside every builtin', () => {
+    const config = SubagentsCapabilityConfig.parse({
+      profiles: { mine: { mode: 'subagent', toolPolicy: 'readOnly' } }
+    })
+    const merged = mergeBuiltinSubagentProfiles(config)
+    expect(Object.keys(merged.profiles).sort()).toEqual(
+      ['design-reviewer', 'explore', 'general', 'mine', 'over-engineering-reviewer'].sort()
+    )
+  })
+})
diff --git a/kun/tests/capability-registry.test.ts b/kun/tests/capability-registry.test.ts
index af36dcea5..69aad95f4 100644
--- a/kun/tests/capability-registry.test.ts
+++ b/kun/tests/capability-registry.test.ts
@@ -138,4 +138,67 @@ describe('CapabilityRegistry', () => {
     )
     expect(visible.map((entry) => entry.name)).toEqual(['vision_tool'])
   })
+
+  it('honors provider deny-lists (blockedProviderIds) at advertise and execute', async () => {
+    let executed = false
+    const tool = LocalToolHost.defineTool({
+      name: 'mcp_github_create_issue',
+      description: 'create issue',
+      inputSchema: { type: 'object' },
+      policy: 'auto',
+      execute: async () => {
+        executed = true
+        return { output: { ok: true } }
+      }
+    })
+    const host = new LocalToolHost({
+      registry: new CapabilityRegistry([
+        { id: 'mcp:github', kind: 'mcp', enabled: true, available: true, tools: [tool] }
+      ])
+    })
+
+    // No deny-list → the MCP tool is advertised.
+    expect((await host.listTools(buildContext())).map((entry) => entry.name)).toEqual(['mcp_github_create_issue'])
+
+    // blockedProviderIds hides the whole server and rejects execution.
+    const blocked = buildContext({ blockedProviderIds: ['mcp:github'] })
+    expect(await host.listTools(blocked)).toEqual([])
+    await expect(
+      host.execute({ callId: 'call_1', toolName: 'mcp_github_create_issue', arguments: {} }, blocked)
+    ).rejects.toThrow(/not advertised/)
+    expect(executed).toBe(false)
+  })
+
+  it('honors tool-name deny-lists (blockedToolNames) while leaving sibling tools advertised', async () => {
+    let executed = false
+    const bash = LocalToolHost.defineTool({
+      name: 'bash',
+      description: 'run',
+      inputSchema: { type: 'object' },
+      policy: 'auto',
+      execute: async () => {
+        executed = true
+        return { output: { ok: true } }
+      }
+    })
+    const read = LocalToolHost.defineTool({
+      name: 'read',
+      description: 'read',
+      inputSchema: { type: 'object' },
+      policy: 'auto',
+      execute: async () => ({ output: { ok: true } })
+    })
+    const host = new LocalToolHost({
+      registry: new CapabilityRegistry([
+        { id: 'builtin', kind: 'built-in', enabled: true, available: true, tools: [bash, read] }
+      ])
+    })
+
+    const blocked = buildContext({ blockedToolNames: ['bash'] })
+    expect((await host.listTools(blocked)).map((entry) => entry.name)).toEqual(['read'])
+    await expect(
+      host.execute({ callId: 'call_1', toolName: 'bash', arguments: {} }, blocked)
+    ).rejects.toThrow(/active tool policy/)
+    expect(executed).toBe(false)
+  })
 })
diff --git a/kun/tests/child-agent-executor.test.ts b/kun/tests/child-agent-executor.test.ts
index 7e6ffb1a5..75c6f191e 100644
--- a/kun/tests/child-agent-executor.test.ts
+++ b/kun/tests/child-agent-executor.test.ts
@@ -140,4 +140,204 @@ describe('child agent executor', () => {
     })
     expect(result).toMatchObject({ prefixReused: true, inheritedHistoryItems: 0 })
   })
+
+  it('threads the input providerId onto the child ModelRequest for routing', async () => {
+    const seen: ModelRequest[] = []
+    const executor = createChildAgentExecutor({
+      model: model([
+        { kind: 'assistant_text_delta', text: 'ok' },
+        { kind: 'completed', stopReason: 'stop' }
+      ], seen),
+      toolHost: new LocalToolHost({ registry: new CapabilityRegistry([]) }),
+      prefix: createImmutablePrefix({ systemPrompt: 'child system' }),
+      defaultModel: 'child-test',
+      nowIso: () => '2026-06-03T00:00:00.000Z'
+    })
+
+    await executor({
+      childId: 'child_provider',
+      parentThreadId: 'thr_parent',
+      parentTurnId: 'turn_parent',
+      prompt: 'Route me',
+      providerId: 'minimax',
+      toolPolicy: 'inherit',
+      signal: new AbortController().signal
+    })
+
+    expect(seen[0]?.providerId).toBe('minimax')
+  })
+
+  it('gives an inherit child the parent agent full tool set (no forced read-only allowlist)', async () => {
+    const seen: ModelRequest[] = []
+    const registry = new CapabilityRegistry([{
+      id: 'builtin',
+      kind: 'built-in',
+      enabled: true,
+      available: true,
+      tools: buildDefaultLocalTools()
+    }])
+    const executor = createChildAgentExecutor({
+      model: model([
+        { kind: 'assistant_text_delta', text: 'done' },
+        { kind: 'completed', stopReason: 'stop' }
+      ], seen),
+      toolHost: new LocalToolHost({ registry }),
+      prefix: createImmutablePrefix({ systemPrompt: 'child system' }),
+      defaultModel: 'child-test',
+      nowIso: () => '2026-06-03T00:00:00.000Z'
+    })
+
+    await executor({
+      childId: 'child_inherit',
+      parentThreadId: 'thr_parent',
+      parentTurnId: 'turn_parent',
+      prompt: 'Do the work',
+      toolPolicy: 'inherit',
+      signal: new AbortController().signal
+    })
+
+    const toolNames = (seen[0]?.tools ?? []).map((tool) => tool.name)
+    // The child sees write/shell tools (not just the read-only investigation
+    // set) because inherit applies no forced allow-list.
+    expect(toolNames).toContain('read')
+    expect(toolNames.length).toBeGreaterThan(4)
+    const restricted = new Set(['read', 'grep', 'find', 'ls'])
+    expect(toolNames.some((name) => !restricted.has(name))).toBe(true)
+  })
+
+  it('honors an explicit allowedTools list over the tool policy', async () => {
+    const seen: ModelRequest[] = []
+    const registry = new CapabilityRegistry([{
+      id: 'builtin',
+      kind: 'built-in',
+      enabled: true,
+      available: true,
+      tools: buildDefaultLocalTools()
+    }])
+    const executor = createChildAgentExecutor({
+      model: model([
+        { kind: 'assistant_text_delta', text: 'done' },
+        { kind: 'completed', stopReason: 'stop' }
+      ], seen),
+      toolHost: new LocalToolHost({ registry }),
+      prefix: createImmutablePrefix({ systemPrompt: 'child system' }),
+      defaultModel: 'child-test',
+      nowIso: () => '2026-06-03T00:00:00.000Z'
+    })
+
+    await executor({
+      childId: 'child_tools',
+      parentThreadId: 'thr_parent',
+      parentTurnId: 'turn_parent',
+      prompt: 'Investigate',
+      // readOnly would allow read/grep/find/ls; the explicit list narrows it.
+      toolPolicy: 'readOnly',
+      allowedTools: ['read', 'grep'],
+      signal: new AbortController().signal
+    })
+
+    const toolNames = (seen[0]?.tools ?? []).map((tool) => tool.name).sort()
+    expect(toolNames).toEqual(['grep', 'read'])
+  })
+
+  it('drops blocked built-in tools (blockedTools) from an inherit child', async () => {
+    const seen: ModelRequest[] = []
+    const registry = new CapabilityRegistry([{
+      id: 'builtin',
+      kind: 'built-in',
+      enabled: true,
+      available: true,
+      tools: buildDefaultLocalTools()
+    }])
+    const executor = createChildAgentExecutor({
+      model: model([
+        { kind: 'assistant_text_delta', text: 'done' },
+        { kind: 'completed', stopReason: 'stop' }
+      ], seen),
+      toolHost: new LocalToolHost({ registry }),
+      prefix: createImmutablePrefix({ systemPrompt: 'child system' }),
+      defaultModel: 'child-test',
+      nowIso: () => '2026-06-03T00:00:00.000Z'
+    })
+
+    await executor({
+      childId: 'child_blocked_tools',
+      parentThreadId: 'thr_parent',
+      parentTurnId: 'turn_parent',
+      prompt: 'Do the work',
+      toolPolicy: 'inherit',
+      blockedTools: ['bash', 'write'],
+      signal: new AbortController().signal
+    })
+
+    const toolNames = (seen[0]?.tools ?? []).map((tool) => tool.name)
+    expect(toolNames).toContain('read')
+    expect(toolNames).not.toContain('bash')
+    expect(toolNames).not.toContain('write')
+  })
+
+  it('maps blockedMcpServers to mcp:<serverId> and hides that server tools from the child', async () => {
+    const seen: ModelRequest[] = []
+    const mcpTool = LocalToolHost.defineTool({
+      name: 'mcp_github_create_issue',
+      description: 'create issue',
+      inputSchema: { type: 'object' },
+      policy: 'auto',
+      execute: async () => ({ output: { ok: true } })
+    })
+    const registry = new CapabilityRegistry([
+      { id: 'builtin', kind: 'built-in', enabled: true, available: true, tools: buildDefaultLocalTools() },
+      { id: 'mcp:github', kind: 'mcp', enabled: true, available: true, tools: [mcpTool] }
+    ])
+    const executor = createChildAgentExecutor({
+      model: model([
+        { kind: 'assistant_text_delta', text: 'done' },
+        { kind: 'completed', stopReason: 'stop' }
+      ], seen),
+      toolHost: new LocalToolHost({ registry }),
+      prefix: createImmutablePrefix({ systemPrompt: 'child system' }),
+      defaultModel: 'child-test',
+      nowIso: () => '2026-06-03T00:00:00.000Z'
+    })
+
+    await executor({
+      childId: 'child_blocked_mcp',
+      parentThreadId: 'thr_parent',
+      parentTurnId: 'turn_parent',
+      prompt: 'Do the work',
+      toolPolicy: 'inherit',
+      blockedMcpServers: ['github'],
+      signal: new AbortController().signal
+    })
+
+    const toolNames = (seen[0]?.tools ?? []).map((tool) => tool.name)
+    expect(toolNames).toContain('read')
+    expect(toolNames).not.toContain('mcp_github_create_issue')
+  })
+
+  it('augments the base system prompt with the agent systemPrompt', async () => {
+    const seen: ModelRequest[] = []
+    const executor = createChildAgentExecutor({
+      model: model([
+        { kind: 'assistant_text_delta', text: 'ok' },
+        { kind: 'completed', stopReason: 'stop' }
+      ], seen),
+      toolHost: new LocalToolHost({ registry: new CapabilityRegistry([]) }),
+      prefix: createImmutablePrefix({ systemPrompt: 'BASE PROMPT' }),
+      defaultModel: 'child-test',
+      nowIso: () => '2026-06-03T00:00:00.000Z'
+    })
+
+    await executor({
+      childId: 'child_sys',
+      parentThreadId: 'thr_parent',
+      parentTurnId: 'turn_parent',
+      prompt: 'Task',
+      systemPrompt: 'You are a careful reviewer.',
+      toolPolicy: 'inherit',
+      signal: new AbortController().signal
+    })
+
+    expect(seen[0]?.systemPrompt).toBe('BASE PROMPT\n\nYou are a careful reviewer.')
+  })
 })
diff --git a/kun/tests/contracts.test.ts b/kun/tests/contracts.test.ts
index 89017ba6a..0fcc07f1d 100644
--- a/kun/tests/contracts.test.ts
+++ b/kun/tests/contracts.test.ts
@@ -518,7 +518,7 @@ describe('cli', () => {
     expect('defaultStepLimit' in config.subagents).toBe(false)
   })
 
-  it('parses subagent profiles and defaults the tool policy to read-only', () => {
+  it('parses subagent profiles and defaults the tool policy to inherit', () => {
     const config = KunCapabilitiesConfig.parse({
       subagents: {
         enabled: true,
@@ -527,15 +527,19 @@ describe('cli', () => {
         defaultProfile: 'reviewer',
         profiles: {
           reviewer: { model: 'deepseek-v4-pro', promptPreamble: 'Review for bugs.', toolPolicy: 'readOnly' },
-          fixer: { toolPolicy: 'inherit' }
+          fixer: { toolPolicy: 'inherit' },
+          helper: {}
         }
       }
     })
-    expect(config.subagents.defaultToolPolicy).toBe('readOnly')
+    // Default subagent policy follows the main agent (inherit), not read-only.
+    expect(config.subagents.defaultToolPolicy).toBe('inherit')
     expect(config.subagents.defaultProfile).toBe('reviewer')
+    // Explicit per-profile policy still wins over the inherit default.
     expect(config.subagents.profiles.reviewer).toMatchObject({ model: 'deepseek-v4-pro', toolPolicy: 'readOnly' })
-    // Profiles default toolPolicy to readOnly when omitted.
     expect(config.subagents.profiles.fixer.toolPolicy).toBe('inherit')
+    // Profiles default toolPolicy to inherit when omitted.
+    expect(config.subagents.profiles.helper.toolPolicy).toBe('inherit')
   })
 
   it('rejects a defaultProfile that is not defined in profiles', () => {
@@ -561,7 +565,7 @@ describe('cli', () => {
     expect(manifest.subagents).toMatchObject({
       maxParallel: 2,
       maxChildRuns: 6,
-      defaultToolPolicy: 'readOnly',
+      defaultToolPolicy: 'inherit',
       defaultProfile: 'reviewer',
       profiles: [{ name: 'reviewer', model: 'deepseek-v4-pro', toolPolicy: 'readOnly' }]
     })
diff --git a/kun/tests/delegation-runtime.test.ts b/kun/tests/delegation-runtime.test.ts
index 5db6d46cc..967314195 100644
--- a/kun/tests/delegation-runtime.test.ts
+++ b/kun/tests/delegation-runtime.test.ts
@@ -146,15 +146,15 @@ describe('DelegationRuntime', () => {
     await expect(blocking).resolves.toMatchObject({ status: 'completed' })
   })
 
-  it('resolves a profile to model, preamble, and tool policy', async () => {
-    const seen: Array<{ model?: string; promptPreamble?: string; toolPolicy: string }> = []
+  it('resolves a profile to model, provider, preamble, and tool policy', async () => {
+    const seen: Array<{ model?: string; providerId?: string; promptPreamble?: string; toolPolicy: string }> = []
     const runtime = createRuntime({
       defaultProfile: 'reviewer',
       profiles: {
-        reviewer: { model: 'deepseek-v4-pro', promptPreamble: 'Review for bugs.', toolPolicy: 'readOnly' }
+        reviewer: { model: 'deepseek-v4-pro', providerId: 'minimax', promptPreamble: 'Review for bugs.', toolPolicy: 'readOnly' }
       },
       executor: async (input) => {
-        seen.push({ model: input.model, promptPreamble: input.promptPreamble, toolPolicy: input.toolPolicy })
+        seen.push({ model: input.model, providerId: input.providerId, promptPreamble: input.promptPreamble, toolPolicy: input.toolPolicy })
         return { summary: 'reviewed', toolInvocations: 2, prefixReused: true, inheritedHistoryItems: 0 }
       }
     })
@@ -164,17 +164,79 @@ describe('DelegationRuntime', () => {
       prompt: 'check the diff',
       signal: new AbortController().signal
     })
-    expect(seen[0]).toMatchObject({ model: 'deepseek-v4-pro', promptPreamble: 'Review for bugs.', toolPolicy: 'readOnly' })
+    expect(seen[0]).toMatchObject({ model: 'deepseek-v4-pro', providerId: 'minimax', promptPreamble: 'Review for bugs.', toolPolicy: 'readOnly' })
     expect(record).toMatchObject({
       profile: 'reviewer',
       toolPolicy: 'readOnly',
       model: 'deepseek-v4-pro',
+      providerId: 'minimax',
       toolInvocations: 2,
       prefixReused: true,
       inheritedHistoryItems: 0
     })
   })
 
+  it('threads a profile\'s blocked tool/MCP/skill deny-lists to the child executor', async () => {
+    const seen: Array<{ blockedTools?: string[]; blockedMcpServers?: string[]; blockedSkills?: string[] }> = []
+    const runtime = createRuntime({
+      defaultProfile: 'scoped',
+      profiles: {
+        scoped: {
+          toolPolicy: 'inherit',
+          blockedTools: ['bash', 'write'],
+          blockedMcpServers: ['github'],
+          blockedSkills: ['deep-research']
+        }
+      },
+      executor: async (input) => {
+        seen.push({
+          blockedTools: input.blockedTools,
+          blockedMcpServers: input.blockedMcpServers,
+          blockedSkills: input.blockedSkills
+        })
+        return { summary: 'ok' }
+      }
+    })
+    await runtime.runChild({
+      parentThreadId: 'thr_1',
+      parentTurnId: 'turn_1',
+      prompt: 'go',
+      signal: new AbortController().signal
+    })
+    expect(seen[0]).toEqual({
+      blockedTools: ['bash', 'write'],
+      blockedMcpServers: ['github'],
+      blockedSkills: ['deep-research']
+    })
+  })
+
+  it('routes a child through an explicit providerId, overriding the profile, and surfaces it on the event', async () => {
+    const sessionStore = new InMemorySessionStore()
+    const seen: Array<{ providerId?: string }> = []
+    const runtime = createRuntime({
+      sessionStore,
+      defaultProfile: 'reviewer',
+      profiles: { reviewer: { providerId: 'minimax', toolPolicy: 'readOnly' } },
+      executor: async (input) => {
+        seen.push({ providerId: input.providerId })
+        return { summary: 'ok' }
+      }
+    })
+    // An explicit providerId on the call wins over the profile's providerId.
+    const record = await runtime.runChild({
+      parentThreadId: 'thr_1',
+      parentTurnId: 'turn_1',
+      prompt: 'go',
+      providerId: 'anthropic',
+      signal: new AbortController().signal
+    })
+    expect(seen[0]?.providerId).toBe('anthropic')
+    expect(record.providerId).toBe('anthropic')
+    const events = await sessionStore.loadEventsSince('thr_1', 0)
+    const completed = events.find((event) => event.child?.childId === record.id && event.child.childStatus === 'completed')
+    expect(completed?.child?.childProviderId).toBe('anthropic')
+  })
+
   it('rejects an unknown profile name', async () => {
     const runtime = createRuntime({ profiles: { reviewer: { toolPolicy: 'readOnly' } } })
     await expect(runtime.runChild({
@@ -186,7 +248,7 @@ describe('DelegationRuntime', () => {
     })).rejects.toThrow(/unknown subagent profile/)
   })
 
-  it('defaults the tool policy to read-only when no profile resolves', async () => {
+  it('defaults the tool policy to inherit (follow the main agent) when no profile resolves', async () => {
     const seen: string[] = []
     const runtime = createRuntime({
       executor: async (input) => {
@@ -200,6 +262,25 @@ describe('DelegationRuntime', () => {
       prompt: 'investigate',
       signal: new AbortController().signal
     })
+    expect(seen[0]).toBe('inherit')
+    expect(record.toolPolicy).toBe('inherit')
+  })
+
+  it('still honors an explicit read-only default tool policy', async () => {
+    const seen: string[] = []
+    const runtime = createRuntime({
+      defaultToolPolicy: 'readOnly',
+      executor: async (input) => {
+        seen.push(input.toolPolicy)
+        return { summary: 'ok' }
+      }
+    })
+    const record = await runtime.runChild({
+      parentThreadId: 'thr_1',
+      parentTurnId: 'turn_1',
+      prompt: 'investigate',
+      signal: new AbortController().signal
+    })
     expect(seen[0]).toBe('readOnly')
     expect(record.toolPolicy).toBe('readOnly')
   })
@@ -233,8 +314,71 @@ describe('DelegationRuntime', () => {
       prefixReused: true,
       totalTokens: 3,
       cacheHitRate: 0.5,
-      childToolPolicy: 'readOnly'
+      childToolPolicy: 'inherit'
+    })
+  })
+
+  it('returns immediately when detach=true and keeps executing in the background', async () => {
+    const start = deferred<void>()
+    const release = deferred<void>()
+    const runtime = createRuntime({
+      executor: async () => {
+        start.resolve()
+        await release.promise
+        return { summary: 'background done' }
+      }
+    })
+    const queued = await runtime.runChild({
+      parentThreadId: 'thr_detach',
+      parentTurnId: 'turn_detach',
+      prompt: 'long running task',
+      detach: true,
+      signal: new AbortController().signal
+    })
+    // Immediately returns with status 'queued' — synchronous runs would
+    // have returned 'completed' here.
+    expect(queued.status).toBe('queued')
+    // The executor actually runs in the background.
+    await start.promise
+    let diagnostics = await runtime.diagnostics('thr_detach')
+    expect(diagnostics.childRuns[0]?.status).toBe('running')
+    // Release the executor and wait for the record to flip to completed.
+    release.resolve()
+    await waitFor(async () => {
+      diagnostics = await runtime.diagnostics('thr_detach')
+      return diagnostics.childRuns[0]?.status === 'completed'
+    })
+    expect(diagnostics.childRuns[0]?.summary).toBe('background done')
+  })
+
+  it('abortChild signals a detached run and false-returns for unknown ids', async () => {
+    const start = deferred<void>()
+    const runtime = createRuntime({
+      executor: async ({ signal }) => {
+        start.resolve()
+        await new Promise<void>((resolve, reject) => {
+          signal.addEventListener('abort', () => reject(new Error('aborted')))
+        })
+        return { summary: 'unreachable' }
+      }
+    })
+    const queued = await runtime.runChild({
+      parentThreadId: 'thr_abort',
+      parentTurnId: 'turn_abort',
+      prompt: 'long task',
+      detach: true,
+      signal: new AbortController().signal
+    })
+    await start.promise
+    expect(runtime.abortChild(queued.id)).toBe(true)
+    await waitFor(async () => {
+      const diagnostics = await runtime.diagnostics('thr_abort')
+      return diagnostics.childRuns[0]?.status === 'aborted'
     })
+    // After the run finished the controller is cleaned up via .finally.
+    // Poll because the cleanup runs in a microtask after the run resolves.
+    await waitFor(() => runtime.abortChild(queued.id) === false)
+    expect(runtime.abortChild('child_unknown')).toBe(false)
   })
 
   it('aggregates child runs by label and model for dashboards', async () => {
@@ -301,7 +445,7 @@ describe('DelegationRuntime', () => {
     maxChildRuns?: number
     defaultToolPolicy?: 'readOnly' | 'inherit'
     defaultProfile?: string
-    profiles?: Record<string, { model?: string; promptPreamble?: string; toolPolicy?: 'readOnly' | 'inherit' }>
+    profiles?: Record<string, { model?: string; providerId?: string; promptPreamble?: string; toolPolicy?: 'readOnly' | 'inherit'; blockedTools?: string[]; blockedMcpServers?: string[]; blockedSkills?: string[] }>
     sessionStore?: InMemorySessionStore
     executor?: ConstructorParameters<typeof DelegationRuntime>[0]['executor']
     recordExternalUsage?: ConstructorParameters<typeof DelegationRuntime>[0]['recordExternalUsage']
diff --git a/kun/tests/domain.test.ts b/kun/tests/domain.test.ts
index fb865273c..c8fde108e 100644
--- a/kun/tests/domain.test.ts
+++ b/kun/tests/domain.test.ts
@@ -64,12 +64,14 @@ describe('domain.thread', () => {
       workspace: '/tmp',
       model: 'deepseek-chat',
       approvalPolicy: 'on-request',
-      sandboxMode: 'read-only'
+      sandboxMode: 'read-only',
+      pinned: true
     })
     const summary = toThreadSummary(thread)
     expect(summary).not.toHaveProperty('turns')
     expect(summary.approvalPolicy).toBe('on-request')
     expect(summary.sandboxMode).toBe('read-only')
+    expect(summary.pinned).toBe(true)
   })
 })
 
diff --git a/kun/tests/http-server.test.ts b/kun/tests/http-server.test.ts
index fb64100bf..3868a3b9d 100644
--- a/kun/tests/http-server.test.ts
+++ b/kun/tests/http-server.test.ts
@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { join, resolve } from 'node:path'
 import { dispatchRequest } from '../src/server/http-server.js'
 import { createApprovalRequest } from '../src/domain/approval.js'
 import { makeAssistantTextItem, makeToolCallItem, makeToolResultItem } from '../src/domain/item.js'
@@ -116,6 +116,7 @@ describe('HTTP server', () => {
       skills: {
         enabled: false,
         roots: [],
+        globalRoots: [],
         skills: [],
         validationErrors: [],
         lastActivations: []
@@ -174,6 +175,7 @@ describe('HTTP server', () => {
     h.runtime.skills = () => ({
       enabled: true,
       roots: ['/tmp/skills'],
+      globalRoots: [],
       skills: [
         {
           id: 'review',
@@ -181,6 +183,7 @@ describe('HTTP server', () => {
           description: 'Review the current change',
           version: '1.0.0',
           root: '/tmp/skills/review',
+          source: 'project' as const,
           legacy: false,
           triggers: { commands: ['/review'], promptPatterns: [], fileTypes: [] },
           allowedTools: ['read']
@@ -857,6 +860,30 @@ describe('HTTP server', () => {
     const body = (await readJson(decide)) as { decision: string }
     expect(body.decision).toBe('allow')
     await expect(pending).resolves.toBe('allow')
+
+    const replay = await dispatchRequest(
+      h.router,
+      new Request('http://localhost/v1/approvals/appr_1', {
+        method: 'POST',
+        headers: { authorization: 'Bearer tok-1', 'content-type': 'application/json' },
+        body: JSON.stringify({ decision: 'allow' })
+      })
+    )
+    expect(replay.status).toBe(200)
+    expect(await readJson(replay)).toMatchObject({
+      decision: 'allow',
+      alreadyResolved: true
+    })
+
+    const conflict = await dispatchRequest(
+      h.router,
+      new Request('http://localhost/v1/approvals/appr_1', {
+        method: 'POST',
+        headers: { authorization: 'Bearer tok-1', 'content-type': 'application/json' },
+        body: JSON.stringify({ decision: 'deny' })
+      })
+    )
+    expect(conflict.status).toBe(409)
   })
 
   it('resolves GUI user input through both HTTP compatibility endpoints', async () => {
@@ -1269,6 +1296,6 @@ describe('HTTP server', () => {
     )
     expect(response.status).toBe(200)
     const body = (await readJson(response)) as { path: string }
-    expect(body.path).toBe('/tmp')
+    expect(body.path).toBe(resolve('/tmp'))
   })
 })
diff --git a/kun/tests/loop.test.ts b/kun/tests/loop.test.ts
index 5fc68c2ad..e04f96cf0 100644
--- a/kun/tests/loop.test.ts
+++ b/kun/tests/loop.test.ts
@@ -10,6 +10,7 @@ import { GET_GOAL_TOOL_NAME, UPDATE_GOAL_TOOL_NAME } from '../src/adapters/tool/
 import { FileThreadStore, FileSessionStore } from '../src/adapters/file/index.js'
 import { RuntimeEventRecorder } from '../src/services/runtime-event-recorder.js'
 import { ContextCompactor } from '../src/loop/context-compactor.js'
+import { COMPACTION_SYSTEM_PROMPT } from '../src/loop/compaction-summary.js'
 import { effectiveHistoryAfterLatestCompaction } from '../src/loop/compaction-history.js'
 import { resolveModelContextProfile } from '../src/loop/model-context-profile.js'
 import { isPlanClarifyingQuestion } from '../src/loop/agent-loop.js'
@@ -2347,7 +2348,7 @@ describe('AgentLoop', () => {
         async *stream(request: ModelRequest): AsyncIterable<ModelStreamChunk> {
           requests.push(request)
           const isSummaryRequest = request.tools.length === 0 &&
-            request.contextInstructions?.some((text) => text.includes('history fold'))
+            request.systemPrompt === COMPACTION_SYSTEM_PROMPT
           if (isSummaryRequest) {
             yield {
               kind: 'usage',
@@ -2398,23 +2399,25 @@ describe('AgentLoop', () => {
     const status = await h.loop.runTurn(h.threadId, h.turnId)
     const [summaryRequest, mainRequest] = requests
     if (!summaryRequest || !mainRequest) throw new Error('expected summary and main model requests')
-    const summaryPromptItem = summaryRequest.history[0]
+    const summaryContinuation = summaryRequest.history[summaryRequest.history.length - 1]
     const persisted = await h.sessionStore.loadItems(h.threadId)
     const persistedSummary = persisted.find((item) => item.kind === 'compaction')
     const mainSummary = mainRequest.history.find((item) => item.kind === 'compaction')
 
     expect(status).toBe('completed')
     expect(requests).toHaveLength(2)
-    expect(summaryRequest.systemPrompt).toBe('be brief')
-    expect(summaryRequest.prefix).toBe(h.prefix.fewShots)
+    // Compaction-mode turn: dedicated summarizer system prompt, no main prefix,
+    // and the real conversation fed as messages with a free-form continuation.
+    expect(summaryRequest.systemPrompt).toBe(COMPACTION_SYSTEM_PROMPT)
+    expect(summaryRequest.prefix).toEqual([])
     expect(summaryRequest.tools).toEqual([])
     expect(summaryRequest.maxTokens).toBe(333)
     expect(summaryRequest.temperature).toBe(0)
     expect(summaryRequest.reasoningEffort).toBe('off')
-    expect(summaryRequest.contextInstructions?.join('\n')).toContain('history fold')
-    expect(summaryPromptItem?.kind).toBe('user_message')
-    expect(summaryPromptItem?.kind === 'user_message' ? summaryPromptItem.text : '')
-      .toContain('Conversation history to fold')
+    expect(summaryRequest.history.some((item) => item.id === 'model_summary_hist_0')).toBe(true)
+    expect(summaryContinuation?.kind).toBe('user_message')
+    expect(summaryContinuation?.kind === 'user_message' ? summaryContinuation.text : '')
+      .toContain('Provide a detailed summary of our conversation above')
     expect(mainSummary?.kind === 'compaction' ? mainSummary.summary : '')
       .toContain('Model summary: preserve alpha.txt')
     expect(persistedSummary?.kind === 'compaction' ? persistedSummary.summary : '')
@@ -2430,7 +2433,7 @@ describe('AgentLoop', () => {
         async *stream(request: ModelRequest): AsyncIterable<ModelStreamChunk> {
           requests.push(request)
           const isSummaryRequest = request.tools.length === 0 &&
-            request.contextInstructions?.some((text) => text.includes('history fold'))
+            request.systemPrompt === COMPACTION_SYSTEM_PROMPT
           if (isSummaryRequest) {
             yield { kind: 'error', message: 'summary model unavailable', code: 'summary_down' }
             return
diff --git a/kun/tests/mcp-config.test.ts b/kun/tests/mcp-config.test.ts
index e73958aff..4d7e35780 100644
--- a/kun/tests/mcp-config.test.ts
+++ b/kun/tests/mcp-config.test.ts
@@ -10,6 +10,7 @@ describe('MCP config', () => {
     const server = McpServerConfig.parse({
       transport: 'stdio',
       command: 'node',
+      cwd: '/tmp/project',
       args: ['server.js'],
       env: { API_KEY: 'secret' },
       trustScope: 'workspace',
@@ -18,6 +19,7 @@ describe('MCP config', () => {
 
     expect(server.enabled).toBe(true)
     expect(server.transport).toBe('stdio')
+    expect(server.cwd).toBe('/tmp/project')
     expect(server.timeoutMs).toBe(30_000)
   })
 
diff --git a/kun/tests/mcp-tool-provider.test.ts b/kun/tests/mcp-tool-provider.test.ts
index 3fe4ad33c..c0b647171 100644
--- a/kun/tests/mcp-tool-provider.test.ts
+++ b/kun/tests/mcp-tool-provider.test.ts
@@ -7,6 +7,7 @@ import {
   formatMcpConnectionError,
   isMcpServerTrusted,
   normalizeMcpToolName,
+  resolveMcpServerCwd,
   type McpClientLike
 } from '../src/adapters/tool/mcp-tool-provider.js'
 import { REDACTED_SECRET } from '../src/config/secret-redaction.js'
@@ -138,6 +139,26 @@ describe('MCP tool provider', () => {
     expect(isMcpServerTrusted(server, '/tmp/other')).toBe(false)
   })
 
+  it('resolves stdio MCP working directories from explicit config or trusted workspace fallback', () => {
+    const base = {
+      enabled: true,
+      transport: 'stdio',
+      command: 'node',
+      args: [],
+      url: undefined,
+      headers: {},
+      env: {},
+      trustScope: 'workspace',
+      trustedWorkspaceRoots: ['/tmp/project'],
+      timeoutMs: 30_000
+    } satisfies McpServerConfig
+
+    expect(resolveMcpServerCwd({ ...base, cwd: '/tmp/explicit' })).toBe('/tmp/explicit')
+    expect(resolveMcpServerCwd(base)).toBe('/tmp/project')
+    expect(resolveMcpServerCwd({ ...base, trustScope: 'user', trustedWorkspaceRoots: [] })).toBeUndefined()
+    expect(resolveMcpServerCwd({ ...base, transport: 'streamable-http', url: 'https://mcp.example.test' })).toBeUndefined()
+  })
+
   it('builds registry providers from connected MCP clients and executes tools', async () => {
     const config = KunCapabilitiesConfig.parse({
       mcp: {
diff --git a/kun/tests/mcp-tool-search.test.ts b/kun/tests/mcp-tool-search.test.ts
new file mode 100644
index 000000000..3a9c56caa
--- /dev/null
+++ b/kun/tests/mcp-tool-search.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest'
+import { CapabilityRegistry } from '../src/adapters/tool/capability-registry.js'
+import { LocalToolHost } from '../src/adapters/tool/local-tool-host.js'
+import {
+  createMcpSearchProvider,
+  type McpSearchCatalogRecord
+} from '../src/adapters/tool/mcp-tool-search.js'
+import { KunCapabilitiesConfig, McpServerConfig } from '../src/contracts/capabilities.js'
+import type { ToolHostContext } from '../src/ports/tool-host.js'
+
+const SEARCH_CONFIG = KunCapabilitiesConfig.parse({
+  mcp: { enabled: true, search: { enabled: true, mode: 'search' } }
+}).mcp.search
+
+const SERVER = McpServerConfig.parse({ transport: 'stdio', command: 'noop', trustScope: 'user' })
+
+function record(serverId: string, toolName: string, calls: string[]): McpSearchCatalogRecord {
+  return {
+    toolId: `${serverId}/${toolName}`,
+    serverId,
+    server: SERVER,
+    client: {
+      async callTool(input) {
+        calls.push(`${serverId}/${input.name}`)
+        return { ok: true }
+      }
+    },
+    descriptor: { name: toolName, description: `${toolName} on ${serverId}` },
+    normalizedName: `mcp_${serverId}_${toolName}`,
+    policy: 'auto'
+  }
+}
+
+function ctx(overrides: Partial<ToolHostContext> = {}): ToolHostContext {
+  return {
+    threadId: 't',
+    turnId: 'u',
+    workspace: '/ws',
+    approvalPolicy: 'auto',
+    abortSignal: new AbortController().signal,
+    awaitApproval: async () => 'allow',
+    ...overrides
+  }
+}
+
+describe('MCP search provider honors blockedProviderIds', () => {
+  it('hides a blocked server from mcp_search/mcp_describe/mcp_call but leaves others reachable', async () => {
+    const calls: string[] = []
+    const records = [record('github', 'create_issue', calls), record('files', 'read_file', calls)]
+    const host = new LocalToolHost({
+      registry: new CapabilityRegistry([
+        createMcpSearchProvider({
+          config: SEARCH_CONFIG,
+          state: { records },
+          refreshCatalog: async () => records,
+          isServerTrusted: () => true
+        })
+      ])
+    })
+    const blocked = ctx({ blockedProviderIds: ['mcp:github'] })
+
+    // mcp_search must not surface the blocked server's tool, and reports a
+    // reduced searched-tools count.
+    const search = await host.execute(
+      { callId: 'c0', toolName: 'mcp_search', arguments: { query: 'create issue github' } },
+      blocked
+    )
+    expect(search.item.kind).toBe('tool_result')
+    if (search.item.kind === 'tool_result') {
+      const output = search.item.output as { searchedTools: number; results: Array<{ serverId: string }> }
+      expect(output.searchedTools).toBe(1)
+      expect(output.results.every((r) => r.serverId !== 'github')).toBe(true)
+    }
+
+    // mcp_describe (schema disclosure) is refused for the blocked server.
+    const describeBlocked = await host.execute(
+      { callId: 'c1', toolName: 'mcp_describe', arguments: { toolId: 'github/create_issue' } },
+      blocked
+    )
+    expect(describeBlocked.item).toMatchObject({ kind: 'tool_result', isError: true })
+
+    // mcp_call (execution) is refused AND the underlying client is never invoked.
+    const callBlocked = await host.execute(
+      { callId: 'c2', toolName: 'mcp_call', arguments: { toolId: 'github/create_issue', arguments: {} } },
+      blocked
+    )
+    expect(callBlocked.item).toMatchObject({ kind: 'tool_result', isError: true })
+    expect(calls).toEqual([])
+
+    // A non-blocked server still works.
+    const callOk = await host.execute(
+      { callId: 'c3', toolName: 'mcp_call', arguments: { toolId: 'files/read_file', arguments: {} } },
+      blocked
+    )
+    expect(callOk.item).toMatchObject({ kind: 'tool_result', isError: false })
+    expect(calls).toEqual(['files/read_file'])
+
+    // Without a deny-list the blocked server is reachable again (the deny is
+    // per-turn, not baked into the catalog).
+    const callDefault = await host.execute(
+      { callId: 'c4', toolName: 'mcp_call', arguments: { toolId: 'github/create_issue', arguments: {} } },
+      ctx()
+    )
+    expect(callDefault.item).toMatchObject({ kind: 'tool_result', isError: false })
+    expect(calls).toEqual(['files/read_file', 'github/create_issue'])
+  })
+})
diff --git a/kun/tests/model-client.test.ts b/kun/tests/model-client.test.ts
index 1ef1350e9..9da15a53c 100644
--- a/kun/tests/model-client.test.ts
+++ b/kun/tests/model-client.test.ts
@@ -512,7 +512,9 @@ describe('CompatModelClient', () => {
     })
     expect(sentBodies[0]).toMatchObject({
       model: 'deepseek-chat',
-      max_tokens: 4096,
+      // Non-reasoning messages default (raised from 4096 so reasoning models
+      // don't truncate their tool calls; this model has no reasoning metadata).
+      max_tokens: 8192,
       system: [{
         type: 'text',
         text: 'You are a helpful assistant.',
diff --git a/kun/tests/skill-runtime.test.ts b/kun/tests/skill-runtime.test.ts
index 110dd49e8..804dccd1f 100644
--- a/kun/tests/skill-runtime.test.ts
+++ b/kun/tests/skill-runtime.test.ts
@@ -109,7 +109,8 @@ describe('SkillRuntime', () => {
       const runtime = await createRuntime()
 
       expect(runtime.diagnostics().skills.map((skill) => skill.id)).toContain('linked')
-      expect(runtime.resolveTurn({ prompt: '/linked go', workspace: root }).activeSkillIds).toEqual(['linked'])
+      await expect(runtime.resolveTurn({ prompt: '/linked go', workspace: root }))
+        .resolves.toMatchObject({ activeSkillIds: ['linked'] })
     } finally {
       await rm(realDir, { recursive: true, force: true })
     }
@@ -129,7 +130,7 @@ describe('SkillRuntime', () => {
     }, 'small instructions')
     const runtime = await createRuntime({ instructionBudgetBytes: 600 })
 
-    const resolution = runtime.resolveTurn({
+    const resolution = await runtime.resolveTurn({
       prompt: 'Please handle TypeScript in src/app.ts',
       workspace: root
     })
@@ -157,6 +158,60 @@ describe('SkillRuntime', () => {
     expect(catalog).toContain('### How to use skills')
   })
 
+  it('scopes the dynamic skill catalog to the current workspace', async () => {
+    const workspaceA = await mkdtemp(join(tmpdir(), 'kun-skill-workspace-a-'))
+    const workspaceB = await mkdtemp(join(tmpdir(), 'kun-skill-workspace-b-'))
+    try {
+      const rootA = join(workspaceA, '.agents', 'skills')
+      const rootB = join(workspaceB, '.agents', 'skills')
+      await writeSkillAt(rootA, 'alpha', {
+        id: 'alpha',
+        name: 'Alpha',
+        triggers: { commands: ['/alpha'] }
+      }, 'alpha instructions')
+      await writeSkillAt(rootB, 'beta', {
+        id: 'beta',
+        name: 'Beta',
+        triggers: { commands: ['/beta'] }
+      }, 'beta instructions')
+
+      const config = KunCapabilitiesConfig.parse({
+        skills: {
+          enabled: true,
+          roots: [rootA, rootB],
+          workspaceRoots: [workspaceA, workspaceB],
+          legacySkillMd: true
+        }
+      })
+      const runtime = await SkillRuntime.create(config.skills)
+      const workspaceAResolution = await runtime.resolveTurn({ prompt: '/alpha run', workspace: workspaceA })
+      const workspaceBResolution = await runtime.resolveTurn({ prompt: '/beta run', workspace: workspaceB })
+
+      expect(workspaceAResolution.catalogInstruction).toContain('Alpha')
+      expect(workspaceAResolution.catalogInstruction).not.toContain('Beta')
+      expect(workspaceAResolution.activeSkillIds).toEqual(['alpha'])
+      expect(workspaceBResolution.catalogInstruction).toContain('Beta')
+      expect(workspaceBResolution.catalogInstruction).not.toContain('Alpha')
+      expect(workspaceBResolution.activeSkillIds).toEqual(['beta'])
+
+      const disabledConfig = KunCapabilitiesConfig.parse({
+        skills: {
+          enabled: true,
+          roots: [rootA],
+          workspaceRoots: [workspaceA, workspaceB],
+          legacySkillMd: true
+        }
+      })
+      const disabledRuntime = await SkillRuntime.create(disabledConfig.skills)
+      const disabledResolution = await disabledRuntime.resolveTurn({ prompt: '/beta run', workspace: workspaceB })
+      expect(disabledResolution.catalogInstruction).toBeUndefined()
+      expect(disabledResolution.activeSkillIds).toEqual([])
+    } finally {
+      await rm(workspaceA, { recursive: true, force: true })
+      await rm(workspaceB, { recursive: true, force: true })
+    }
+  })
+
   it('truncates the catalog when the byte budget is exceeded', async () => {
     await writeSkill('one', { id: 'one', name: 'One', description: 'd'.repeat(400) }, 'b')
     await writeSkill('two', { id: 'two', name: 'Two', description: 'd'.repeat(400) }, 'b')
@@ -168,7 +223,7 @@ describe('SkillRuntime', () => {
   })
 
   it('returns no catalog when skills are disabled', async () => {
-    const runtime = await SkillRuntime.create({ enabled: false, roots: [], legacySkillMd: true })
+    const runtime = await SkillRuntime.create({ enabled: false, roots: [], workspaceRoots: [], globalRoots: [], disabledIds: [], legacySkillMd: true })
     expect(runtime.catalogInstruction()).toBeUndefined()
   })
 
@@ -182,7 +237,7 @@ describe('SkillRuntime', () => {
     const runtime = await createRuntime()
 
     for (const ref of ['gamma', '$gamma', '@gamma', 'skill:gamma']) {
-      const result = runtime.loadSkillById(ref)
+      const result = await runtime.loadSkillById(ref)
       expect('error' in result).toBe(false)
       if ('error' in result) continue
       expect(result.skillId).toBe('gamma')
@@ -197,16 +252,79 @@ describe('SkillRuntime', () => {
     await writeSkill('known', { id: 'known', name: 'Known' }, 'body')
     const runtime = await createRuntime()
 
-    const result = runtime.loadSkillById('does-not-exist')
+    const result = await runtime.loadSkillById('does-not-exist')
     expect('error' in result).toBe(true)
     if ('error' in result) expect(result.error).toContain('known')
   })
 
+  it('excludes disabledIds from catalog, matching, load, and diagnostics', async () => {
+    await writeSkill('gmail', {
+      id: 'gmail',
+      name: 'Gmail',
+      triggers: { commands: ['/gmail'] }
+    }, 'gmail body')
+    await writeSkill('keeper', {
+      id: 'keeper',
+      name: 'Keeper',
+      triggers: { commands: ['/keeper'] }
+    }, 'keeper body')
+    // Mixed-case / prefixed forms must still match the slugged discovered id.
+    const runtime = await createRuntime({}, { disabledIds: ['Gmail', 'skill:nonexistent'] })
+
+    // diagnostics + count
+    expect(runtime.diagnostics().skills.map((skill) => skill.id)).toEqual(['keeper'])
+    expect(runtime.count()).toBe(1)
+
+    // global catalog
+    expect(runtime.catalogInstruction()).not.toContain('Gmail')
+    expect(runtime.catalogInstruction()).toContain('Keeper')
+
+    // per-turn catalog + auto-match (command trigger)
+    const resolution = await runtime.resolveTurn({ prompt: '/gmail send', workspace: root })
+    expect(resolution.catalogInstruction).not.toContain('Gmail')
+    expect(resolution.activeSkillIds).not.toContain('gmail')
+
+    // load_skill
+    const result = await runtime.loadSkillById('gmail')
+    expect('error' in result).toBe(true)
+  })
+
+  it('excludes per-call blockedSkillIds from resolveTurn + load_skill without mutating siblings', async () => {
+    await writeSkill('gmail', {
+      id: 'gmail',
+      name: 'Gmail',
+      triggers: { commands: ['/gmail'] }
+    }, 'gmail body')
+    await writeSkill('keeper', {
+      id: 'keeper',
+      name: 'Keeper',
+      triggers: { commands: ['/keeper'] }
+    }, 'keeper body')
+    const runtime = await createRuntime()
+
+    // A child whose profile blocks gmail: hidden from the per-turn catalog and
+    // auto-match. The `skill:`-prefixed + mixed-case form must still match the
+    // slugged discovered id (mirrors load_skill's accepted forms).
+    const blocked = await runtime.resolveTurn({ prompt: '/gmail send', workspace: root, blockedSkillIds: ['skill:Gmail'] })
+    expect(blocked.catalogInstruction).not.toContain('Gmail')
+    expect(blocked.catalogInstruction).toContain('Keeper')
+    expect(blocked.activeSkillIds).not.toContain('gmail')
+    // load_skill rejects the blocked id for that child.
+    expect('error' in (await runtime.loadSkillById('gmail', root, ['gmail']))).toBe(true)
+
+    // The shared runtime is NOT mutated: a sibling call with no deny-list still
+    // sees gmail in the catalog, auto-activates it, and can load it.
+    const sibling = await runtime.resolveTurn({ prompt: '/gmail send', workspace: root })
+    expect(sibling.catalogInstruction).toContain('Gmail')
+    expect(sibling.activeSkillIds).toContain('gmail')
+    expect('error' in (await runtime.loadSkillById('gmail', root))).toBe(false)
+  })
+
   it('truncates an oversized skill body to the instruction budget on load', async () => {
     await writeSkill('huge', { id: 'huge', name: 'Huge' }, 'z'.repeat(5_000))
     const runtime = await createRuntime({ instructionBudgetBytes: 1_000 })
 
-    const result = runtime.loadSkillById('huge')
+    const result = await runtime.loadSkillById('huge')
     expect('error' in result).toBe(false)
     if ('error' in result) return
     expect(result.truncated).toBe(true)
@@ -228,7 +346,7 @@ describe('SkillRuntime', () => {
       allowedTools: ['bash']
     }, 'Use bash')
     const runtime = await createRuntime()
-    const resolution = runtime.resolveTurn({
+    const resolution = await runtime.resolveTurn({
       prompt: '/readonly inspect',
       workspace: root
     })
@@ -283,7 +401,8 @@ describe('SkillRuntime', () => {
     await runtime.refresh()
 
     expect(runtime.count()).toBe(1)
-    expect(runtime.resolveTurn({ prompt: '/new run', workspace: root }).activeSkillIds).toEqual(['new'])
+    await expect(runtime.resolveTurn({ prompt: '/new run', workspace: root }))
+      .resolves.toMatchObject({ activeSkillIds: ['new'] })
   })
 
   it('injects active Skills into AgentLoop context and turn metadata', async () => {
@@ -326,19 +445,24 @@ describe('SkillRuntime', () => {
 
     await h.loop.runTurn(h.threadId, h.turnId)
 
-    expect(seenRequest?.contextInstructions?.[0]).toContain('Always inspect the diff first.')
+    expect(seenRequest?.contextInstructions?.join('\n')).toContain('Always inspect the diff first.')
     expect(seenRequest?.tools.map((tool) => tool.name)).toEqual(['read'])
     const turn = await h.turns.getTurn(h.threadId, h.turnId)
     expect(turn?.activeSkillIds).toEqual(['review'])
     expect(turn?.skillInjectionBytes).toBeGreaterThan(0)
   })
 
-  async function createRuntime(options: Parameters<typeof SkillRuntime.create>[1] = {}) {
+  async function createRuntime(
+    options: Parameters<typeof SkillRuntime.create>[1] = {},
+    skillsOverride: Record<string, unknown> = {}
+  ) {
     const config = KunCapabilitiesConfig.parse({
       skills: {
         enabled: true,
         roots: [root],
-        legacySkillMd: true
+        workspaceRoots: [],
+        legacySkillMd: true,
+        ...skillsOverride
       }
     })
     return SkillRuntime.create(config.skills, options)
@@ -349,7 +473,16 @@ describe('SkillRuntime', () => {
     manifest: Record<string, unknown>,
     entry: string
   ): Promise<void> {
-    const dir = join(root, folder)
+    await writeSkillAt(root, folder, manifest, entry)
+  }
+
+  async function writeSkillAt(
+    parentRoot: string,
+    folder: string,
+    manifest: Record<string, unknown>,
+    entry: string
+  ): Promise<void> {
+    const dir = join(parentRoot, folder)
     await mkdir(dir, { recursive: true })
     const entryName = typeof manifest.entry === 'string' ? manifest.entry : 'SKILL.md'
     await writeFile(join(dir, 'skill.json'), JSON.stringify(manifest), 'utf8')
diff --git a/kun/tests/skill-tool-provider.test.ts b/kun/tests/skill-tool-provider.test.ts
index 644ebc750..c5d2dc94a 100644
--- a/kun/tests/skill-tool-provider.test.ts
+++ b/kun/tests/skill-tool-provider.test.ts
@@ -29,7 +29,7 @@ describe('buildSkillToolProviders', () => {
   }
 
   it('returns no provider when no skills are loaded', async () => {
-    const runtime = await SkillRuntime.create({ enabled: false, roots: [], legacySkillMd: true })
+    const runtime = await SkillRuntime.create({ enabled: false, roots: [], workspaceRoots: [], globalRoots: [], disabledIds: [], legacySkillMd: true })
     expect(buildSkillToolProviders(runtime)).toEqual([])
     expect(buildSkillToolProviders(undefined)).toEqual([])
   })
diff --git a/kun/tests/workspace-agents.test.ts b/kun/tests/workspace-agents.test.ts
new file mode 100644
index 000000000..b64d3bd29
--- /dev/null
+++ b/kun/tests/workspace-agents.test.ts
@@ -0,0 +1,108 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { loadWorkspaceAgentProfiles } from '../src/delegation/workspace-agents.js'
+
+describe('loadWorkspaceAgentProfiles', () => {
+  let workspace: string
+
+  beforeEach(async () => {
+    workspace = await mkdtemp(join(tmpdir(), 'kun-ws-agents-'))
+    await mkdir(join(workspace, '.kun', 'agents'), { recursive: true })
+  })
+
+  afterEach(async () => {
+    await rm(workspace, { recursive: true, force: true }).catch(() => undefined)
+  })
+
+  it('returns an empty list when the agents directory is missing', async () => {
+    const empty = await mkdtemp(join(tmpdir(), 'kun-ws-empty-'))
+    expect(await loadWorkspaceAgentProfiles(empty)).toEqual([])
+    await rm(empty, { recursive: true, force: true })
+  })
+
+  it('parses a minimal frontmatter agent file', async () => {
+    await writeFile(
+      join(workspace, '.kun', 'agents', 'reviewer.md'),
+      [
+        '---',
+        'name: Reviewer',
+        'description: 检查代码',
+        'mode: subagent',
+        'toolPolicy: readOnly',
+        '---',
+        'You are a careful reviewer.'
+      ].join('\n')
+    )
+    const profiles = await loadWorkspaceAgentProfiles(workspace)
+    expect(profiles).toHaveLength(1)
+    const entry = profiles[0]!
+    expect(entry.id).toBe('reviewer')
+    expect(entry.profile.name).toBe('Reviewer')
+    expect(entry.profile.description).toBe('检查代码')
+    expect(entry.profile.mode).toBe('subagent')
+    expect(entry.profile.toolPolicy).toBe('readOnly')
+    // Body becomes the systemPrompt when no explicit field is given.
+    expect(entry.profile.systemPrompt).toBe('You are a careful reviewer.')
+  })
+
+  it('uses explicit id, parses allowedTools list, and falls back to subagent mode', async () => {
+    await writeFile(
+      join(workspace, '.kun', 'agents', 'security.md'),
+      [
+        '---',
+        'id: security-reviewer',
+        'name: Security Reviewer',
+        'allowedTools: [read, grep, ls]',
+        'model: deepseek-chat',
+        'providerId: deepseek',
+        'color: "#10b981"',
+        '---'
+      ].join('\n')
+    )
+    const profiles = await loadWorkspaceAgentProfiles(workspace)
+    expect(profiles).toHaveLength(1)
+    const entry = profiles[0]!
+    expect(entry.id).toBe('security-reviewer')
+    expect(entry.profile.allowedTools).toEqual(['read', 'grep', 'ls'])
+    expect(entry.profile.providerId).toBe('deepseek')
+    expect(entry.profile.color).toBe('#10b981')
+    expect(entry.profile.mode).toBe('subagent')
+  })
+
+  it('parses blockedTools / blockedMcpServers / blockedSkills deny-lists from frontmatter', async () => {
+    await writeFile(
+      join(workspace, '.kun', 'agents', 'scoped.md'),
+      [
+        '---',
+        'id: scoped',
+        'name: Scoped',
+        'toolPolicy: inherit',
+        'blockedTools: [bash, write]',
+        'blockedMcpServers: [github]',
+        'blockedSkills: [deep-research, pdf]',
+        '---'
+      ].join('\n')
+    )
+    const profiles = await loadWorkspaceAgentProfiles(workspace)
+    const entry = profiles.find((p) => p.id === 'scoped')!
+    expect(entry.profile.blockedTools).toEqual(['bash', 'write'])
+    expect(entry.profile.blockedMcpServers).toEqual(['github'])
+    expect(entry.profile.blockedSkills).toEqual(['deep-research', 'pdf'])
+  })
+
+  it('drops files without frontmatter silently', async () => {
+    await writeFile(
+      join(workspace, '.kun', 'agents', 'no-front.md'),
+      'Plain markdown without YAML frontmatter.'
+    )
+    await writeFile(
+      join(workspace, '.kun', 'agents', 'real.md'),
+      '---\nname: Real\nmode: all\ntoolPolicy: inherit\n---\nBody.'
+    )
+    const profiles = await loadWorkspaceAgentProfiles(workspace)
+    expect(profiles.map((p) => p.id)).toEqual(['real'])
+  })
+})
diff --git a/src/asset/img/kun_cheer.png b/src/asset/img/kun_cheer.png
new file mode 100644
index 000000000..ec13c5b69
Binary files /dev/null and b/src/asset/img/kun_cheer.png differ
diff --git a/src/asset/img/kun_clip.png b/src/asset/img/kun_clip.png
new file mode 100644
index 000000000..9829a4fe3
Binary files /dev/null and b/src/asset/img/kun_clip.png differ
diff --git a/src/asset/img/kun_headset.png b/src/asset/img/kun_headset.png
new file mode 100644
index 000000000..18da18b08
Binary files /dev/null and b/src/asset/img/kun_headset.png differ
diff --git a/src/asset/img/kun_laptop.png b/src/asset/img/kun_laptop.png
new file mode 100644
index 000000000..9c5c3f530
Binary files /dev/null and b/src/asset/img/kun_laptop.png differ
diff --git a/src/asset/img/kun_magic.png b/src/asset/img/kun_magic.png
new file mode 100644
index 000000000..550acee48
Binary files /dev/null and b/src/asset/img/kun_magic.png differ
diff --git a/src/asset/img/kun_rest.png b/src/asset/img/kun_rest.png
new file mode 100644
index 000000000..f16a9d96b
Binary files /dev/null and b/src/asset/img/kun_rest.png differ
diff --git a/src/asset/img/kun_search.png b/src/asset/img/kun_search.png
new file mode 100644
index 000000000..48b9db30d
Binary files /dev/null and b/src/asset/img/kun_search.png differ
diff --git a/src/asset/img/kun_wrench.png b/src/asset/img/kun_wrench.png
new file mode 100644
index 000000000..a4a4c3aa4
Binary files /dev/null and b/src/asset/img/kun_wrench.png differ
diff --git a/src/main/claw-runtime.test.ts b/src/main/claw-runtime.test.ts
index 5804c2a01..323d252cb 100644
--- a/src/main/claw-runtime.test.ts
+++ b/src/main/claw-runtime.test.ts
@@ -24,13 +24,14 @@ function buildSettings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: defaultKunRuntimeSettings()
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
@@ -359,6 +360,8 @@ describe('ClawRuntime', () => {
 
   it('accepts assistant_text items when waiting for a Claw turn result', async () => {
     const settings = buildSettings()
+    settings.agents.kun.approvalPolicy = 'on-request'
+    settings.agents.kun.sandboxMode = 'workspace-write'
     const runtimeRequest = vi.fn(async (_settings, path, init) => {
       if (path === '/v1/threads') {
         return { ok: true, status: 200, body: JSON.stringify({ id: 'thr_1' }) }
@@ -422,19 +425,243 @@ describe('ClawRuntime', () => {
       ([, path, init]) => path === '/v1/threads' && init?.method === 'POST'
     )
     expect(JSON.parse(String(createThreadCall?.[2]?.body ?? '{}'))).toMatchObject({
-      approvalPolicy: 'auto',
-      sandboxMode: 'danger-full-access'
+      approvalPolicy: 'on-request',
+      sandboxMode: 'workspace-write'
     })
     const turnCall = runtimeRequest.mock.calls.find(
       ([, path, init]) => path === '/v1/threads/thr_1/turns' && init?.method === 'POST'
     )
     expect(JSON.parse(String(turnCall?.[2]?.body ?? '{}'))).toMatchObject({
       disableUserInput: true,
-      approvalPolicy: 'auto',
-      sandboxMode: 'danger-full-access'
+      approvalPolicy: 'on-request',
+      sandboxMode: 'workspace-write'
+    })
+  })
+
+  it('passes non-default agent approval/sandbox settings through to IM turns without downgrading', async () => {
+    const settings = buildSettings()
+    settings.agents.kun.approvalPolicy = 'untrusted'
+    settings.agents.kun.sandboxMode = 'read-only'
+    const runtimeRequest = vi.fn(async (_settings, path, init) => {
+      if (path === '/v1/threads') {
+        return { ok: true, status: 200, body: JSON.stringify({ id: 'thr_1' }) }
+      }
+      if (path === '/v1/threads/thr_1' && init?.method === 'PATCH') {
+        return { ok: true, status: 200, body: '{}' }
+      }
+      if (path === '/v1/threads/thr_1' && init?.method === 'GET') {
+        return {
+          ok: true,
+          status: 200,
+          body: JSON.stringify({
+            thread: { id: 'thr_1', status: 'completed' },
+            turns: [{ id: 'turn_1', status: 'completed' }],
+            items: [{ kind: 'assistant_text', detail: 'ok' }]
+          })
+        }
+      }
+      if (path === '/v1/threads/thr_1/turns') {
+        return { ok: true, status: 202, body: JSON.stringify({ threadId: 'thr_1', turnId: 'turn_1' }) }
+      }
+      return { ok: true, status: 200, body: '{}' }
+    })
+    const runtime = createClawRuntime({
+      store: { load: vi.fn(async () => settings), patch: vi.fn(async () => settings) } as never,
+      runtimeRequest,
+      logError: () => undefined
+    })
+
+    await (runtime as unknown as {
+      runPrompt: (
+        settingsArg: AppSettingsV1,
+        options: {
+          prompt: string
+          title: string
+          workspaceRoot: string
+          model: string
+          mode: 'agent' | 'plan'
+          waitForResult: boolean
+          responseTimeoutMs: number
+          source: 'task' | 'im'
+        }
+      ) => Promise<{ ok: boolean; text?: string }>
+    }).runPrompt(settings, {
+      prompt: 'hello',
+      title: 'demo',
+      workspaceRoot: '/tmp/workspace',
+      model: 'auto',
+      mode: 'agent',
+      waitForResult: true,
+      responseTimeoutMs: 10,
+      source: 'im'
+    })
+
+    const createThreadCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads' && init?.method === 'POST'
+    )
+    expect(JSON.parse(String(createThreadCall?.[2]?.body ?? '{}'))).toMatchObject({
+      approvalPolicy: 'untrusted',
+      sandboxMode: 'read-only'
+    })
+    const turnCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads/thr_1/turns' && init?.method === 'POST'
+    )
+    expect(JSON.parse(String(turnCall?.[2]?.body ?? '{}'))).toMatchObject({
+      disableUserInput: true,
+      approvalPolicy: 'untrusted',
+      sandboxMode: 'read-only'
+    })
+  })
+
+  it('passes the never approval policy through to IM turns without escalating to auto', async () => {
+    const settings = buildSettings()
+    settings.agents.kun.approvalPolicy = 'never'
+    settings.agents.kun.sandboxMode = 'read-only'
+    const runtimeRequest = vi.fn(async (_settings, path, init) => {
+      if (path === '/v1/threads') {
+        return { ok: true, status: 200, body: JSON.stringify({ id: 'thr_1' }) }
+      }
+      if (path === '/v1/threads/thr_1' && init?.method === 'PATCH') {
+        return { ok: true, status: 200, body: '{}' }
+      }
+      if (path === '/v1/threads/thr_1' && init?.method === 'GET') {
+        return {
+          ok: true,
+          status: 200,
+          body: JSON.stringify({
+            thread: { id: 'thr_1', status: 'completed' },
+            turns: [{ id: 'turn_1', status: 'completed' }],
+            items: [{ kind: 'assistant_text', detail: 'ok' }]
+          })
+        }
+      }
+      if (path === '/v1/threads/thr_1/turns') {
+        return { ok: true, status: 202, body: JSON.stringify({ threadId: 'thr_1', turnId: 'turn_1' }) }
+      }
+      return { ok: true, status: 200, body: '{}' }
+    })
+    const runtime = createClawRuntime({
+      store: { load: vi.fn(async () => settings), patch: vi.fn(async () => settings) } as never,
+      runtimeRequest,
+      logError: () => undefined
+    })
+
+    await (runtime as unknown as {
+      runPrompt: (
+        settingsArg: AppSettingsV1,
+        options: {
+          prompt: string
+          title: string
+          workspaceRoot: string
+          model: string
+          mode: 'agent' | 'plan'
+          waitForResult: boolean
+          responseTimeoutMs: number
+          source: 'task' | 'im'
+        }
+      ) => Promise<{ ok: boolean; text?: string }>
+    }).runPrompt(settings, {
+      prompt: 'hello',
+      title: 'demo',
+      workspaceRoot: '/tmp/workspace',
+      model: 'auto',
+      mode: 'agent',
+      waitForResult: true,
+      responseTimeoutMs: 10,
+      source: 'im'
+    })
+
+    const createThreadCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads' && init?.method === 'POST'
+    )
+    expect(JSON.parse(String(createThreadCall?.[2]?.body ?? '{}'))).toMatchObject({
+      approvalPolicy: 'never',
+      sandboxMode: 'read-only'
+    })
+    const turnCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads/thr_1/turns' && init?.method === 'POST'
+    )
+    expect(JSON.parse(String(turnCall?.[2]?.body ?? '{}'))).toMatchObject({
+      disableUserInput: true,
+      approvalPolicy: 'never',
+      sandboxMode: 'read-only'
     })
   })
 
+  it('does not attach IM-only permission fields when source is not im', async () => {
+    const settings = buildSettings()
+    settings.agents.kun.approvalPolicy = 'untrusted'
+    settings.agents.kun.sandboxMode = 'read-only'
+    const runtimeRequest = vi.fn(async (_settings, path, init) => {
+      if (path === '/v1/threads') {
+        return { ok: true, status: 200, body: JSON.stringify({ id: 'thr_1' }) }
+      }
+      if (path === '/v1/threads/thr_1' && init?.method === 'PATCH') {
+        return { ok: true, status: 200, body: '{}' }
+      }
+      if (path === '/v1/threads/thr_1' && init?.method === 'GET') {
+        return {
+          ok: true,
+          status: 200,
+          body: JSON.stringify({
+            thread: { id: 'thr_1', status: 'completed' },
+            turns: [{ id: 'turn_1', status: 'completed' }],
+            items: [{ kind: 'assistant_text', detail: 'ok' }]
+          })
+        }
+      }
+      if (path === '/v1/threads/thr_1/turns') {
+        return { ok: true, status: 202, body: JSON.stringify({ threadId: 'thr_1', turnId: 'turn_1' }) }
+      }
+      return { ok: true, status: 200, body: '{}' }
+    })
+    const runtime = createClawRuntime({
+      store: { load: vi.fn(async () => settings), patch: vi.fn(async () => settings) } as never,
+      runtimeRequest,
+      logError: () => undefined
+    })
+
+    await (runtime as unknown as {
+      runPrompt: (
+        settingsArg: AppSettingsV1,
+        options: {
+          prompt: string
+          title: string
+          workspaceRoot: string
+          model: string
+          mode: 'agent' | 'plan'
+          waitForResult: boolean
+          responseTimeoutMs: number
+          source: 'task' | 'im'
+        }
+      ) => Promise<{ ok: boolean; text?: string }>
+    }).runPrompt(settings, {
+      prompt: 'hello',
+      title: 'demo',
+      workspaceRoot: '/tmp/workspace',
+      model: 'auto',
+      mode: 'agent',
+      waitForResult: true,
+      responseTimeoutMs: 10,
+      source: 'task'
+    })
+
+    const createThreadCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads' && init?.method === 'POST'
+    )
+    const createBody = JSON.parse(String(createThreadCall?.[2]?.body ?? '{}'))
+    expect(createBody).not.toHaveProperty('approvalPolicy')
+    expect(createBody).not.toHaveProperty('sandboxMode')
+    expect(createBody).not.toHaveProperty('disableUserInput')
+    const turnCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads/thr_1/turns' && init?.method === 'POST'
+    )
+    const turnBody = JSON.parse(String(turnCall?.[2]?.body ?? '{}'))
+    expect(turnBody).not.toHaveProperty('approvalPolicy')
+    expect(turnBody).not.toHaveProperty('sandboxMode')
+    expect(turnBody).not.toHaveProperty('disableUserInput')
+  })
+
   it('reads assistant text from the Kun thread detail shape used by the real runtime', async () => {
     const settings = buildSettings()
     const runtimeRequest = vi.fn(async (_settings, path, init) => {
@@ -1214,6 +1441,105 @@ describe('ClawRuntime', () => {
     })
   })
 
+  it('passes non-default agent approval/sandbox settings through the WeChat webhook path without downgrading', async () => {
+    const settings = buildSettings()
+    settings.claw.im.enabled = true
+    settings.claw.im.responseTimeoutMs = 2_500
+    settings.agents.kun.approvalPolicy = 'untrusted'
+    settings.agents.kun.sandboxMode = 'read-only'
+    settings.claw.channels = [buildChannel({
+      provider: 'weixin' as const,
+      id: 'channel_weixin',
+      label: 'WeChat',
+      threadId: '',
+      conversations: []
+    })]
+    const { store } = mutableSettingsStore(settings)
+    const runtimeRequest = vi.fn(async (_settings, path, init) => {
+      if (path === '/v1/threads' && init?.method === 'POST') {
+        return { ok: true, status: 201, body: JSON.stringify({ id: 'thr_weixin' }) }
+      }
+      if (path === '/v1/threads/thr_weixin' && init?.method === 'PATCH') {
+        return { ok: true, status: 200, body: '{}' }
+      }
+      if (path === '/v1/threads/thr_weixin/turns' && init?.method === 'POST') {
+        return { ok: true, status: 202, body: JSON.stringify({ turnId: 'turn_weixin' }) }
+      }
+      if (path === '/v1/threads/thr_weixin' && init?.method === 'GET') {
+        return {
+          ok: true,
+          status: 200,
+          body: JSON.stringify({
+            id: 'thr_weixin',
+            status: 'idle',
+            turns: [
+              {
+                id: 'turn_weixin',
+                status: 'completed',
+                items: [{ kind: 'assistant_text', text: 'hello from GUI' }]
+              }
+            ]
+          })
+        }
+      }
+      throw new Error(`unexpected path ${path}`)
+    })
+    const runtime = createClawRuntime({
+      store: store as never,
+      runtimeRequest: runtimeRequest as never,
+      logError: () => undefined,
+      createScheduledTaskFromText: vi.fn(async () => ({ kind: 'noop' as const }))
+    })
+    const body = JSON.stringify({
+      text: '你好',
+      provider: 'weixin',
+      channelId: 'channel_weixin',
+      chatId: 'wx_user_1',
+      messageId: 'wx_msg_1',
+      senderId: 'wx_user_1',
+      senderName: 'Alice'
+    })
+    const req = {
+      method: 'POST',
+      url: settings.claw.im.path,
+      headers: {},
+      async *[Symbol.asyncIterator]() {
+        yield Buffer.from(body)
+      }
+    }
+    let status = 0
+    let responseBody = ''
+    const res = {
+      writeHead: vi.fn((nextStatus: number) => {
+        status = nextStatus
+      }),
+      end: vi.fn((payload: string) => {
+        responseBody = payload
+      })
+    }
+
+    await (runtime as unknown as {
+      handleWebhook: (request: typeof req, response: typeof res) => Promise<void>
+    }).handleWebhook(req, res)
+
+    expect(status).toBe(200)
+    const createThreadCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads' && init?.method === 'POST'
+    )
+    expect(JSON.parse(String(createThreadCall?.[2]?.body ?? '{}'))).toMatchObject({
+      approvalPolicy: 'untrusted',
+      sandboxMode: 'read-only'
+    })
+    const turnCall = runtimeRequest.mock.calls.find(
+      ([, path, init]) => path === '/v1/threads/thr_weixin/turns' && init?.method === 'POST'
+    )
+    expect(JSON.parse(String(turnCall?.[2]?.body ?? '{}'))).toMatchObject({
+      disableUserInput: true,
+      approvalPolicy: 'untrusted',
+      sandboxMode: 'read-only'
+    })
+  })
+
   it('backfills a WeChat conversation when an existing channel thread handles the webhook', async () => {
     const settings = buildSettings()
     settings.claw.im.enabled = true
diff --git a/src/main/claw-runtime.ts b/src/main/claw-runtime.ts
index ab0fb3c55..17f14aa10 100644
--- a/src/main/claw-runtime.ts
+++ b/src/main/claw-runtime.ts
@@ -80,8 +80,6 @@ import { FeishuStreamer } from './feishu-streamer'
 import type { TelegramInboundPayload } from './telegram-runtime'
 
 const MAX_IM_FILE_UPLOAD_BYTES = 50 * 1024 * 1024
-const CLAW_IM_APPROVAL_POLICY = 'auto'
-const CLAW_IM_SANDBOX_MODE = 'danger-full-access'
 const CLAW_TELEGRAM_INBOUND_IMAGE_HEADING = '[Telegram inbound message]'
 
 type FeishuClawChannel = ClawImChannelV1 & {
@@ -573,8 +571,8 @@ export class ClawRuntime {
     const createThread = async (): Promise<ThreadRecordJson | null> => {
       const body: Record<string, unknown> = { workspace, model, mode: options.mode }
       if (options.source === 'im') {
-        body.approvalPolicy = CLAW_IM_APPROVAL_POLICY
-        body.sandboxMode = CLAW_IM_SANDBOX_MODE
+        body.approvalPolicy = runtimeSettings.agents.kun.approvalPolicy
+        body.sandboxMode = runtimeSettings.agents.kun.sandboxMode
       }
       const create = await this.deps.runtimeRequest(runtimeSettings, '/v1/threads', {
         method: 'POST',
@@ -604,10 +602,12 @@ export class ClawRuntime {
     if (model) turnBody.model = model
     // IM senders can only reply in their chat app; they cannot answer
     // GUI prompts, so the runtime must not expose user-input tools.
+    // Permission fields are pure passthrough from the agent settings so
+    // IM turns follow the same policy the user picked for the GUI.
     if (options.source === 'im') {
       turnBody.disableUserInput = true
-      turnBody.approvalPolicy = CLAW_IM_APPROVAL_POLICY
-      turnBody.sandboxMode = CLAW_IM_SANDBOX_MODE
+      turnBody.approvalPolicy = runtimeSettings.agents.kun.approvalPolicy
+      turnBody.sandboxMode = runtimeSettings.agents.kun.sandboxMode
     }
     let turn = await this.startRuntimeTurn(runtimeSettings, thread.id, turnBody)
     if (!turn.ok && existingThreadId && isMissingThreadResult(turn)) {
diff --git a/src/main/claw-schedule-mcp-config.test.ts b/src/main/claw-schedule-mcp-config.test.ts
index 3b140faa1..d66c35698 100644
--- a/src/main/claw-schedule-mcp-config.test.ts
+++ b/src/main/claw-schedule-mcp-config.test.ts
@@ -33,7 +33,7 @@ function createSettings(patch: Partial<AppSettingsV1['schedule']['internal']> =
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: defaultKunRuntimeSettings()
@@ -43,6 +43,7 @@ function createSettings(patch: Partial<AppSettingsV1['schedule']['internal']> =
       enabled: true,
       retentionDays: 2
     },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: {
       turnComplete: true
     },
diff --git a/src/main/claw-scheduled-task-detector.test.ts b/src/main/claw-scheduled-task-detector.test.ts
index 84ab28634..762234dfa 100644
--- a/src/main/claw-scheduled-task-detector.test.ts
+++ b/src/main/claw-scheduled-task-detector.test.ts
@@ -27,13 +27,14 @@ function settings(endpointFormat: ModelEndpointFormat): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider,
     agents: {
       kun: defaultKunRuntimeSettings()
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/index.ts b/src/main/index.ts
index 6eaf5187d..75def014e 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -31,6 +31,7 @@ import {
   MIN_KUN_LOCAL_PORT,
   normalizeAppSettings,
   normalizeAppBehaviorSettings,
+  normalizeCheckpointCleanupSettings,
   normalizeKeyboardShortcuts,
   resolveKunRuntimeSettings,
   resolveTerminalColorMode,
@@ -52,9 +53,15 @@ import {
   runtimeRequestViaHost
 } from './runtime/kun-adapter'
 import { waitForRuntimeTurnsIdle } from './runtime/managed-runtime-idle'
-import { setKunUnexpectedExitHandler, type KunUnexpectedExitInfo } from './kun-process'
+import {
+  resolveKunDataDir,
+  setKunUnexpectedExitHandler,
+  waitForKunStartupSettled,
+  type KunUnexpectedExitInfo
+} from './kun-process'
 import { RestartBudget, type KunRuntimeStatus } from './kun-runtime-supervisor'
 import { configureLogger, logError, logWarn, pruneOnStartup } from './logger'
+import { cleanupUnusedGitCheckpointsIfDue } from './services/git-checkpoint-service'
 import { createClawRuntime, type ClawRuntime } from './claw-runtime'
 import { createScheduleRuntime, type ScheduleRuntime } from './schedule-runtime'
 import { createWorkflowRuntime, type WorkflowRuntime } from './workflow-runtime'
@@ -216,6 +223,7 @@ let trayMenu: Menu | null = null
 let trayMenuOpenPromise: Promise<void> | null = null
 let isQuitting = false
 let closeWindowPromptOpen = false
+let checkpointCleanupTimer: ReturnType<typeof setInterval> | null = null
 
 type GuiUpdaterModule = typeof import('./gui-updater')
 
@@ -227,6 +235,50 @@ function emitClawChannelActivity(payload: { channelId: string; threadId: string
   mainWindow.webContents.send('claw:channel-activity', payload)
 }
 
+function stopCheckpointCleanupTimer(): void {
+  if (checkpointCleanupTimer) {
+    clearInterval(checkpointCleanupTimer)
+    checkpointCleanupTimer = null
+  }
+}
+
+async function runCheckpointCleanupIfDue(settings: AppSettingsV1): Promise<void> {
+  if (!settings.checkpointCleanup.enabled) return
+  const runtime = resolveKunRuntimeSettings(settings)
+  const dataDir = resolveKunDataDir(runtime)
+  const intervalDays = settings.checkpointCleanup.intervalDays
+  try {
+    const cleanup = await cleanupUnusedGitCheckpointsIfDue({ dataDir, intervalDays })
+    if (!cleanup.due) return
+    const { result } = cleanup
+    console.info(
+      `[kun-gui] git checkpoint cleanup scanned=${result.scanned} deleted=${result.deleted} kept=${result.kept} failed=${result.failed}`
+    )
+    if (result.failed > 0) {
+      logWarn('git-checkpoint-cleanup', 'failed to delete some unused checkpoints', {
+        failed: result.failed,
+        failedIds: result.failedIds
+      })
+    }
+  } catch (error) {
+    logWarn('git-checkpoint-cleanup', 'failed to clean unused checkpoints', {
+      message: error instanceof Error ? error.message : String(error)
+    })
+  }
+}
+
+function syncCheckpointCleanupTimer(settings: AppSettingsV1): void {
+  stopCheckpointCleanupTimer()
+  if (!settings.checkpointCleanup.enabled) return
+  const intervalMs = settings.checkpointCleanup.intervalDays * 24 * 60 * 60 * 1_000
+  const run = (): void => {
+    void runCheckpointCleanupIfDue(settings)
+  }
+  run()
+  checkpointCleanupTimer = setInterval(run, intervalMs)
+  checkpointCleanupTimer.unref?.()
+}
+
 async function stopManagedRuntimesForQuit(): Promise<void> {
   if (managedRuntimesStoppedForQuit) return
   await stopManagedRuntimes()
@@ -632,6 +684,7 @@ async function probeThreadApi(settings: AppSettingsV1): Promise<
 async function waitForKunHealth(settings: AppSettingsV1, timeoutMs: number): Promise<boolean> {
   const base = getRuntimeBaseUrlForSettings(settings)
   const deadline = Date.now() + timeoutMs
+  let lastError = ''
 
   while (Date.now() <= deadline) {
     try {
@@ -641,12 +694,18 @@ async function waitForKunHealth(settings: AppSettingsV1, timeoutMs: number): Pro
         signal: AbortSignal.timeout(Math.max(250, Math.min(1_000, remaining)))
       })
       if (res.ok && isKunHealthResponseBody(await res.text())) return true
-    } catch {
-      /* retry until the deadline */
+      lastError = `unexpected status ${res.status}`
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      if (msg !== lastError) {
+        lastError = msg
+        logWarn('health-probe', `${base}/health: ${msg}`)
+      }
     }
     await sleep(150)
   }
 
+  logWarn('health-probe', `gave up after ${timeoutMs}ms, last error: ${lastError}`)
   return false
 }
 
@@ -1042,6 +1101,10 @@ async function restartRuntime(settings: AppSettingsV1): Promise<void> {
 
 async function restartRuntimeOnce(settings: AppSettingsV1): Promise<void> {
   await waitForQueuedRuntimeSettingsApply()
+  // Don't tear down a child that is still completing its startup; wait for it
+  // to settle so a restart trigger that races a boot doesn't reset the clock
+  // (#544). Resolves immediately when nothing is launching.
+  await waitForKunStartupSettled()
   const runtime = getKunRuntimeSettings(settings)
 
   if (!resolveConfiguredApiKey(settings)) {
@@ -1218,6 +1281,13 @@ async function restartManagedRuntimeForSettingsChange(
 ): Promise<void> {
   if (!runtimeStartupConfigChanged(prev, next)) return
 
+  // Let any in-flight boot launch finish (or fail) before we read liveness
+  // and stop the child. Killing a kun that is still inside its startup window
+  // throws away the boot's progress and restarts the clock — the #544 restart
+  // storm. Once it settles, the child is either healthy (graceful restart
+  // below) or already gone (`wasRunning` is false and we return).
+  await waitForKunStartupSettled()
+
   const runtime = resolveKunRuntimeSettings(next)
   const adapter = kunRuntimeAdapter
   const wasRunning = adapter.isChildRunning()
@@ -1328,6 +1398,10 @@ async function rollbackRuntimeSettingsAfterFailedApply(
 }
 
 async function restartManagedRuntimeForMcpConfigChange(settings: AppSettingsV1): Promise<void> {
+  // See restartManagedRuntimeForSettingsChange: never interrupt an in-flight
+  // boot launch (#544 restart storm).
+  await waitForKunStartupSettled()
+
   const runtime = resolveKunRuntimeSettings(settings)
   const adapter = kunRuntimeAdapter
   const wasRunning = adapter.isChildRunning()
@@ -1431,6 +1505,7 @@ app.whenReady().then(async () => {
     retentionDays: initial.log.retentionDays
   })
   traceStartup('logger configured')
+  syncCheckpointCleanupTimer(initial)
   scheduleRuntime = createScheduleRuntime({ store, runtimeRequest, logError, powerSaveBlocker })
   scheduleRuntime.sync(initial)
   workflowRuntime = createWorkflowRuntime({ store, runtimeRequest, logError, powerSaveBlocker })
@@ -1480,6 +1555,10 @@ app.whenReady().then(async () => {
       ...restPatch,
       provider: mergeModelProviderSettings(prev.provider, providerPatch),
       log: { ...prev.log, ...(partial.log ?? {}) },
+      checkpointCleanup: normalizeCheckpointCleanupSettings({
+        ...prev.checkpointCleanup,
+        ...(partial.checkpointCleanup ?? {})
+      }),
       notifications: { ...prev.notifications, ...(partial.notifications ?? {}) },
       appBehavior: mergeAppBehaviorSettings(prev.appBehavior, partial.appBehavior),
       keyboardShortcuts: normalizeKeyboardShortcuts({
@@ -1522,6 +1601,7 @@ app.whenReady().then(async () => {
     syncWeixinBridgeRuntime(saved)
     syncLoginItemSettings(saved)
     syncTray(saved)
+    syncCheckpointCleanupTimer(saved)
     return saved
   }
 
@@ -1630,6 +1710,7 @@ app.on('window-all-closed', () => {
 app.on('before-quit', (event) => {
   isQuitting = true
   stopRuntimeWatchdog()
+  stopCheckpointCleanupTimer()
   if (managedRuntimesStoppedForQuit) return
   event.preventDefault()
   void stopManagedRuntimesForQuit()
diff --git a/src/main/ipc/app-ipc-schemas.ts b/src/main/ipc/app-ipc-schemas.ts
index 54902d853..0eedada96 100644
--- a/src/main/ipc/app-ipc-schemas.ts
+++ b/src/main/ipc/app-ipc-schemas.ts
@@ -46,7 +46,7 @@ import {
 } from '../../shared/app-settings'
 import { DESKTOP_COMMANDS } from '../../shared/kun-gui-api'
 import { GUI_UPDATE_CHANNELS } from '../../shared/gui-update'
-import { WINDOW_CLOSE_ACTIONS } from '../../shared/app-settings'
+import { WINDOW_CLOSE_ACTIONS, UI_FONT_SCALE_MIN, UI_FONT_SCALE_MAX } from '../../shared/app-settings'
 import { KEYBOARD_SHORTCUT_COMMANDS } from '../../shared/keyboard-shortcuts'
 import { WRITE_EXPORT_FORMATS } from '../../shared/write-export'
 import { WRITE_INFOGRAPHIC_MAX_TEXT_CHARS } from '../../shared/write-infographic'
@@ -207,7 +207,10 @@ export const runtimeRequestPayloadSchema = z
 
 const localeSchema = z.enum(['en', 'zh'])
 const themeSchema = z.enum(['system', 'light', 'dark'])
-const uiFontScaleSchema = z.enum(['small', 'medium', 'large'])
+const uiFontScaleSchema = z.union([
+  z.number().min(UI_FONT_SCALE_MIN).max(UI_FONT_SCALE_MAX),
+  z.enum(['small', 'medium', 'large'])
+])
 const hexColorSchema = z.string().trim().regex(/^#[0-9a-fA-F]{6}$/)
 const approvalPolicySchema = z.enum(['always', 'on-request', 'untrusted', 'never', 'auto', 'suggest'])
 const sandboxModeSchema = z.enum(['read-only', 'workspace-write', 'danger-full-access', 'external-sandbox'])
@@ -321,6 +324,42 @@ const modelProviderPatchSchema = z.object({
   }).strict()).max(50).optional()
 }).strict()
 
+// Subagent profile patch. `.passthrough()` so a field the GUI adds later is
+// preserved through the strict parent instead of being dropped (which would
+// silently lose a configured model/reasoning on round-trip).
+const subagentProfilePatchSchema = z
+  .object({
+    id: z.string().min(1).max(128),
+    enabled: z.boolean(),
+    name: z.string().max(200),
+    description: z.string().max(2000).optional(),
+    color: z.string().max(32).optional(),
+    mode: z.enum(['subagent', 'primary', 'all']),
+    model: z.string().max(256).optional(),
+    providerId: z.string().trim().max(64).optional(),
+    systemPrompt: z.string().max(MAX_BODY_BYTES).optional(),
+    promptPreamble: z.string().max(MAX_BODY_BYTES).optional(),
+    toolPolicy: z.enum(['readOnly', 'inherit']),
+    allowedTools: z.array(z.string().max(128)).max(200).optional(),
+    blockedTools: z.array(z.string().max(128)).max(200).optional(),
+    blockedMcpServers: z.array(z.string().max(128)).max(200).optional(),
+    blockedSkills: z.array(z.string().max(128)).max(200).optional(),
+    reasoningEffort: modelReasoningEffortSchema.optional(),
+    builtin: z.boolean().optional()
+  })
+  .passthrough()
+
+const subagentsPatchSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    maxParallel: z.number().int().nonnegative().max(64).optional(),
+    maxChildRuns: z.number().int().nonnegative().max(10_000).optional(),
+    defaultToolPolicy: z.enum(['readOnly', 'inherit']).optional(),
+    defaultProfile: z.string().max(128).optional(),
+    profiles: z.array(subagentProfilePatchSchema).max(200).optional()
+  })
+  .passthrough()
+
 const kunRuntimePatchSchema = z.object({
   binaryPath: defaultPathSchema,
   port: z.number().int().min(MIN_KUN_LOCAL_PORT).max(65_535).optional(),
@@ -368,7 +407,9 @@ const kunRuntimePatchSchema = z.object({
     summaryMode: kunCompactionSummaryModeSchema.optional(),
     summaryTimeoutMs: z.number().int().positive().max(120_000).optional(),
     summaryMaxTokens: z.number().int().positive().max(16_000).optional(),
-    summaryInputMaxBytes: z.number().int().positive().max(8 * 1024 * 1024).optional()
+    summaryInputMaxBytes: z.number().int().positive().max(8 * 1024 * 1024).optional(),
+    summaryModel: optionalModelIdSchema,
+    summaryProviderId: z.string().trim().max(64).optional()
   }).strict().optional(),
   runtimeTuning: z.object({
     streamIdleTimeoutMs: z.number().int().min(0).max(3_600_000).optional(),
@@ -454,7 +495,22 @@ const kunRuntimePatchSchema = z.object({
     modelIdSchema,
     modelProfilePatchSchema.nullable()
   ).optional(),
-  memoryEnabled: z.boolean().optional()
+  memoryEnabled: z.boolean().optional(),
+  // Global small-model slot + per-role internal-LLM model overrides (agents.kun.*).
+  // Title & Summary default to smallModel, then the main conversation model.
+  smallModel: optionalModelIdSchema,
+  smallModelProviderId: z.string().trim().max(64).optional(),
+  titleModel: optionalModelIdSchema,
+  titleProviderId: z.string().trim().max(64).optional(),
+  summaryModel: optionalModelIdSchema,
+  summaryProviderId: z.string().trim().max(64).optional(),
+  codeReviewModel: optionalModelIdSchema,
+  codeReviewProviderId: z.string().trim().max(64).optional(),
+  // Per-role reasoning depth. Default 'off' is omitted by the normalizer.
+  titleReasoningEffort: modelReasoningEffortSchema.optional(),
+  summaryReasoningEffort: modelReasoningEffortSchema.optional(),
+  codeReviewReasoningEffort: modelReasoningEffortSchema.optional(),
+  subagents: subagentsPatchSchema.optional()
 }).strict()
 
 const logPatchSchema = z.object({
@@ -462,6 +518,17 @@ const logPatchSchema = z.object({
   retentionDays: z.number().int().min(1).max(365).optional()
 }).strict()
 
+const checkpointCleanupPatchSchema = z.object({
+  enabled: z.boolean().optional(),
+  intervalDays: z.union([
+    z.literal(1),
+    z.literal(2),
+    z.literal(3),
+    z.literal(5),
+    z.literal(10)
+  ]).optional()
+}).strict()
+
 const notificationsPatchSchema = z.object({
   turnComplete: z.boolean().optional()
 }).strict()
@@ -1286,6 +1353,7 @@ const settingsPatchObjectSchema = z.object({
   }).strict().optional(),
   workspaceRoot: defaultPathSchema,
   log: logPatchSchema.optional(),
+  checkpointCleanup: checkpointCleanupPatchSchema.optional(),
   notifications: notificationsPatchSchema.optional(),
   appBehavior: appBehaviorPatchSchema.optional(),
   keyboardShortcuts: keyboardShortcutsPatchSchema.optional(),
@@ -1338,6 +1406,11 @@ export const skillListPayloadSchema = z
   .strict()
 
 export const rootPathSchema = trimmedString(MAX_PATH_LENGTH)
+export const localPdfTextTargetPayloadSchema = z
+  .object({
+    path: rootPathSchema
+  })
+  .strict()
 export const deepseekConfigContentSchema = z.string().max(MAX_CONFIG_FILE_BYTES)
 
 export const workspaceRootSchema = trimmedString(MAX_PATH_LENGTH)
diff --git a/src/main/ipc/register-app-ipc-handlers.test.ts b/src/main/ipc/register-app-ipc-handlers.test.ts
index b424df67d..26c611160 100644
--- a/src/main/ipc/register-app-ipc-handlers.test.ts
+++ b/src/main/ipc/register-app-ipc-handlers.test.ts
@@ -36,13 +36,14 @@ function settings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: defaultKunRuntimeSettings()
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
@@ -124,6 +125,35 @@ describe('registerAppIpcHandlers', () => {
     expect(applySettingsPatch).toHaveBeenCalledWith(payload)
   })
 
+  it('accepts checkpoint cleanup settings patches', async () => {
+    const { registerAppIpcHandlers } = await import('./register-app-ipc-handlers')
+    const applySettingsPatch = vi.fn(async () => settings())
+
+    registerAppIpcHandlers(registerOptions({ applySettingsPatch }))
+
+    const payload = {
+      checkpointCleanup: {
+        intervalDays: 5
+      }
+    }
+    const handler = handlers.get('settings:set')
+    await expect(handler?.({}, payload)).resolves.toEqual(settings())
+    expect(applySettingsPatch).toHaveBeenCalledWith(payload)
+  })
+
+  it('rejects unsupported checkpoint cleanup intervals', async () => {
+    const { registerAppIpcHandlers } = await import('./register-app-ipc-handlers')
+    const applySettingsPatch = vi.fn(async () => settings())
+
+    registerAppIpcHandlers(registerOptions({ applySettingsPatch }))
+
+    const handler = handlers.get('settings:set')
+    await expect(
+      handler?.({}, { checkpointCleanup: { intervalDays: 4 } })
+    ).rejects.toThrow(/Invalid payload for settings:set/)
+    expect(applySettingsPatch).not.toHaveBeenCalled()
+  })
+
   it('accepts telegram phone connection settings patches', async () => {
     const { registerAppIpcHandlers } = await import('./register-app-ipc-handlers')
     const applySettingsPatch = vi.fn(async () => settings())
diff --git a/src/main/ipc/register-app-ipc-handlers.ts b/src/main/ipc/register-app-ipc-handlers.ts
index 8d76d1e3c..fe02baf8f 100644
--- a/src/main/ipc/register-app-ipc-handlers.ts
+++ b/src/main/ipc/register-app-ipc-handlers.ts
@@ -46,6 +46,7 @@ import {
   gitCheckpointRestorePayloadSchema,
   gitWorktreeRemoveSchema,
   guiUpdateChannelSchema,
+  localPdfTextTargetPayloadSchema,
   logErrorPayloadSchema,
   notificationPayloadSchema,
   openEditorPathPayloadSchema,
@@ -178,6 +179,7 @@ import {
 } from '../services/computer-use-permissions'
 import { copyWriteDocumentAsRichText, exportWriteDocument } from '../services/write-export-service'
 import { importGithubSkillsToRoot } from '../services/github-skill-import-service'
+import { readLocalPdfText } from '../services/write-pdf-text-service'
 import { saveGuiSkillPackage } from '../services/skill-save-service'
 import { listGuiSkillRoots, listGuiSkills } from '../services/skill-service'
 
@@ -958,7 +960,18 @@ export function registerAppIpcHandlers(options: RegisterAppIpcHandlersOptions):
     const request = parseIpcPayload('git:checkpoint:restore', gitCheckpointRestorePayloadSchema, payload)
     return restoreGitCheckpoint({
       dataDir: await resolveKunThreadsDataDir(),
-      checkpointId: request.checkpointId
+      checkpointId: request.checkpointId,
+      // Bridge the main-process runtimeRequest into the shape restoreGitCheckpoint
+      // expects ((path, {method, body}) => {ok,status,body}). On a transport-level
+      // failure (runtime not up, connection refused) we return a non-ok result so
+      // the busy guard fails closed instead of throwing past the handler.
+      runtimeRequest: async (path, init) => {
+        try {
+          return await runtimeRequest(path, init?.method, init?.body)
+        } catch (error) {
+          return { ok: false, status: 0, body: error instanceof Error ? error.message : String(error) }
+        }
+      }
     })
   })
   ipcMain.handle(
@@ -1087,6 +1100,22 @@ export function registerAppIpcHandlers(options: RegisterAppIpcHandlersOptions):
       parseIpcPayload('file:read-workspace-pdf', workspaceFileTargetPayloadSchema, payload)
     )
   )
+  ipcMain.handle('file:read-local-pdf-text', async (_, payload: unknown) => {
+    const result = await readLocalPdfText(
+      parseIpcPayload('file:read-local-pdf-text', localPdfTextTargetPayloadSchema, payload)
+    )
+    if (!result.ok) return result
+    return {
+      ok: true,
+      path: result.path,
+      size: result.size,
+      mtimeMs: result.mtimeMs,
+      pageCount: result.pageCount,
+      text: result.pages.map((page) => page.text).join('\n\n'),
+      hasText: result.hasText,
+      truncated: result.truncated
+    }
+  })
   ipcMain.handle('file:save-as', async (_, payload: unknown) =>
     saveWorkspaceFileAs(payload, getMainWindow)
   )
diff --git a/src/main/kun-process.test.ts b/src/main/kun-process.test.ts
index a7677ac18..cc21f0c4f 100644
--- a/src/main/kun-process.test.ts
+++ b/src/main/kun-process.test.ts
@@ -33,7 +33,7 @@ function createSettings(binaryPath: string): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: {
@@ -44,6 +44,7 @@ function createSettings(binaryPath: string): AppSettingsV1 {
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
@@ -113,9 +114,17 @@ describe('startKunChild', () => {
     const script = writeScript(
       'ready-child.js',
       [
-        "setTimeout(() => {",
-        "  process.stdout.write('KUN_READY ' + JSON.stringify({ service: 'kun', mode: 'serve', port: 18899 }) + '\\n')",
-        "}, 50)",
+        "const http = require('node:http')",
+        "const port = 18899",
+        "const server = http.createServer((req, res) => {",
+        "  res.setHeader('content-type', 'application/json')",
+        "  res.end(JSON.stringify({ service: 'kun', mode: 'serve', status: 'ok' }))",
+        "})",
+        "server.listen(port, '127.0.0.1', () => {",
+        "  setTimeout(() => {",
+        "    process.stdout.write('KUN_READY ' + JSON.stringify({ service: 'kun', mode: 'serve', port }) + '\\n')",
+        "  }, 50)",
+        "})",
         "setInterval(() => {}, 1_000)"
       ].join('\n')
     )
@@ -128,19 +137,76 @@ describe('startKunChild', () => {
     expect(logText).toContain('ready marker received on port 18899')
   })
 
+  it('does not settle on the ready marker until the /health endpoint responds', async () => {
+    if (!tempRoot) throw new Error('temp root not initialized')
+    const healthSignalPath = join(tempRoot, 'allow-health')
+    const script = writeScript(
+      'marker-without-health-child.js',
+      [
+        "const http = require('node:http')",
+        "const { existsSync } = require('node:fs')",
+        `const healthSignalPath = ${JSON.stringify(healthSignalPath)}`,
+        "const port = 18899",
+        // Emit the ready marker right away but serve no /health yet: the
+        // marker alone must NOT be enough to settle the launch.
+        "process.stdout.write('KUN_READY ' + JSON.stringify({ service: 'kun', mode: 'serve', port }) + '\\n')",
+        'let served = false',
+        'setInterval(() => {',
+        '  if (served || !existsSync(healthSignalPath)) return',
+        '  served = true',
+        "  const server = http.createServer((req, res) => {",
+        "    res.setHeader('content-type', 'application/json')",
+        "    res.end(JSON.stringify({ service: 'kun', mode: 'serve', status: 'ok' }))",
+        "  })",
+        "  server.listen(port, '127.0.0.1')",
+        '}, 10)',
+        'setInterval(() => {}, 1_000)'
+      ].join('\n')
+    )
+    const module = await import('./kun-process')
+    let resolved = false
+    const start = module.startKunChild(createSettings(script)).then(() => {
+      resolved = true
+    })
+
+    // The marker has been emitted but /health is not up yet. The child is
+    // spawned and alive, yet the launch must stay PENDING for the whole
+    // window (the startup timeout is far larger, so it cannot mask this).
+    await new Promise((resolve) => setTimeout(resolve, 300))
+    expect(resolved).toBe(false)
+
+    // Bring /health online; the parallel probe now settles the launch.
+    writeFileSync(healthSignalPath, 'ok', 'utf8')
+    await start
+    expect(resolved).toBe(true)
+    expect(module.isKunChildRunning()).toBe(true)
+
+    await module.stopKunChildAndWait()
+  })
+
   it('shares the startup promise while Kun is spawned but not ready', async () => {
     if (!tempRoot) throw new Error('temp root not initialized')
     const readySignalPath = join(tempRoot, 'allow-ready')
     const script = writeScript(
       'delayed-ready-child.js',
       [
+        "const http = require('node:http')",
         "const { existsSync } = require('node:fs')",
         `const readySignalPath = ${JSON.stringify(readySignalPath)}`,
+        "const port = 18899",
         'let sentReady = false',
+        // Only stand up the /health server once the signal exists so the
+        // parallel health probe cannot settle the launch before then.
         'setInterval(() => {',
         '  if (sentReady || !existsSync(readySignalPath)) return',
         '  sentReady = true',
-        "  process.stdout.write('KUN_READY ' + JSON.stringify({ service: 'kun', mode: 'serve', port: 18899 }) + '\\n')",
+        "  const server = http.createServer((req, res) => {",
+        "    res.setHeader('content-type', 'application/json')",
+        "    res.end(JSON.stringify({ service: 'kun', mode: 'serve', status: 'ok' }))",
+        "  })",
+        "  server.listen(port, '127.0.0.1', () => {",
+        "    process.stdout.write('KUN_READY ' + JSON.stringify({ service: 'kun', mode: 'serve', port }) + '\\n')",
+        "  })",
         '}, 10)',
         'setInterval(() => {}, 1_000)'
       ].join('\n')
@@ -188,6 +254,99 @@ describe('startKunChild', () => {
   })
 })
 
+describe('resolveKunStartupTimeoutMs', () => {
+  it('gives Windows the larger default and other platforms a smaller one', async () => {
+    const { resolveKunStartupTimeoutMs } = await import('./kun-process')
+    expect(resolveKunStartupTimeoutMs('win32', {})).toBe(90_000)
+    expect(resolveKunStartupTimeoutMs('darwin', {})).toBe(60_000)
+    expect(resolveKunStartupTimeoutMs('linux', {})).toBe(60_000)
+  })
+
+  it('honors a valid KUN_STARTUP_TIMEOUT_MS override on every platform', async () => {
+    const { resolveKunStartupTimeoutMs } = await import('./kun-process')
+    expect(resolveKunStartupTimeoutMs('win32', { KUN_STARTUP_TIMEOUT_MS: '120000' })).toBe(120_000)
+    expect(resolveKunStartupTimeoutMs('linux', { KUN_STARTUP_TIMEOUT_MS: ' 30000 ' })).toBe(30_000)
+  })
+
+  it('clamps an out-of-range override to the 15s–10min bounds', async () => {
+    const { resolveKunStartupTimeoutMs } = await import('./kun-process')
+    expect(resolveKunStartupTimeoutMs('linux', { KUN_STARTUP_TIMEOUT_MS: '1000' })).toBe(15_000)
+    expect(resolveKunStartupTimeoutMs('linux', { KUN_STARTUP_TIMEOUT_MS: '99999999' })).toBe(600_000)
+  })
+
+  it('falls back to the platform default when the override is not a finite number', async () => {
+    const { resolveKunStartupTimeoutMs } = await import('./kun-process')
+    expect(resolveKunStartupTimeoutMs('win32', { KUN_STARTUP_TIMEOUT_MS: 'soon' })).toBe(90_000)
+    expect(resolveKunStartupTimeoutMs('darwin', { KUN_STARTUP_TIMEOUT_MS: '' })).toBe(60_000)
+    expect(resolveKunStartupTimeoutMs('darwin', { KUN_STARTUP_TIMEOUT_MS: '   ' })).toBe(60_000)
+  })
+})
+
+describe('waitForKunStartupSettled', () => {
+  it('resolves immediately when no launch is in flight', async () => {
+    const module = await import('./kun-process')
+    let resolved = false
+    await Promise.race([
+      module.waitForKunStartupSettled().then(() => {
+        resolved = true
+      }),
+      new Promise((resolve) => setTimeout(resolve, 50))
+    ])
+    expect(resolved).toBe(true)
+  })
+
+  it('does not resolve until an in-flight launch settles', async () => {
+    if (!tempRoot) throw new Error('temp root not initialized')
+    const readySignalPath = join(tempRoot, 'allow-ready-settled')
+    const script = writeScript(
+      'settled-delayed-child.js',
+      [
+        "const http = require('node:http')",
+        "const { existsSync } = require('node:fs')",
+        `const readySignalPath = ${JSON.stringify(readySignalPath)}`,
+        "const port = 18899",
+        'let sentReady = false',
+        // Only stand up the /health server once the signal exists so the
+        // parallel health probe cannot settle the launch before then.
+        'setInterval(() => {',
+        '  if (sentReady || !existsSync(readySignalPath)) return',
+        '  sentReady = true',
+        "  const server = http.createServer((req, res) => {",
+        "    res.setHeader('content-type', 'application/json')",
+        "    res.end(JSON.stringify({ service: 'kun', mode: 'serve', status: 'ok' }))",
+        "  })",
+        "  server.listen(port, '127.0.0.1', () => {",
+        "    process.stdout.write('KUN_READY ' + JSON.stringify({ service: 'kun', mode: 'serve', port }) + '\\n')",
+        "  })",
+        '}, 10)',
+        'setInterval(() => {}, 1_000)'
+      ].join('\n')
+    )
+    const module = await import('./kun-process')
+    const settings = createSettings(script)
+    const start = module.startKunChild(settings)
+
+    for (let attempt = 0; attempt < 100 && !module.isKunChildRunning(); attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 10))
+    }
+    expect(module.isKunChildRunning()).toBe(true)
+
+    let settled = false
+    const settledPromise = module.waitForKunStartupSettled().then(() => {
+      settled = true
+    })
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    expect(settled).toBe(false)
+
+    writeFileSync(readySignalPath, 'ready', 'utf8')
+    await start
+    await settledPromise
+    expect(settled).toBe(true)
+
+    await module.stopKunChildAndWait()
+  })
+})
+
 describe('reclaimKunPort', () => {
   it('reports a port as unavailable when another listener owns it', async () => {
     const server = createServer()
@@ -384,6 +543,10 @@ describe('syncGuiManagedKunConfig', () => {
     expect(parsed.runtime.toolArgumentRepair).toMatchObject({ maxStringBytes: 524288 })
     expect(parsed.capabilities.attachments).toMatchObject({ enabled: true })
     expect(parsed.capabilities.memory).toMatchObject({ enabled: false })
+    // Subagents have no GUI enable toggle: they default ON so delegate_task + the
+    // built-in profiles are always offered. maxParallel/maxChildRuns must be >=1 or
+    // DelegationRuntime can never run a child. This locks the default against regressions.
+    expect(parsed.capabilities.subagents).toMatchObject({ enabled: true, maxParallel: 3, maxChildRuns: 12 })
     expect(parsed.capabilities.web).toMatchObject({ enabled: true, fetchEnabled: true })
     expect(parsed.capabilities.mcp.search).toMatchObject({ enabled: false, mode: 'auto' })
     expect(parsed.capabilities.imageGen).toEqual({
@@ -683,6 +846,43 @@ describe('syncGuiManagedKunConfig', () => {
     ]))
   })
 
+  it('drops stale Codex plugin cache roots but keeps hand-added manual roots', async () => {
+    if (!tempRoot) throw new Error('temp root not initialized')
+    const configPath = join(tempRoot, 'config.json')
+    // A version directory left behind by a plugin upgrade and a root a user
+    // added by hand to the Kun config file.
+    const staleRoot = join(homedir(), '.codex', 'plugins', 'cache', 'gmail', '0.0.0-stale', 'skills')
+    const manualRoot = join(tempRoot, 'manual', 'skills')
+    writeFileSync(configPath, JSON.stringify({
+      capabilities: { skills: { enabled: true, roots: [staleRoot, manualRoot], legacySkillMd: true } }
+    }), 'utf8')
+    const module = await import('./kun-process')
+
+    await module.syncGuiManagedKunConfig(tempRoot, defaultKunRuntimeSettings())
+
+    const parsed = JSON.parse(readFileSync(configPath, 'utf8')) as any
+    expect(parsed.capabilities.skills.roots).not.toContain(staleRoot)
+    expect(parsed.capabilities.skills.roots).toContain(manualRoot)
+  })
+
+  it('forwards GUI disabledSkillIds into the runtime skills capability', async () => {
+    if (!tempRoot) throw new Error('temp root not initialized')
+    const configPath = join(tempRoot, 'config.json')
+    const module = await import('./kun-process')
+    const settings = createSettings('/tmp/fake-kun-child.js')
+    settings.disabledSkillIds = ['gmail', 'vercel-agent']
+
+    await module.syncGuiManagedKunConfig(tempRoot, defaultKunRuntimeSettings(), {
+      scheduleMcp: {
+        settings,
+        launch: { appPath: '/tmp/deepseek-gui-test-app', execPath: '/tmp/electron', isPackaged: false }
+      }
+    })
+
+    const parsed = JSON.parse(readFileSync(configPath, 'utf8')) as any
+    expect(parsed.capabilities.skills.disabledIds).toEqual(['gmail', 'vercel-agent'])
+  })
+
   it('writes GUI-managed MCP search settings without removing existing servers', async () => {
     if (!tempRoot) throw new Error('temp root not initialized')
     const configPath = join(tempRoot, 'config.json')
@@ -875,6 +1075,7 @@ describe('syncGuiManagedKunConfig', () => {
       servers: {
         'stata-mcp': {
           command: 'uvx',
+          cwd: 'D:\\Workspace\\stata-project',
           args: ['stata-mcp'],
           env: {
             STATA_CLI: 'D:\\stata\\StataMP-64.exe'
@@ -902,6 +1103,7 @@ describe('syncGuiManagedKunConfig', () => {
       enabled: true,
       transport: 'stdio',
       command: 'uvx',
+      cwd: 'D:\\Workspace\\stata-project',
       args: ['stata-mcp'],
       env: {
         STATA_CLI: 'D:\\stata\\StataMP-64.exe'
@@ -1021,3 +1223,43 @@ describe('syncGuiManagedKunConfig', () => {
     })
   })
 })
+
+describe('subagentProfilesForRuntime', () => {
+  it('drops blank optional fields so the runtime config still parses', async () => {
+    const module = await import('./kun-process')
+    // Built-in profiles store an empty `name` (the GUI localizes the label) and
+    // the user picked a model on one of them. The runtime schema marks every
+    // optional string `.min(1)`, so a forwarded empty string used to throw and
+    // strand the runtime at "无法连接到本地运行时".
+    const config = module.subagentProfilesForRuntime({
+      enabled: true,
+      profiles: [
+        {
+          id: 'general',
+          enabled: true,
+          name: '',
+          mode: 'subagent',
+          toolPolicy: 'inherit',
+          model: 'deepseek-v4',
+          description: '   '
+        }
+      ]
+    })
+
+    expect(config.profiles.general).toBeDefined()
+    expect('name' in config.profiles.general).toBe(false)
+    expect('description' in config.profiles.general).toBe(false)
+    expect(config.profiles.general.model).toBe('deepseek-v4')
+  })
+
+  it('keeps a non-empty name', async () => {
+    const module = await import('./kun-process')
+    const config = module.subagentProfilesForRuntime({
+      enabled: true,
+      profiles: [
+        { id: 'custom', enabled: true, name: '我的代理', mode: 'subagent', toolPolicy: 'inherit' }
+      ]
+    })
+    expect(config.profiles.custom.name).toBe('我的代理')
+  })
+})
diff --git a/src/main/kun-process.ts b/src/main/kun-process.ts
index b5f66718e..4ea134b00 100644
--- a/src/main/kun-process.ts
+++ b/src/main/kun-process.ts
@@ -16,6 +16,7 @@ import {
   type ModelProviderModelProfileV1,
   type ModelProviderProfileV1,
   type KunRuntimeSettingsV1,
+  type KunSubagentsSettingsV1,
   type AppSettingsV1
 } from '../shared/app-settings'
 import {
@@ -28,7 +29,8 @@ import {
   ModelConfigSchema,
   ContextCompactionConfigSchema,
   QualityConfigSchema,
-  RuntimeTuningConfigSchema
+  RuntimeTuningConfigSchema,
+  RolesConfigSchema
 } from '../../kun/src/config/kun-config.js'
 import { HooksConfigSchema } from '../../kun/src/hooks/hook-config.js'
 import {
@@ -58,7 +60,9 @@ import { appendManagedLogLine } from './logger'
 import {
   comparableSkillRootPath,
   guiSkillManagedComparablePaths,
+  guiSkillWorkspaceRootsForRuntime,
   guiSkillRootsForRuntime,
+  isCodexPluginCacheRoot,
   normalizeSkillRootPath
 } from './services/skill-service'
 
@@ -93,10 +97,45 @@ export function setKunUnexpectedExitHandler(
 
 const execFileAsync = promisify(execFile)
 const KUN_READY_PREFIX = 'KUN_READY '
-// Cold starts on slow disks (Windows + antivirus scans, sqlite rebuilds,
-// MCP server connects) routinely exceed 15s; killing kun that early left
-// fresh installs permanently "unable to connect" (#188).
-const KUN_STARTUP_TIMEOUT_MS = 45_000
+const KUN_STARTUP_TIMEOUT_FLOOR_MS = 15_000
+const KUN_STARTUP_TIMEOUT_CEILING_MS = 600_000
+
+/**
+ * How long to wait for a freshly spawned kun to report ready before giving
+ * up and killing it. kun emits its ready marker only after the HTTP server
+ * is actually listening, which it does only after sqlite opens, the thread
+ * store finishes its backfill, usage carryover replays every thread's
+ * events, and the MCP fast-connect race runs. On a slow disk (Windows +
+ * antivirus scans) with a large history this routinely exceeds 45s, leaving
+ * the runtime stuck in a "did not report ready within 45000ms" → SIGTERM →
+ * respawn loop (#188, #544).
+ *
+ * A generous ceiling is free on fast machines: the parallel /health probe
+ * in waitForKunStartup settles the moment the server responds, and a process
+ * that actually crashes rejects immediately via its exit event rather than
+ * waiting out the timeout. Only a slow-but-progressing boot uses the extra
+ * runway. Windows gets the larger default; everything is overridable via the
+ * KUN_STARTUP_TIMEOUT_MS env var (milliseconds, clamped to 15s–10min) for
+ * extreme cases without a rebuild.
+ */
+export function resolveKunStartupTimeoutMs(
+  platform: NodeJS.Platform,
+  env: NodeJS.ProcessEnv
+): number {
+  const raw = env.KUN_STARTUP_TIMEOUT_MS
+  if (raw && raw.trim()) {
+    const parsed = Number(raw)
+    if (Number.isFinite(parsed)) {
+      return Math.min(
+        KUN_STARTUP_TIMEOUT_CEILING_MS,
+        Math.max(KUN_STARTUP_TIMEOUT_FLOOR_MS, Math.floor(parsed))
+      )
+    }
+  }
+  return platform === 'win32' ? 90_000 : 60_000
+}
+
+const KUN_STARTUP_TIMEOUT_MS = resolveKunStartupTimeoutMs(process.platform, process.env)
 const KUN_STARTUP_HEALTH_POLL_MS = 500
 const KUN_STARTUP_HEALTH_REQUEST_TIMEOUT_MS = 1_000
 const KUN_STOP_GRACE_MS = 5_000
@@ -260,6 +299,21 @@ function isCurrentKunChildPid(pid: number): boolean {
   return Boolean(child?.pid === pid && isKunChildRunning())
 }
 
+/**
+ * Resolve once any in-flight kun launch has settled — whether it became
+ * ready or failed. The settings/MCP-apply paths use this to avoid
+ * SIGTERM-ing a child that is still inside its (deliberately generous)
+ * startup window: interrupting a slow-but-healthy boot only restarts the
+ * clock and is what turns one slow start into the #544 restart storm.
+ *
+ * Deadlock-safe by construction: `kunStartPromise` is only set once a launch
+ * has already passed the settings-apply gate, so an apply that awaits it can
+ * never be the thing that launch is itself waiting on.
+ */
+export function waitForKunStartupSettled(): Promise<void> {
+  return kunStartPromise ? kunStartPromise.catch(() => undefined) : Promise.resolve()
+}
+
 export function startKunChild(settings: AppSettingsV1): Promise<void> {
   if (kunStartPromise) return kunStartPromise
   const runtime = resolveKunRuntimeSettings(settings)
@@ -399,6 +453,15 @@ export async function syncGuiManagedKunConfig(
     | 'modelProfiles'
     | 'memoryEnabled'
     | 'quality'
+    | 'subagents'
+    | 'smallModel'
+    | 'smallModelProviderId'
+    | 'titleModel'
+    | 'titleProviderId'
+    | 'summaryModel'
+    | 'summaryProviderId'
+    | 'codeReviewModel'
+    | 'codeReviewProviderId'
   >,
   options?: {
     scheduleMcp?: {
@@ -458,6 +521,10 @@ export async function syncGuiManagedKunConfig(
     contextCompaction: contextCompactionConfigForRuntime(runtime.contextCompaction, existingContextCompaction),
     runtime: runtimeTuningConfigForRuntime(runtime.runtimeTuning, existingRuntimeTuning),
     quality: qualityConfigForRuntime(runtime.quality, existingQuality),
+    ...(() => {
+      const roles = rolesConfigForRuntime(runtime)
+      return Object.keys(roles).length ? { roles } : {}
+    })(),
     capabilities: {
       ...capabilities,
       attachments: {
@@ -479,6 +546,7 @@ export async function syncGuiManagedKunConfig(
         ...memory,
         enabled: runtime.memoryEnabled
       },
+      subagents: subagentProfilesForRuntime(runtime.subagents ?? { enabled: true, profiles: [] }),
       mcp: {
         ...mcp,
         ...(options?.scheduleMcp || mcpSearch.enabled || hasImportedEnabledMcpServer
@@ -546,10 +614,17 @@ async function skillCapabilityConfigForRuntime(
   // Drop previously-persisted GUI-managed roots so disabling a directory in
   // settings actually removes it — otherwise a toggled-off root would stick
   // around forever via `existing.roots`.
+  // GUI-managed roots are dropped from the carried-over set and rebuilt fresh
+  // below. Besides the common/extra candidates, auto-discovered Codex plugin
+  // caches count as managed too — otherwise old version directories from a
+  // plugin upgrade stay in `roots` forever (#392).
   const managed = guiSkillManagedComparablePaths(settings)
   const manualExisting = stringArrayValue(existing.roots)
     .map(normalizeSkillRootPath)
-    .filter((path) => path.length > 0 && !managed.has(comparableSkillRootPath(path)))
+    .filter((path) =>
+      path.length > 0 &&
+      !managed.has(comparableSkillRootPath(path)) &&
+      !isCodexPluginCacheRoot(path))
   const roots = uniqueStrings([
     ...manualExisting,
     ...(await guiSkillRootsForRuntime(settings)).map((root) => root.path)
@@ -562,6 +637,13 @@ async function skillCapabilityConfigForRuntime(
     // skills. An explicit `true` still forces on even with no roots.
     enabled: roots.length > 0 || existing.enabled === true,
     roots,
+    workspaceRoots: guiSkillWorkspaceRootsForRuntime(settings),
+    // #149: Pass global skill roots from settings (e.g. ~/.kun/skills)
+    globalRoots: existing.globalRoots ?? [],
+    // Skills the user disabled in the GUI. Forwarded so the runtime drops them
+    // from discovery — without this they stay loadable via load_skill and keep
+    // appearing in the catalog despite the GUI toggle (#392).
+    disabledIds: settings?.disabledSkillIds ?? stringArrayValue(existing.disabledIds),
     legacySkillMd: existing.legacySkillMd === false ? false : true
   }
 }
@@ -610,6 +692,7 @@ function mcpServersFromGuiConfig(config: Record<string, unknown>): Record<string
 function normalizeGuiManagedMcpServer(server: unknown): Record<string, unknown> | null {
   const raw = objectValue(server)
   const command = scalarStringValue(raw.command)
+  const cwd = scalarStringValue(raw.cwd)?.trim()
   const url = scalarStringValue(raw.url)
   const args = stringArrayValue(raw.args)
   const headers = stringRecordValue(raw.headers)
@@ -626,6 +709,7 @@ function normalizeGuiManagedMcpServer(server: unknown): Record<string, unknown>
     enabled: raw.enabled === false || raw.disabled === true ? false : true,
     transport,
     ...(command ? { command } : {}),
+    ...(transport === 'stdio' && cwd ? { cwd } : {}),
     ...(args.length > 0 ? { args } : {}),
     ...(url ? { url } : {}),
     ...(Object.keys(headers).length > 0 ? { headers } : {}),
@@ -821,8 +905,52 @@ function contextCompactionConfigForRuntime(
     summaryMode: contextCompaction.summaryMode,
     summaryTimeoutMs: contextCompaction.summaryTimeoutMs,
     summaryMaxTokens: contextCompaction.summaryMaxTokens,
-    summaryInputMaxBytes: contextCompaction.summaryInputMaxBytes
+    summaryInputMaxBytes: contextCompaction.summaryInputMaxBytes,
+    ...(contextCompaction.summaryModel ? { summaryModel: contextCompaction.summaryModel } : {}),
+    ...(contextCompaction.summaryProviderId ? { summaryProviderId: contextCompaction.summaryProviderId } : {})
+  }
+}
+
+/**
+ * Build the kun `roles` config (internal-LLM model routing) from GUI settings.
+ * Only non-empty fields are emitted so the strict RolesConfigSchema accepts the
+ * result and a cleared field removes itself from config.json.
+ */
+function rolesConfigForRuntime(
+  runtime: Pick<
+    KunRuntimeSettingsV1,
+    | 'smallModel'
+    | 'smallModelProviderId'
+    | 'titleModel'
+    | 'titleProviderId'
+    | 'summaryModel'
+    | 'summaryProviderId'
+    | 'codeReviewModel'
+    | 'codeReviewProviderId'
+    | 'titleReasoningEffort'
+    | 'summaryReasoningEffort'
+    | 'codeReviewReasoningEffort'
+  >
+): Record<string, string> {
+  const out: Record<string, string> = {}
+  const put = (key: string, value: string | undefined): void => {
+    const trimmed = typeof value === 'string' ? value.trim() : ''
+    if (trimmed) out[key] = trimmed
   }
+  put('smallModel', runtime.smallModel)
+  put('smallModelProviderId', runtime.smallModelProviderId)
+  put('titleModel', runtime.titleModel)
+  put('titleProviderId', runtime.titleProviderId)
+  put('summaryModel', runtime.summaryModel)
+  put('summaryProviderId', runtime.summaryProviderId)
+  put('codeReviewModel', runtime.codeReviewModel)
+  put('codeReviewProviderId', runtime.codeReviewProviderId)
+  // Per-role reasoning depth. 'off' is the default and is intentionally omitted
+  // by the normalizer, so only an opted-in level (low/medium/high/max) is emitted.
+  put('titleReasoningEffort', runtime.titleReasoningEffort)
+  put('summaryReasoningEffort', runtime.summaryReasoningEffort)
+  put('codeReviewReasoningEffort', runtime.codeReviewReasoningEffort)
+  return out
 }
 
 function computerUseConfigForRuntime(
@@ -979,6 +1107,75 @@ function qualityConfigForRuntime(
   }
 }
 
+const VALID_PROFILE_REASONING = new Set(['auto', 'low', 'medium', 'high', 'max'])
+
+/**
+ * Remove optional fields the runtime schema rejects when blank: empty/whitespace
+ * strings (every optional string there is `.min(1)`) and empty arrays. Leaving
+ * them in throws on SubagentsCapabilityConfig.parse and stops the runtime from
+ * starting; dropping them lets the field fall back to its server default.
+ */
+function stripBlankProfileFields(profile: Record<string, unknown>): Record<string, unknown> {
+  const next: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(profile)) {
+    if (typeof value === 'string' && value.trim() === '') continue
+    if (Array.isArray(value) && value.length === 0) continue
+    next[key] = value
+  }
+  return next
+}
+
+export function subagentProfilesForRuntime(subagents: KunSubagentsSettingsV1): SubagentsCapabilityConfig {
+  const profiles: Record<string, unknown> = {}
+  for (const profile of subagents.profiles) {
+    if (!profile.enabled) continue
+    const { id: _id, enabled: _enabled, name, reasoningEffort, ...rest } = profile
+    // Coerce the per-profile reasoning enum so a hand-edited invalid value can't
+    // throw SubagentsCapabilityConfig.parse below ('off'/invalid → omitted).
+    const effort = typeof reasoningEffort === 'string' && VALID_PROFILE_REASONING.has(reasoningEffort)
+      ? { reasoningEffort }
+      : {}
+    // Built-in profiles carry an empty `name` (the GUI localizes their display
+    // labels rather than storing them), and the user can blank any optional
+    // field in the editor. The runtime schema marks every optional string as
+    // `.min(1)`, so forwarding an empty string throws and the runtime never
+    // connects. Drop blank strings / empty arrays so they fall back to defaults.
+    profiles[profile.id] = stripBlankProfileFields({ name, ...rest, ...effort })
+  }
+  const candidate = {
+    // Subagents are a first-class feature with no GUI "enable" toggle; default ON
+    // (only an explicit `false` disables) so delegate_task + the built-in profiles
+    // (design-reviewer / over-engineering-reviewer) are always offered to the model.
+    // maxParallel/maxChildRuns MUST be >=1 or DelegationRuntime can never run a child.
+    enabled: subagents.enabled !== false,
+    maxParallel: subagents.maxParallel && subagents.maxParallel > 0 ? subagents.maxParallel : 3,
+    maxChildRuns: subagents.maxChildRuns && subagents.maxChildRuns > 0 ? subagents.maxChildRuns : 12,
+    ...(subagents.defaultToolPolicy ? { defaultToolPolicy: subagents.defaultToolPolicy } : {}),
+    ...(subagents.defaultProfile ? { defaultProfile: subagents.defaultProfile } : {}),
+    profiles
+  }
+  // A single malformed profile must never brick the whole runtime connection.
+  // If the GUI somehow persisted a value the schema rejects, drop the custom
+  // profiles and fall back to a minimal valid block — the runtime still merges
+  // in the built-in reviewers, so subagents keep working.
+  const parsed = SubagentsCapabilityConfig.safeParse(candidate)
+  if (parsed.success) return parsed.data
+  void appendManagedLogLine(
+    'kun',
+    formatKunLogLine(
+      'lifecycle',
+      undefined,
+      `[settings] dropped invalid subagent profiles: ${JSON.stringify(parsed.error.issues)}`
+    )
+  )
+  return SubagentsCapabilityConfig.parse({
+    enabled: candidate.enabled,
+    maxParallel: candidate.maxParallel,
+    maxChildRuns: candidate.maxChildRuns,
+    ...(subagents.defaultToolPolicy ? { defaultToolPolicy: subagents.defaultToolPolicy } : {})
+  })
+}
+
 async function readJsonObjectIfExists(path: string): Promise<Record<string, unknown> | null> {
   try {
     const text = await readFile(path, 'utf8')
@@ -1067,6 +1264,9 @@ function sanitizeKunConfigSections(
     runtime: parseKunConfigSection(RuntimeTuningConfigSchema, existing.runtime),
     quality: parseKunConfigSection(QualityConfigSchema, existing.quality),
     capabilities: sanitizeKunCapabilitiesConfig(existing.capabilities),
+    ...('roles' in existing
+      ? { roles: parseKunConfigSection(RolesConfigSchema, existing.roles) }
+      : {}),
     ...(hooks.length ? { hooks } : {})
   }
 }
@@ -1370,22 +1570,30 @@ async function waitForKunStartup(startedChild: ChildProcess, port?: number): Pro
     let stdoutBuffer = ''
     let stderrTail = ''
     let healthProbeInFlight = false
+    let healthConfirmed = false
+    let readyMarkerSeen = false
     const timer = setTimeout(() => {
       if (settled) return
       settled = true
       cleanup()
-      reject(new Error(describeKunStartupTimeout(stderrTail)))
+      reject(new Error(describeKunStartupTimeout(stderrTail, readyMarkerSeen && Boolean(port))))
     }, KUN_STARTUP_TIMEOUT_MS)
     // The stdout ready marker can lag behind the actual server (pipe
     // buffering) or get lost in unusual spawn environments; the HTTP
     // health endpoint is the ground truth, so poll it in parallel.
+    // A passing health probe alone is enough to settle (it proves the
+    // server responds). The stdout marker alone is NOT enough — it only
+    // proves the process started, not that the HTTP server can serve.
     const healthTimer = port
       ? setInterval(() => {
           if (settled || healthProbeInFlight) return
           healthProbeInFlight = true
           void probeKunHealth(port)
             .then((healthy) => {
-              if (healthy) settleReady()
+              if (healthy) {
+                healthConfirmed = true
+                settleReady()
+              }
             })
             .finally(() => {
               healthProbeInFlight = false
@@ -1423,7 +1631,11 @@ async function waitForKunStartup(startedChild: ChildProcess, port?: number): Pro
     }
     const onStdout = (chunk: Buffer | string): void => {
       stdoutBuffer = appendTail(stdoutBuffer, String(chunk), STDERR_TAIL_MAX_CHARS * 2)
-      if (tryParseReady()) settleReady()
+      if (!tryParseReady()) return
+      readyMarkerSeen = true
+      if (healthConfirmed || !healthTimer) {
+        settleReady()
+      }
     }
     const onStderr = (chunk: Buffer | string): void => {
       stderrTail = appendTail(stderrTail, String(chunk))
@@ -1458,8 +1670,11 @@ function describeKunExit(
   return `Kun exited during startup${suffix}`
 }
 
-function describeKunStartupTimeout(stderrTail: string): string {
+function describeKunStartupTimeout(stderrTail: string, sawReadyMarker = false): string {
   const suffix = stderrTail.trim() ? `\n${stderrTail.trim()}` : ''
+  if (sawReadyMarker) {
+    return `Kun reported ready but did not pass health checks within ${KUN_STARTUP_TIMEOUT_MS}ms${suffix}`
+  }
   return `Kun did not report ready within ${KUN_STARTUP_TIMEOUT_MS}ms${suffix}`
 }
 
diff --git a/src/main/kun-regression.test.ts b/src/main/kun-regression.test.ts
index 65db123d8..8b6be1207 100644
--- a/src/main/kun-regression.test.ts
+++ b/src/main/kun-regression.test.ts
@@ -112,13 +112,14 @@ describe('Kun single-agent regression', () => {
       version: 1,
       locale: 'en',
       theme: 'system',
-      uiFontScale: 'small',
+      uiFontScale: 0.82,
       provider: defaultModelProviderSettings(),
       agents: {
         kun: defaultKunRuntimeSettings(19000)
       },
       workspaceRoot: '/tmp',
       log: { enabled: true, retentionDays: 7 },
+      checkpointCleanup: { enabled: false, intervalDays: 3 },
       notifications: { turnComplete: true },
       appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
       keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/runtime/kun-adapter.test.ts b/src/main/runtime/kun-adapter.test.ts
index 9b785a2f8..1a0af093f 100644
--- a/src/main/runtime/kun-adapter.test.ts
+++ b/src/main/runtime/kun-adapter.test.ts
@@ -21,7 +21,7 @@ function settingsForPort(port: number): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: {
@@ -31,6 +31,7 @@ function settingsForPort(port: number): AppSettingsV1 {
     },
     workspaceRoot: '/tmp',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/runtime/managed-runtime-idle.test.ts b/src/main/runtime/managed-runtime-idle.test.ts
index b18a51733..d3e19e6a3 100644
--- a/src/main/runtime/managed-runtime-idle.test.ts
+++ b/src/main/runtime/managed-runtime-idle.test.ts
@@ -20,11 +20,12 @@ const settings: AppSettingsV1 = {
   version: 1,
   locale: 'en',
   theme: 'system',
-  uiFontScale: 'small',
+  uiFontScale: 0.82,
   provider: defaultModelProviderSettings(),
   agents: { kun: defaultKunRuntimeSettings() },
   workspaceRoot: '/tmp/workspace',
   log: { enabled: false, retentionDays: 7 },
+  checkpointCleanup: { enabled: false, intervalDays: 3 },
   notifications: { turnComplete: true },
   appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
   keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/schedule-runtime.test.ts b/src/main/schedule-runtime.test.ts
index 98c8b1d40..7213fd944 100644
--- a/src/main/schedule-runtime.test.ts
+++ b/src/main/schedule-runtime.test.ts
@@ -83,7 +83,7 @@ function settingsWith(
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: {
@@ -93,6 +93,7 @@ function settingsWith(
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/services/git-checkpoint-service.test.ts b/src/main/services/git-checkpoint-service.test.ts
index 77af61d70..8d60eec95 100644
--- a/src/main/services/git-checkpoint-service.test.ts
+++ b/src/main/services/git-checkpoint-service.test.ts
@@ -1,9 +1,15 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { execFileSync } from 'node:child_process'
-import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { mkdtemp, mkdir, readFile, rm, stat, symlink, utimes, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { createGitCheckpoint, restoreGitCheckpoint } from './git-checkpoint-service'
+import { join, normalize } from 'node:path'
+import {
+  cleanupUnusedGitCheckpoints,
+  cleanupUnusedGitCheckpointsIfDue,
+  createGitCheckpoint,
+  restoreGitCheckpoint,
+  testResolvePathWithinRepository
+} from './git-checkpoint-service'
 
 let sandbox = ''
 let repoRoot = ''
@@ -153,4 +159,261 @@ describe('git checkpoint service', () => {
     const refs = execFileSync('git', ['-C', repoRoot, 'show-ref'], { encoding: 'utf-8' })
     expect(refs).not.toContain('refs/kun/checkpoints')
   })
+
+  it('refuses to restore when a tampered checkpoint smuggles a path-traversal untracked entry', async () => {
+    // Build a legitimate checkpoint, then rewrite its metadata.json so an
+    // untracked entry escapes the repository root (`../escape.txt`). The restore
+    // must reject the traversal rather than copying the file outside the repo.
+    const checkpoint = await createGitCheckpoint({
+      dataDir,
+      workspaceRoot: repoRoot,
+      threadId: 'thr_traversal'
+    })
+    expect(checkpoint.ok).toBe(true)
+    if (!checkpoint.ok) throw new Error(checkpoint.message)
+
+    const checkpointDir = join(dataDir, 'git-checkpoints', checkpoint.checkpointId)
+    const metadataPath = join(checkpointDir, 'metadata.json')
+    const metadata = JSON.parse(await readFile(metadataPath, 'utf-8')) as {
+      untrackedFiles: string[]
+      [key: string]: unknown
+    }
+    metadata.untrackedFiles = ['../escape.txt']
+    await writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8')
+
+    // Plant a payload at the smuggled source location inside the checkpoint
+    // untracked dir so the existence check would succeed without the guard.
+    const smuggledSource = join(checkpointDir, 'untracked', '..', 'escape.txt')
+    await writeFile(smuggledSource, 'escaped payload\n')
+
+    // The destination the traversal would write to, OUTSIDE the repo.
+    const escapeTarget = join(repoRoot, '..', 'escape.txt')
+
+    const restored = await restoreGitCheckpoint({
+      dataDir,
+      checkpointId: checkpoint.checkpointId
+    })
+    expect(restored.ok).toBe(false)
+    if (restored.ok) throw new Error('expected restore to be refused')
+    expect(restored.reason).toBe('error')
+    expect(restored.message).toMatch(/escapes the repository root/)
+
+    // Nothing must have been written outside the repository.
+    await expect(stat(escapeTarget)).rejects.toThrow()
+  })
+
+  it('refuses to restore when a tampered checkpoint smuggles an absolute untracked path', async () => {
+    const checkpoint = await createGitCheckpoint({
+      dataDir,
+      workspaceRoot: repoRoot,
+      threadId: 'thr_absolute'
+    })
+    expect(checkpoint.ok).toBe(true)
+    if (!checkpoint.ok) throw new Error(checkpoint.message)
+
+    const checkpointDir = join(dataDir, 'git-checkpoints', checkpoint.checkpointId)
+    const metadataPath = join(checkpointDir, 'metadata.json')
+    const metadata = JSON.parse(await readFile(metadataPath, 'utf-8')) as {
+      untrackedFiles: string[]
+      [key: string]: unknown
+    }
+    metadata.untrackedFiles = ['/tmp/escape-absolute.txt']
+    await writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8')
+
+    const restored = await restoreGitCheckpoint({
+      dataDir,
+      checkpointId: checkpoint.checkpointId
+    })
+    expect(restored.ok).toBe(false)
+    if (restored.ok) throw new Error('expected restore to be refused')
+    expect(restored.reason).toBe('error')
+    expect(restored.message).toMatch(/invalid untracked path|escapes the repository root/)
+  })
+
+  it('resolvePathWithinRepository rejects a path that escapes via an in-repo symlink', async () => {
+    // An in-repo symlink `repo/link -> /outside` makes the relative path
+    // `link/payload.txt` lexically contained (target startsWith repo+sep), but
+    // cp() would follow the link and write OUTSIDE the repo. The helper must
+    // resolve the target's real path (walking up to the existing symlink dir)
+    // and reject the escape. This is the regression for the symlink-anchored
+    // traversal that a lexical-only check misses.
+    const outsideDir = join(sandbox, 'outside')
+    await mkdir(outsideDir, { recursive: true })
+    await symlink(outsideDir, join(repoRoot, 'link'), 'dir')
+
+    await expect(
+      testResolvePathWithinRepository(repoRoot, 'link/payload.txt')
+    ).rejects.toThrow(/escapes the repository root/)
+    // And nothing should have been created outside the repo.
+    await expect(stat(join(outsideDir, 'payload.txt'))).rejects.toThrow()
+  })
+
+  it('resolvePathWithinRepository accepts a legitimate path inside the repo', async () => {
+    const { realpath } = await import('node:fs/promises')
+    await mkdir(join(repoRoot, 'sub'), { recursive: true })
+    // The helper anchors against the realpath'd root (macOS /var -> /private/var),
+    // so compare against the canonical root, not the lexical repoRoot.
+    const repoReal = await realpath(repoRoot)
+    await expect(
+      testResolvePathWithinRepository(repoRoot, 'sub/file.txt')
+    ).resolves.toBe(normalize(join(repoReal, 'sub', 'file.txt')))
+  })
+
+  it('resolvePathWithinRepository rejects traversal, absolute, and null-byte paths', async () => {
+    await expect(testResolvePathWithinRepository(repoRoot, '../escape.txt')).rejects.toThrow()
+    await expect(testResolvePathWithinRepository(repoRoot, '/tmp/escape.txt')).rejects.toThrow()
+    await expect(testResolvePathWithinRepository(repoRoot, 'evil\0.txt')).rejects.toThrow()
+    await expect(testResolvePathWithinRepository(repoRoot, '.')).rejects.toThrow()
+    await expect(testResolvePathWithinRepository(repoRoot, '..')).rejects.toThrow()
+  })
+
+  it('refuses to restore while a thread is running and leaves the working tree untouched', async () => {
+    const checkpoint = await createGitCheckpoint({
+      dataDir,
+      workspaceRoot: repoRoot,
+      threadId: 'thr_busy'
+    })
+    expect(checkpoint.ok).toBe(true)
+    if (!checkpoint.ok) throw new Error(checkpoint.message)
+
+    // Mutate the working tree after the checkpoint so we can assert the restore
+    // did NOT clobber it. If the busy guard fails open, these changes vanish.
+    await writeFile(join(repoRoot, 'tracked.txt'), 'agent editing\n')
+    await writeFile(join(repoRoot, 'post-checkpoint.txt'), 'should survive\n')
+    const headBefore = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf-8' }).trim()
+
+    const runtimeRequest = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      // ThreadSummary exposes `status` (idle|running|archived|deleted), NOT
+      // `state`. A running thread must be reported as status === 'running'.
+      body: JSON.stringify({ threads: [{ id: 'thr_running', status: 'running' }] })
+    }))
+
+    const restored = await restoreGitCheckpoint({
+      dataDir,
+      checkpointId: checkpoint.checkpointId,
+      runtimeRequest
+    })
+
+    expect(restored.ok).toBe(false)
+    if (restored.ok) throw new Error('expected restore to be refused')
+    expect(restored.reason).toBe('error')
+    expect(restored.message).toMatch(/Cannot restore checkpoint while a thread is running/)
+
+    // The busy guard must fire BEFORE any destructive git op, so the runtime
+    // probe is the only call made and the working tree is byte-for-byte intact.
+    expect(runtimeRequest).toHaveBeenCalledTimes(1)
+    expect(await readFile(join(repoRoot, 'tracked.txt'), 'utf-8')).toBe('agent editing\n')
+    expect(await readFile(join(repoRoot, 'post-checkpoint.txt'), 'utf-8')).toBe('should survive\n')
+    expect(execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf-8' }).trim()).toBe(headBefore)
+  })
+
+  it('restores when the runtime reports all threads idle (runtimeRequest exercised)', async () => {
+    const checkpoint = await createGitCheckpoint({
+      dataDir,
+      workspaceRoot: repoRoot,
+      threadId: 'thr_idle'
+    })
+    expect(checkpoint.ok).toBe(true)
+    if (!checkpoint.ok) throw new Error(checkpoint.message)
+
+    await writeFile(join(repoRoot, 'tracked.txt'), 'changed after checkpoint\n')
+    await writeFile(join(repoRoot, 'new-after.txt'), 'new\n')
+
+    const runtimeRequest = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      body: JSON.stringify({ threads: [{ id: 'thr_a', status: 'idle' }, { id: 'thr_b', status: 'archived' }] })
+    }))
+
+    const restored = await restoreGitCheckpoint({
+      dataDir,
+      checkpointId: checkpoint.checkpointId,
+      runtimeRequest
+    })
+    expect(restored.ok).toBe(true)
+    if (!restored.ok) throw new Error(restored.message)
+    // The guard ran and let the restore proceed.
+    expect(runtimeRequest).toHaveBeenCalledTimes(1)
+    // Restore rewound the tracked file to its checkpoint content and removed the
+    // post-checkpoint untracked file (git clean -fd).
+    expect(await readFile(join(repoRoot, 'tracked.txt'), 'utf-8')).toBe('base\n')
+    await expect(stat(join(repoRoot, 'new-after.txt'))).rejects.toThrow()
+  })
+
+  it('deletes checkpoint directories that are not referenced by thread data', async () => {
+    const used = 'gcp_used'
+    const unused = 'gcp_unused'
+    await mkdir(join(dataDir, 'git-checkpoints', used), { recursive: true })
+    await mkdir(join(dataDir, 'git-checkpoints', unused), { recursive: true })
+    await mkdir(join(dataDir, 'threads', 'thr_1'), { recursive: true })
+    await writeFile(
+      join(dataDir, 'threads', 'thr_1', 'items.jsonl'),
+      `${JSON.stringify({ id: 'item_1', workspaceCheckpointId: used })}\n`,
+      'utf-8'
+    )
+
+    const result = await cleanupUnusedGitCheckpoints({ dataDir, graceMs: 0 })
+
+    expect(result.scanned).toBe(2)
+    expect(result.kept).toBe(1)
+    expect(result.deleted).toBe(1)
+    expect(result.deletedIds).toEqual([unused])
+    await expect(stat(join(dataDir, 'git-checkpoints', used))).resolves.toBeTruthy()
+    await expect(stat(join(dataDir, 'git-checkpoints', unused))).rejects.toThrow()
+  })
+
+  it('keeps recently created checkpoints (create-vs-flush grace) and deletes old ones', async () => {
+    const fresh = 'gcp_fresh'
+    const stale = 'gcp_stale'
+    await mkdir(join(dataDir, 'git-checkpoints', fresh), { recursive: true })
+    await mkdir(join(dataDir, 'git-checkpoints', stale), { recursive: true })
+    // Backdate the stale checkpoint beyond the grace window; the fresh one keeps
+    // its just-now mtime and must not be deleted (its referencing item may not
+    // be flushed yet).
+    const old = new Date('2020-01-01T00:00:00.000Z')
+    await utimes(join(dataDir, 'git-checkpoints', stale), old, old)
+
+    const result = await cleanupUnusedGitCheckpoints({ dataDir, graceMs: 10 * 60 * 1000 })
+
+    expect(result.deletedIds).toEqual([stale])
+    expect(result.kept).toBe(1)
+    await expect(stat(join(dataDir, 'git-checkpoints', fresh))).resolves.toBeTruthy()
+    await expect(stat(join(dataDir, 'git-checkpoints', stale))).rejects.toThrow()
+  })
+
+  it('records cleanup state and skips runs before the configured interval elapses', async () => {
+    await mkdir(join(dataDir, 'git-checkpoints', 'gcp_first'), { recursive: true })
+
+    const first = await cleanupUnusedGitCheckpointsIfDue({
+      dataDir,
+      intervalDays: 3,
+      graceMs: 0,
+      now: new Date('2026-01-01T00:00:00.000Z')
+    })
+    expect(first.due).toBe(true)
+    if (!first.due) throw new Error('expected cleanup to run')
+    expect(first.result.deletedIds).toEqual(['gcp_first'])
+
+    await mkdir(join(dataDir, 'git-checkpoints', 'gcp_second'), { recursive: true })
+    const skipped = await cleanupUnusedGitCheckpointsIfDue({
+      dataDir,
+      intervalDays: 3,
+      graceMs: 0,
+      now: new Date('2026-01-03T23:59:59.000Z')
+    })
+    expect(skipped.due).toBe(false)
+    await expect(stat(join(dataDir, 'git-checkpoints', 'gcp_second'))).resolves.toBeTruthy()
+
+    const second = await cleanupUnusedGitCheckpointsIfDue({
+      dataDir,
+      intervalDays: 3,
+      graceMs: 0,
+      now: new Date('2026-01-04T00:00:00.000Z')
+    })
+    expect(second.due).toBe(true)
+    if (!second.due) throw new Error('expected cleanup to run after interval')
+    expect(second.result.deletedIds).toEqual(['gcp_second'])
+  })
 })
diff --git a/src/main/services/git-checkpoint-service.ts b/src/main/services/git-checkpoint-service.ts
index c96700501..562681eaa 100644
--- a/src/main/services/git-checkpoint-service.ts
+++ b/src/main/services/git-checkpoint-service.ts
@@ -1,5 +1,6 @@
-import { cp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
+import { cp, mkdir, readFile, readdir, realpath, rm, stat, writeFile } from 'node:fs/promises'
+import type { Dirent } from 'node:fs'
+import { dirname, basename, extname, isAbsolute, join, normalize, resolve, sep } from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { runGit, resolveGitCwd } from './git-service'
 import type {
@@ -18,6 +19,27 @@ type GitCheckpointMetadata = {
   untrackedFiles: string[]
 }
 
+export type GitCheckpointCleanupResult = {
+  scanned: number
+  kept: number
+  deleted: number
+  failed: number
+  deletedIds: string[]
+  failedIds: string[]
+}
+
+export type GitCheckpointCleanupDueResult =
+  | { due: false, lastRunAt: string | null }
+  | { due: true, lastRunAt: string, result: GitCheckpointCleanupResult }
+
+type GitCheckpointCleanupState = {
+  lastRunAt?: string
+}
+
+const DAY_MS = 24 * 60 * 60 * 1_000
+const CHECKPOINT_CLEANUP_STATE_FILE = '.cleanup.json'
+const CHECKPOINT_REFERENCE_FILE_EXTENSIONS = new Set(['.json', '.jsonl'])
+
 function checkpointFailure(error: unknown): Extract<GitCheckpointCreateResult, { ok: false }> {
   const message = error instanceof Error ? error.message : String(error)
   if (/not a git repository/i.test(message)) {
@@ -38,6 +60,14 @@ function checkpointDir(dataDir: string, checkpointId: string): string {
   return join(resolve(dataDir), 'git-checkpoints', checkpointId)
 }
 
+function checkpointRootDir(dataDir: string): string {
+  return join(resolve(dataDir), 'git-checkpoints')
+}
+
+function checkpointCleanupStatePath(dataDir: string): string {
+  return join(checkpointRootDir(dataDir), CHECKPOINT_CLEANUP_STATE_FILE)
+}
+
 function checkpointHeadBundlePath(dataDir: string, checkpointId: string): string {
   return join(checkpointDir(dataDir, checkpointId), 'head.bundle')
 }
@@ -128,6 +158,286 @@ async function resolveRepositoryRoot(workspaceRoot: string): Promise<string | nu
   return stdout.trim()
 }
 
+/**
+ * Validates that `relativePath` (taken from checkpoint metadata, which is
+ * persisted JSON and therefore untrusted) stays inside `repositoryRoot` when
+ * joined to it. Defends the restore path against a tampered metadata.json that
+ * smuggles `..` segments, absolute paths, or symlink-anchored escapes.
+ *
+ * Returns the canonical absolute target so callers reuse the same resolved
+ * path for both the existence check and the copy, avoiding a second resolution
+ * that could disagree with the validated one.
+ *
+ * Fail closed: if `repositoryRoot` cannot be canonicalized (missing, EACCES,
+ * ELOOP, …) the check throws rather than letting an unchecked path through.
+ */
+async function resolvePathWithinRepository(
+  repositoryRoot: string,
+  relativePath: string
+): Promise<string> {
+  // Reject empty / current / parent / absolute, plus null bytes and Windows
+  // drive-relative forms ("C:file") that bypass isAbsolute().
+  if (!relativePath || relativePath === '.' || relativePath === '..' || isAbsolute(relativePath)) {
+    throw new Error(`invalid untracked path: ${relativePath}`)
+  }
+  if (relativePath.includes('\0') || /^[a-zA-Z]:/.test(relativePath)) {
+    throw new Error(`invalid untracked path: ${relativePath}`)
+  }
+
+  const repoReal = await realpath(repositoryRoot)
+  const targetNormalized = normalize(join(repoReal, relativePath))
+  // startsWith with a trailing separator prevents prefix attacks where
+  // repoReal is a textual prefix of an unrelated dir (e.g. "/repo" vs
+  // "/repo-evil"). Exact equality covers the (already-rejected) root case.
+  if (targetNormalized !== repoReal && !targetNormalized.startsWith(repoReal + sep)) {
+    throw new Error(`untracked path escapes the repository root: ${relativePath}`)
+  }
+
+  // The lexical check above is necessary but NOT sufficient: an in-repo
+  // symlink (e.g. repo/link -> /outside) makes `link/payload.txt` lexically
+  // contained while cp() follows the link and writes outside the repo. Resolve
+  // the target via realpath to defeat any symlink on the path. The target may
+  // not exist yet (cp creates it), so when the direct realpath fails with
+  // ENOENT we canonicalize the nearest existing ancestor (the parent dir) and
+  // re-join the remaining suffix, then re-assert containment on the resolved
+  // pair. Any other realpath failure (EACCES/ELOOP/ENOTDIR/…) fails closed.
+  const targetReal = await resolveSymlinkSafe(targetNormalized)
+  if (targetReal !== repoReal && !targetReal.startsWith(repoReal + sep)) {
+    throw new Error(`untracked path escapes the repository root: ${relativePath}`)
+  }
+
+  // Return the lexical target so downstream mkdir/cp operate on the path the
+  // caller asked for; the escape check above already proved it cannot leave
+  // the repository root through any symlink on the path.
+  return targetNormalized
+}
+
+/**
+ * Exported for tests. Validates an untracked-file relative path (from
+ * persisted metadata) stays inside `repositoryRoot`, defeating `..`,
+ * absolute, drive-relative, null-byte, AND in-repo-symlink escapes.
+ */
+export async function testResolvePathWithinRepository(
+  repositoryRoot: string,
+  relativePath: string
+): Promise<string> {
+  return resolvePathWithinRepository(repositoryRoot, relativePath)
+}
+
+/**
+ * Canonicalizes `lexicalPath`, tolerating a not-yet-existing leaf (the
+ * write/create case) by realpath-ing the nearest existing ancestor and
+ * re-joining the non-existent suffix. Fail-closed on realpath errors other
+ * than ENOENT. Mirrors the approach used by the workspace tool escape check.
+ */
+async function resolveSymlinkSafe(lexicalPath: string): Promise<string> {
+  const direct = await safeRealpath(lexicalPath)
+  if (direct !== null) return direct
+  const segments: string[] = []
+  let current = lexicalPath
+  let ancestor: string | null = null
+  for (let i = 0; i < 128 && current !== dirname(current); i += 1) {
+    const resolved = await safeRealpath(current)
+    if (resolved !== null) {
+      ancestor = resolved
+      break
+    }
+    segments.unshift(basename(current))
+    current = dirname(current)
+  }
+  if (ancestor === null) {
+    throw new Error(`cannot canonicalize path (no existing ancestor): ${lexicalPath}`)
+  }
+  return segments.length > 0 ? normalize(join(ancestor, ...segments)) : ancestor
+}
+
+async function safeRealpath(target: string): Promise<string | null> {
+  try {
+    return await realpath(target)
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code
+    if (code === 'ENOENT' || code === 'EACCES' || code === 'ELOOP' || code === 'ENOTDIR') {
+      return null
+    }
+    throw error
+  }
+}
+
+/**
+ * Lexical containment check used against an already-realpath'd base (the
+ * checkpoint untracked dir, whose realpath may be a fallback when the dir is
+ * absent). Shares the same rejection rules as {@link resolvePathWithinRepository}
+ * so a traversal path cannot slip through on the source side.
+ */
+function isValidWithinBase(relativePath: string, baseReal: string): boolean {
+  if (!relativePath || relativePath === '.' || relativePath === '..' || isAbsolute(relativePath)) {
+    return false
+  }
+  if (relativePath.includes('\0') || /^[a-zA-Z]:/.test(relativePath)) {
+    return false
+  }
+  const targetNormalized = normalize(join(baseReal, relativePath))
+  return targetNormalized === baseReal || targetNormalized.startsWith(baseReal + sep)
+}
+
+function extractWorkspaceCheckpointIds(text: string): Set<string> {
+  const ids = new Set<string>()
+  const pattern = /"workspaceCheckpointId"\s*:\s*"([^"]+)"/g
+  let match: RegExpExecArray | null = null
+  while ((match = pattern.exec(text)) !== null) {
+    const id = match[1]?.trim()
+    if (id) ids.add(id)
+  }
+  return ids
+}
+
+async function collectReferencedCheckpointIds(dataDir: string): Promise<Set<string>> {
+  const referenced = new Set<string>()
+  const roots = [join(resolve(dataDir), 'threads')]
+  const visit = async (dir: string): Promise<void> => {
+    let entries: Dirent<string>[]
+    try {
+      entries = await readdir(dir, { withFileTypes: true })
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code === 'ENOENT' || code === 'ENOTDIR') return
+      throw error
+    }
+
+    for (const entry of entries) {
+      const path = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        await visit(path)
+        continue
+      }
+      if (!entry.isFile() || !CHECKPOINT_REFERENCE_FILE_EXTENSIONS.has(extname(entry.name))) continue
+      let text = ''
+      try {
+        text = await readFile(path, 'utf-8')
+      } catch {
+        continue
+      }
+      for (const id of extractWorkspaceCheckpointIds(text)) {
+        referenced.add(id)
+      }
+    }
+  }
+
+  for (const root of roots) {
+    await visit(root)
+  }
+  return referenced
+}
+
+async function readCleanupState(dataDir: string): Promise<GitCheckpointCleanupState> {
+  try {
+    const raw = await readFile(checkpointCleanupStatePath(dataDir), 'utf-8')
+    const parsed = JSON.parse(raw) as GitCheckpointCleanupState
+    return typeof parsed === 'object' && parsed !== null ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+async function writeCleanupState(dataDir: string, state: GitCheckpointCleanupState): Promise<void> {
+  const root = checkpointRootDir(dataDir)
+  await mkdir(root, { recursive: true })
+  await writeFile(checkpointCleanupStatePath(dataDir), JSON.stringify(state, null, 2), 'utf-8')
+}
+
+function isCheckpointCleanupDue(lastRunAt: string | undefined, intervalDays: number, now: Date): boolean {
+  if (!lastRunAt) return true
+  const lastRunMs = Date.parse(lastRunAt)
+  if (!Number.isFinite(lastRunMs)) return true
+  return now.getTime() - lastRunMs >= intervalDays * DAY_MS
+}
+
+// A checkpoint directory is created before its referencing thread item is
+// flushed to disk, so a freshly-created checkpoint can momentarily look
+// unreferenced. Skip directories modified within this window so a cleanup pass
+// landing in that gap can't delete a checkpoint a concurrent turn just created;
+// a genuinely orphaned one is removed on a later pass. Injectable so tests can
+// disable it with graceMs: 0.
+const CHECKPOINT_CLEANUP_GRACE_MS = 10 * 60 * 1_000
+
+export async function cleanupUnusedGitCheckpoints(params: {
+  dataDir: string
+  graceMs?: number
+  now?: Date
+}): Promise<GitCheckpointCleanupResult> {
+  const graceMs = params.graceMs ?? CHECKPOINT_CLEANUP_GRACE_MS
+  const nowMs = (params.now ?? new Date()).getTime()
+  const root = checkpointRootDir(params.dataDir)
+  const referenced = await collectReferencedCheckpointIds(params.dataDir)
+  const result: GitCheckpointCleanupResult = {
+    scanned: 0,
+    kept: 0,
+    deleted: 0,
+    failed: 0,
+    deletedIds: [],
+    failedIds: []
+  }
+
+  let entries: Dirent<string>[]
+  try {
+    entries = await readdir(root, { withFileTypes: true })
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code
+    if (code === 'ENOENT' || code === 'ENOTDIR') return result
+    throw error
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const checkpointId = entry.name
+    result.scanned += 1
+    if (referenced.has(checkpointId)) {
+      result.kept += 1
+      continue
+    }
+    if (graceMs > 0) {
+      try {
+        const dirStat = await stat(join(root, checkpointId))
+        if (nowMs - dirStat.mtimeMs < graceMs) {
+          // Recently touched — may be referenced by an item not yet flushed.
+          result.kept += 1
+          continue
+        }
+      } catch {
+        // Cannot stat (e.g. removed concurrently); fall through to the delete.
+      }
+    }
+    try {
+      await rm(join(root, checkpointId), { recursive: true, force: true })
+      result.deleted += 1
+      result.deletedIds.push(checkpointId)
+    } catch {
+      result.failed += 1
+      result.failedIds.push(checkpointId)
+    }
+  }
+
+  return result
+}
+
+export async function cleanupUnusedGitCheckpointsIfDue(params: {
+  dataDir: string
+  intervalDays: number
+  now?: Date
+  graceMs?: number
+}): Promise<GitCheckpointCleanupDueResult> {
+  const now = params.now ?? new Date()
+  const state = await readCleanupState(params.dataDir)
+  const lastRunAt = typeof state.lastRunAt === 'string' ? state.lastRunAt : undefined
+  if (!isCheckpointCleanupDue(lastRunAt, params.intervalDays, now)) {
+    return { due: false, lastRunAt: lastRunAt ?? null }
+  }
+  const result = await cleanupUnusedGitCheckpoints({ dataDir: params.dataDir, now, graceMs: params.graceMs })
+  const nextLastRunAt = now.toISOString()
+  await writeCleanupState(params.dataDir, { lastRunAt: nextLastRunAt })
+  return { due: true, lastRunAt: nextLastRunAt, result }
+}
+
 export async function createGitCheckpoint(params: {
   dataDir: string
   workspaceRoot: string
@@ -191,6 +501,14 @@ export async function createGitCheckpoint(params: {
 export async function restoreGitCheckpoint(params: {
   dataDir: string
   checkpointId: string
+  /**
+   * Optional runtime bridge used to verify that no thread is mid-turn before
+   * running the destructive `git reset --hard` / `git clean -fd`. When omitted
+   * (e.g. from existing callers and unit tests) the check is skipped and the
+   * function behaves as before. When provided, a non-ok response or any thrown
+   * error fails closed: the restore is refused rather than proceeding.
+   */
+  runtimeRequest?: (path: string, init: { method?: string; body?: string }) => Promise<{ ok: boolean; status: number; body: string }>
 }): Promise<GitCheckpointRestoreResult> {
   const checkpointId = params.checkpointId.trim()
   const metadata = await readMetadata(params.dataDir, checkpointId)
@@ -202,6 +520,46 @@ export async function restoreGitCheckpoint(params: {
     await assertNoUnmerged(repositoryRoot)
     const targetRef = await resolveCheckpointTarget(repositoryRoot, params.dataDir, metadata)
 
+    // Busy guard: a checkpoint restore runs `git reset --hard` + `git clean
+    // -fd`, which would destroy files the agent is actively editing. Before
+    // those destructive ops, ask the runtime whether any thread is currently
+    // running a turn. `GET /v1/threads` serializes ThreadSummary, whose only
+    // activity-relevant field is `status` with the enum
+    // `idle | running | archived | deleted`; a thread is busy exactly when its
+    // status is `running`. Fail closed if the runtime cannot be queried.
+    //
+    // (An earlier version of this guard read a non-existent `thread.state`
+    // field and compared it against turn-level states that never appear on a
+    // thread summary; that made the guard a no-op and the race still fired.)
+    if (params.runtimeRequest) {
+      try {
+        const response = await params.runtimeRequest('/v1/threads?limit=500&include=side', { method: 'GET' })
+        if (!response.ok) {
+          return {
+            ok: false,
+            reason: 'error',
+            message: 'Cannot verify runtime state before checkpoint restore. Please ensure the runtime is healthy and try again.'
+          }
+        }
+        const data = JSON.parse(response.body) as { threads?: Array<{ status?: string }> }
+        const hasRunning = data.threads?.some((thread) => thread.status === 'running')
+        if (hasRunning) {
+          return {
+            ok: false,
+            reason: 'error',
+            message: 'Cannot restore checkpoint while a thread is running. Please wait for the current turn to finish.'
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        return {
+          ok: false,
+          reason: 'error',
+          message: `Cannot verify runtime state before checkpoint restore: ${message}`
+        }
+      }
+    }
+
     const rescue = await createGitCheckpoint({
       dataDir: params.dataDir,
       workspaceRoot: repositoryRoot,
@@ -223,12 +581,33 @@ export async function restoreGitCheckpoint(params: {
     await applyPatchIfPresent(repositoryRoot, join(dir, 'staged.patch'), true)
     await applyPatchIfPresent(repositoryRoot, join(dir, 'unstaged.patch'), false)
 
+    const checkpointUntrackedDir = join(dir, 'untracked')
+    // The untracked dir is created at checkpoint time but may legitimately be
+    // absent on old checkpoints that had no untracked files. realpath() would
+    // throw ENOENT, so canonicalize tolerantly for this non-security-critical
+    // anchor (the per-path escape check below still runs).
+    let checkpointUntrackedReal: string
+    try {
+      checkpointUntrackedReal = await realpath(checkpointUntrackedDir)
+    } catch {
+      checkpointUntrackedReal = normalize(checkpointUntrackedDir)
+    }
+
     for (const relativePath of metadata.untrackedFiles) {
-      const from = join(dir, 'untracked', relativePath)
-      if (!(await fileExists(from))) continue
-      const to = join(repositoryRoot, relativePath)
-      await mkdir(dirname(to), { recursive: true })
-      await cp(from, to, { recursive: true, force: true, errorOnExist: false })
+      // `relativePath` comes from persisted, untrusted metadata. Validate it
+      // stays inside the repository root (rejecting `..`, absolute, drive
+      // forms, null bytes) and inside the checkpoint's untracked dir. Both
+      // checks run through realpath/normalize so symlinks cannot redirect the
+      // copy outside the validated roots.
+      const targetWithinRepo = await resolvePathWithinRepository(repositoryRoot, relativePath)
+      if (!isValidWithinBase(relativePath, checkpointUntrackedReal)) {
+        throw new Error(`untracked path escapes the checkpoint directory: ${relativePath}`)
+      }
+      const sourceWithinCheckpoint = normalize(join(checkpointUntrackedReal, relativePath))
+
+      if (!(await fileExists(sourceWithinCheckpoint))) continue
+      await mkdir(dirname(targetWithinRepo), { recursive: true })
+      await cp(sourceWithinCheckpoint, targetWithinRepo, { recursive: true, force: true, errorOnExist: false })
     }
 
     return {
diff --git a/src/main/services/skill-service.test.ts b/src/main/services/skill-service.test.ts
index d3665acd7..f41dd0072 100644
--- a/src/main/services/skill-service.test.ts
+++ b/src/main/services/skill-service.test.ts
@@ -13,7 +13,12 @@ import {
   defaultTerminalSettings,
   type AppSettingsV1
 } from '../../shared/app-settings'
-import { guiSkillRootsForRuntime, listGuiSkillRoots, listGuiSkills } from './skill-service'
+import {
+  guiSkillRootsForRuntime,
+  isCodexPluginCacheRoot,
+  listGuiSkillRoots,
+  listGuiSkills
+} from './skill-service'
 
 vi.mock('node:os', async (importOriginal) => {
   const actual = await importOriginal<typeof import('node:os')>()
@@ -210,6 +215,29 @@ describe('skill-service', () => {
       .not.toContain(comparable(pluginRoot))
   })
 
+  it('stops scanning Codex plugin caches when global-codex is disabled', async () => {
+    const workspaceRoot = join(tempRoot, 'ws-plugin-global')
+    const pluginRoot = join(tempRoot, '.codex', 'plugins', 'cache', 'gmail', '1.0', 'skills')
+    await mkdir(join(pluginRoot, 'gmail'), { recursive: true })
+    await writeFile(join(pluginRoot, 'gmail', 'SKILL.md'), ['---', 'name: gmail', '---'].join('\n'), 'utf8')
+
+    const settings = createSettings(workspaceRoot)
+    // Plugin caches are on by default...
+    expect((await guiSkillRootsForRuntime(settings, workspaceRoot)).map((root) => comparable(root.path)))
+      .toContain(comparable(pluginRoot))
+
+    // ...and disabling the Codex global root toggle takes them all down with it.
+    settings.claw.skills.disabledDirs = ['global-codex']
+    expect((await guiSkillRootsForRuntime(settings, workspaceRoot)).map((root) => comparable(root.path)))
+      .not.toContain(comparable(pluginRoot))
+  })
+
+  it('recognizes roots under ~/.codex/plugins/cache as Codex plugin caches', () => {
+    expect(isCodexPluginCacheRoot(join(tempRoot, '.codex', 'plugins', 'cache', 'vercel', '2.1', 'skills'))).toBe(true)
+    expect(isCodexPluginCacheRoot(join(tempRoot, '.codex', 'skills'))).toBe(false)
+    expect(isCodexPluginCacheRoot(join(tempRoot, '.kun', 'skills'))).toBe(false)
+  })
+
   it('rejects a skill.json whose entry escapes the package directory (path traversal)', async () => {
     const workspaceRoot = join(tempRoot, 'ws-traversal')
     const skillRoot = join(workspaceRoot, '.claude', 'skills', 'evil')
@@ -261,11 +289,12 @@ describe('skill-service', () => {
       version: 1,
       locale: 'en',
       theme: 'system',
-      uiFontScale: 'small',
+      uiFontScale: 0.82,
       provider: defaultModelProviderSettings(),
       agents: { kun: defaultKunRuntimeSettings() },
       workspaceRoot,
       log: { enabled: false, retentionDays: 7 },
+      checkpointCleanup: { enabled: false, intervalDays: 3 },
       notifications: { turnComplete: true },
       appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
       keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/services/skill-service.ts b/src/main/services/skill-service.ts
index b5275b877..075126d18 100644
--- a/src/main/services/skill-service.ts
+++ b/src/main/services/skill-service.ts
@@ -84,10 +84,17 @@ export async function guiSkillRootsForRuntime(
   const projectCommon = candidates.filter((c) => c.source === 'common' && c.scope === 'project')
   const globalCommon = candidates.filter((c) => c.source === 'common' && c.scope === 'global')
   const extra = candidates.filter((c) => c.source === 'extra')
-  const pluginRoots = (await discoverCodexPluginSkillRoots())
-    .filter((root) => existsSync(root))
-    .filter((root) => !disabled.has(comparablePath(root)))
-    .map((path) => ({ path, scope: 'global' as const }))
+  // Codex plugin caches follow the `global-codex` toggle: disabling the Codex
+  // global root (~/.codex/skills) also stops scanning ~/.codex/plugins/cache/**
+  // (#392). The per-path filter is kept so a hand-added exact plugin path in
+  // `disabledDirs` still works.
+  const codexPluginsDisabled = disabled.has('global-codex')
+  const pluginRoots = codexPluginsDisabled
+    ? []
+    : (await discoverCodexPluginSkillRoots())
+        .filter((root) => existsSync(root))
+        .filter((root) => !disabled.has(comparablePath(root)))
+        .map((path) => ({ path, scope: 'global' as const }))
 
   return uniqueSkillRoots([
     ...projectCommon.map(toGuiSkillRoot),
@@ -97,11 +104,19 @@ export async function guiSkillRootsForRuntime(
   ])
 }
 
+export function guiSkillWorkspaceRootsForRuntime(
+  settings: AppSettingsV1 | undefined,
+  workspaceRootOverride?: string
+): string[] {
+  return collectWorkspaceRoots(settings, workspaceRootOverride)
+}
+
 /**
  * Full list of detected common skill directories + configured extra dirs for
  * the settings UI, including ones the user disabled or that do not exist yet,
- * annotated with skill counts and enabled state. Codex plugin caches are
- * always-on and intentionally excluded from this user-toggleable list.
+ * annotated with skill counts and enabled state. Codex plugin caches are not
+ * listed as a separate row; they follow the `global-codex` toggle (disabling
+ * the Codex global root also stops scanning ~/.codex/plugins/cache/**).
  */
 export async function listGuiSkillRoots(
   settings: AppSettingsV1,
@@ -297,10 +312,26 @@ export function normalizeSkillRootPath(path: string | undefined): string {
 
 async function discoverCodexPluginSkillRoots(): Promise<string[]> {
   const roots: string[] = []
-  await collectSkillRoots(join(homedir(), '.codex', 'plugins', 'cache'), roots, 0, 5)
+  await collectSkillRoots(codexPluginCacheBase(), roots, 0, 5)
   return roots
 }
 
+function codexPluginCacheBase(): string {
+  return join(homedir(), '.codex', 'plugins', 'cache')
+}
+
+/**
+ * Whether a persisted root lives under `~/.codex/plugins/cache/`. The runtime
+ * config builder treats these as GUI-managed (auto-discovered) so stale version
+ * directories left behind by a plugin upgrade are dropped instead of lingering
+ * in `roots` forever and emitting ENOENT validation errors (#392).
+ */
+export function isCodexPluginCacheRoot(path: string): boolean {
+  const comparable = comparablePath(path)
+  const base = comparablePath(codexPluginCacheBase())
+  return comparable === base || comparable.startsWith(`${base}/`)
+}
+
 async function collectSkillRoots(root: string, roots: string[], depth: number, maxDepth: number): Promise<void> {
   if (depth > maxDepth || !existsSync(root)) return
   if (basename(root) === 'skills' && skillRootHasPackages(root)) {
diff --git a/src/main/services/write-inline-completion-service.test.ts b/src/main/services/write-inline-completion-service.test.ts
index 186d3ad1e..453c45f46 100644
--- a/src/main/services/write-inline-completion-service.test.ts
+++ b/src/main/services/write-inline-completion-service.test.ts
@@ -29,7 +29,7 @@ function createSettings(patch: Partial<AppSettingsV1['write']['inlineCompletion'
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: {
@@ -42,6 +42,7 @@ function createSettings(patch: Partial<AppSettingsV1['write']['inlineCompletion'
       enabled: true,
       retentionDays: 2
     },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: {
       turnComplete: true
     },
diff --git a/src/main/services/write-pdf-text-service.test.ts b/src/main/services/write-pdf-text-service.test.ts
index 6ef13f99a..5266fd2f7 100644
--- a/src/main/services/write-pdf-text-service.test.ts
+++ b/src/main/services/write-pdf-text-service.test.ts
@@ -2,7 +2,7 @@ import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
-import { clearWritePdfTextCache, readWritePdfText } from './write-pdf-text-service'
+import { clearWritePdfTextCache, readLocalPdfText, readWritePdfText } from './write-pdf-text-service'
 
 function escapePdfText(text: string): string {
   return text.replaceAll('\\', '\\\\').replaceAll('(', '\\(').replaceAll(')', '\\)')
@@ -63,5 +63,19 @@ describe('write PDF text service', () => {
       charStart: 0
     })
     expect(result.pages[0].text).toContain('PDF BM25 keyword retrieval context')
-  })
+  }, 15_000)
+
+  it('extracts text for local PDF attachments', async () => {
+    const workspaceRoot = await mkdtemp(join(tmpdir(), 'ds-gui-local-pdf-text-'))
+    const pdfPath = join(workspaceRoot, 'fixture.pdf')
+    await writeFile(pdfPath, createSimpleTextPdf('Local PDF attachment text'))
+
+    const result = await readLocalPdfText({ path: pdfPath })
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.pageCount).toBe(1)
+    expect(result.hasText).toBe(true)
+    expect(result.pages[0]?.text).toContain('Local PDF attachment text')
+  }, 15_000)
 })
diff --git a/src/main/services/write-pdf-text-service.ts b/src/main/services/write-pdf-text-service.ts
index e0a172791..b96032494 100644
--- a/src/main/services/write-pdf-text-service.ts
+++ b/src/main/services/write-pdf-text-service.ts
@@ -133,27 +133,18 @@ async function extractPdfText(
 export async function readWritePdfText(payload: WorkspaceFileTarget): Promise<WritePdfTextResult> {
   try {
     const targetPath = await resolveOpenTargetPath(payload.path, payload.workspaceRoot)
-    const fileInfo = await stat(targetPath)
-    if (fileInfo.isDirectory()) return { ok: false, message: 'Cannot read text from a directory.' }
-    if (fileInfo.size > MAX_PDF_TEXT_BYTES) {
-      return { ok: false, message: 'This PDF is too large to parse in Write mode.' }
-    }
-    if (extname(targetPath).toLowerCase() !== '.pdf') {
-      return { ok: false, message: 'This file is not a PDF document.' }
+    return readLocalPdfTextByPath(targetPath, 'This PDF is too large to parse in Write mode.')
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error)
     }
+  }
+}
 
-    const cacheKey = `${targetPath}:${fileInfo.size}:${fileInfo.mtimeMs}`
-    const cached = pdfTextCache.get(cacheKey)
-    if (cached) return cached
-
-    const pending = extractPdfText(targetPath, fileInfo.size, fileInfo.mtimeMs).finally(() => {
-      if (pdfTextCache.size > 32) {
-        const oldest = pdfTextCache.keys().next().value
-        if (oldest) pdfTextCache.delete(oldest)
-      }
-    })
-    pdfTextCache.set(cacheKey, pending)
-    return pending
+export async function readLocalPdfText(payload: { path: string }): Promise<WritePdfTextResult> {
+  try {
+    return readLocalPdfTextByPath(payload.path, 'This PDF is too large to attach.')
   } catch (error) {
     return {
       ok: false,
@@ -162,6 +153,30 @@ export async function readWritePdfText(payload: WorkspaceFileTarget): Promise<Wr
   }
 }
 
+async function readLocalPdfTextByPath(targetPath: string, tooLargeMessage: string): Promise<WritePdfTextResult> {
+  const fileInfo = await stat(targetPath)
+  if (fileInfo.isDirectory()) return { ok: false, message: 'Cannot read text from a directory.' }
+  if (fileInfo.size > MAX_PDF_TEXT_BYTES) {
+    return { ok: false, message: tooLargeMessage }
+  }
+  if (extname(targetPath).toLowerCase() !== '.pdf') {
+    return { ok: false, message: 'This file is not a PDF document.' }
+  }
+
+  const cacheKey = `${targetPath}:${fileInfo.size}:${fileInfo.mtimeMs}`
+  const cached = pdfTextCache.get(cacheKey)
+  if (cached) return cached
+
+  const pending = extractPdfText(targetPath, fileInfo.size, fileInfo.mtimeMs).finally(() => {
+    if (pdfTextCache.size > 32) {
+      const oldest = pdfTextCache.keys().next().value
+      if (oldest) pdfTextCache.delete(oldest)
+    }
+  })
+  pdfTextCache.set(cacheKey, pending)
+  return pending
+}
+
 export function clearWritePdfTextCache(): void {
   pdfTextCache.clear()
 }
diff --git a/src/main/settings-store.test.ts b/src/main/settings-store.test.ts
index e42585148..bda167787 100644
--- a/src/main/settings-store.test.ts
+++ b/src/main/settings-store.test.ts
@@ -2,7 +2,12 @@ import { mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from 'node:fs/
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
-import { DEFAULT_APPROVAL_POLICY, defaultKunRuntimeSettings, defaultModelProviderSettings } from '../shared/app-settings'
+import {
+  DEFAULT_APPROVAL_POLICY,
+  DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS,
+  defaultKunRuntimeSettings,
+  defaultModelProviderSettings
+} from '../shared/app-settings'
 import { DEFAULT_GUI_UPDATE_CHANNEL } from '../shared/gui-update'
 import { JsonSettingsStore } from './settings-store'
 
@@ -15,6 +20,9 @@ describe('JsonSettingsStore', () => {
 
     expect(loaded.guiUpdate.channel).toBe(DEFAULT_GUI_UPDATE_CHANNEL)
     expect(loaded.agents.kun.approvalPolicy).toBe(DEFAULT_APPROVAL_POLICY)
+    expect(loaded.checkpointCleanup.intervalDays).toBe(DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS)
+    // Checkpoint cleanup deletes data, so it must be opt-in (disabled by default).
+    expect(loaded.checkpointCleanup.enabled).toBe(false)
     expect(loaded.appBehavior).toEqual({
       openAtLogin: false,
       startMinimized: false,
@@ -23,6 +31,19 @@ describe('JsonSettingsStore', () => {
     })
   })
 
+  it('patches and normalizes checkpoint cleanup settings', async () => {
+    const userDataDir = await mkdtemp(join(tmpdir(), 'ds-gui-settings-'))
+
+    const store = new JsonSettingsStore(userDataDir)
+    const patched = await store.patch({ checkpointCleanup: { intervalDays: 5 } })
+    expect(patched.checkpointCleanup.intervalDays).toBe(5)
+
+    const clamped = await store.patch({
+      checkpointCleanup: { intervalDays: 99 as unknown as typeof patched.checkpointCleanup.intervalDays }
+    })
+    expect(clamped.checkpointCleanup.intervalDays).toBe(10)
+  })
+
   it('creates a default write workspace with welcome.md', async () => {
     const userDataDir = await mkdtemp(join(tmpdir(), 'ds-gui-settings-'))
 
diff --git a/src/main/settings-store.ts b/src/main/settings-store.ts
index 47bb3c326..f76e292ee 100644
--- a/src/main/settings-store.ts
+++ b/src/main/settings-store.ts
@@ -6,6 +6,8 @@ import {
   applyKunRuntimePatch,
   kunSettingsEnvelope,
   DEFAULT_GUI_UPDATE_CHANNEL,
+  DEFAULT_CHECKPOINT_CLEANUP_ENABLED,
+  DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS,
   DEFAULT_CURSOR_SPOTLIGHT_COLOR,
   DEFAULT_LOG_RETENTION_DAYS,
   DEFAULT_WRITE_WORKSPACE_ROOT,
@@ -25,7 +27,9 @@ import {
   mergeWriteSettings,
   defaultTerminalSettings,
   mergeTerminalSettings,
+  DEFAULT_UI_FONT_SCALE,
   normalizeAppBehaviorSettings,
+  normalizeCheckpointCleanupSettings,
   normalizeKeyboardShortcuts,
   migrateLegacyAppSettings,
   normalizeAppSettings,
@@ -201,7 +205,7 @@ const defaultSettings = (): AppSettingsV1 => ({
   version: 1,
   locale: 'en',
   theme: 'system',
-  uiFontScale: 'small',
+  uiFontScale: DEFAULT_UI_FONT_SCALE,
   cursorSpotlight: true,
   cursorSpotlightColor: DEFAULT_CURSOR_SPOTLIGHT_COLOR,
   provider: defaultModelProviderSettings(),
@@ -213,6 +217,10 @@ const defaultSettings = (): AppSettingsV1 => ({
     enabled: true,
     retentionDays: DEFAULT_LOG_RETENTION_DAYS
   },
+  checkpointCleanup: {
+    enabled: DEFAULT_CHECKPOINT_CLEANUP_ENABLED,
+    intervalDays: DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS
+  },
   notifications: {
     turnComplete: true
   },
@@ -241,6 +249,10 @@ function buildMergedSettings(parsed: Partial<AppSettingsV1>): AppSettingsV1 {
       mergeKunRuntimeSettings(getKunRuntimeSettings(defaults), migrated.agents?.kun)
     ),
     log: { ...defaults.log, ...migrated.log },
+    checkpointCleanup: normalizeCheckpointCleanupSettings({
+      ...defaults.checkpointCleanup,
+      ...migrated.checkpointCleanup
+    }),
     notifications: { ...defaults.notifications, ...migrated.notifications },
     appBehavior: mergeAppBehaviorSettings(defaults.appBehavior, migrated.appBehavior),
     keyboardShortcuts: normalizeKeyboardShortcuts(migrated.keyboardShortcuts),
@@ -426,6 +438,10 @@ export class JsonSettingsStore {
       ...restPatch,
       provider: mergeModelProviderSettings(cur.provider, providerPatch),
       log: { ...cur.log, ...(partial.log ?? {}) },
+      checkpointCleanup: normalizeCheckpointCleanupSettings({
+        ...cur.checkpointCleanup,
+        ...(partial.checkpointCleanup ?? {})
+      }),
       notifications: { ...cur.notifications, ...(partial.notifications ?? {}) },
       appBehavior: mergeAppBehaviorSettings(cur.appBehavior, partial.appBehavior),
       keyboardShortcuts: normalizeKeyboardShortcuts({
diff --git a/src/main/upstream-models.test.ts b/src/main/upstream-models.test.ts
index 05285a1a7..4db175f41 100644
--- a/src/main/upstream-models.test.ts
+++ b/src/main/upstream-models.test.ts
@@ -22,7 +22,7 @@ function settings(dataDir: string, model = 'settings-model'): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: {
       ...provider,
       providers: [
@@ -48,6 +48,7 @@ function settings(dataDir: string, model = 'settings-model'): AppSettingsV1 {
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/workflow-runtime.nodes.test.ts b/src/main/workflow-runtime.nodes.test.ts
index 66503806c..d3db7367e 100644
--- a/src/main/workflow-runtime.nodes.test.ts
+++ b/src/main/workflow-runtime.nodes.test.ts
@@ -105,11 +105,12 @@ function buildSettings(
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: { kun: { ...defaultKunRuntimeSettings(), model: 'test-model', apiKey: 'test-key' } },
     workspaceRoot: '/tmp/workflow-workspace',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/main/workflow-runtime.run.test.ts b/src/main/workflow-runtime.run.test.ts
index 48cb827b8..9b2273c46 100644
--- a/src/main/workflow-runtime.run.test.ts
+++ b/src/main/workflow-runtime.run.test.ts
@@ -46,11 +46,12 @@ function settingsWithWorkflows(workflows: WorkflowV1[], modules: WorkflowCustomM
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: { kun: { ...defaultKunRuntimeSettings(), model: 'test-model', apiKey: 'test-key' } },
     workspaceRoot: '/tmp/workflow-workspace',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/preload/index.ts b/src/preload/index.ts
index e0cf5f235..5c5959760 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -134,6 +134,8 @@ const api = {
     ipcRenderer.invoke('file:read-workspace-image', options),
   readWorkspacePdf: (options) =>
     ipcRenderer.invoke('file:read-workspace-pdf', options),
+  readLocalPdfText: (options) =>
+    ipcRenderer.invoke('file:read-local-pdf-text', options),
   saveWorkspaceFileAs: (payload) =>
     ipcRenderer.invoke('file:save-as', payload),
   writeWorkspaceFile: (payload) =>
diff --git a/src/renderer/src/agent/kun-contract.ts b/src/renderer/src/agent/kun-contract.ts
index 8641ae6a4..f0e76abcd 100644
--- a/src/renderer/src/agent/kun-contract.ts
+++ b/src/renderer/src/agent/kun-contract.ts
@@ -16,12 +16,20 @@ export type CoreItemStatus =
 export type CoreThreadSummaryJson = {
   id: string
   title: string
+  /** Whether the title is auto/provisional (see ThreadSchema.titleAuto on the core). */
+  titleAuto?: boolean
+  /** Optional whole-conversation summary produced by the summarize route. */
+  summary?: string
   workspace?: string
   model: string
   mode: string
   status: CoreThreadStatus
   approvalPolicy?: string
   sandboxMode?: string
+  pinned?: boolean
+  providerId?: string
+  agentId?: string
+  systemPrompt?: string
   relation?: 'primary' | 'fork' | 'side'
   parentThreadId?: string
   forkedFromThreadId?: string
@@ -535,6 +543,10 @@ export type CoreRuntimeEventJson = {
 	  changeKind?: 'additive' | 'breaking'
 	  toolNames?: string[]
   status?: string
+  /** thread_created / thread_updated: the thread's (possibly upgraded) title. */
+  title?: string
+  /** thread_created / thread_updated: whether that title is auto/provisional. */
+  titleAuto?: boolean
   stage?:
     | 'setup'
     | 'pre_start'
diff --git a/src/renderer/src/agent/kun-mapper.ts b/src/renderer/src/agent/kun-mapper.ts
index 1c37ae741..dd20c84f2 100644
--- a/src/renderer/src/agent/kun-mapper.ts
+++ b/src/renderer/src/agent/kun-mapper.ts
@@ -48,6 +48,8 @@ export function threadFromCore(thread: CoreThreadSummaryJson): NormalizedThread
   return {
     id: thread.id,
     title: thread.title?.trim() || thread.id.slice(0, 8),
+    ...(thread.titleAuto !== undefined ? { titleAuto: thread.titleAuto } : {}),
+    ...(thread.summary?.trim() ? { summary: thread.summary.trim() } : {}),
     updatedAt: thread.updatedAt,
     model: thread.model,
     mode: thread.mode,
@@ -56,6 +58,10 @@ export function threadFromCore(thread: CoreThreadSummaryJson): NormalizedThread
     approvalPolicy: normalizeApprovalPolicy(thread.approvalPolicy),
     sandboxMode: normalizeSandboxMode(thread.sandboxMode),
     archived: thread.status === 'archived',
+    pinned: thread.pinned === true,
+    ...(thread.providerId ? { providerId: thread.providerId } : {}),
+    ...(thread.agentId ? { agentId: thread.agentId } : {}),
+    ...(thread.systemPrompt ? { systemPrompt: thread.systemPrompt } : {}),
     relation: thread.relation,
     parentThreadId: thread.parentThreadId,
     forkedFromThreadId: thread.forkedFromThreadId,
@@ -1222,6 +1228,14 @@ export async function dispatchKunRuntimeEvent(
     case 'usage':
       if (event.usage) sink.onUsage?.(usageFromCore(event.usage))
       return
+    case 'thread_updated':
+      sink.onThreadUpdated?.({
+        threadId: event.threadId ?? '',
+        ...(event.title !== undefined ? { title: event.title } : {}),
+        ...(event.titleAuto !== undefined ? { titleAuto: event.titleAuto } : {}),
+        ...(event.status !== undefined ? { status: event.status } : {})
+      })
+      return
     case 'turn_completed':
     case 'turn_aborted':
       sink.onTurnComplete()
diff --git a/src/renderer/src/agent/kun-runtime.test.ts b/src/renderer/src/agent/kun-runtime.test.ts
index b1b8c19fc..101756e69 100644
--- a/src/renderer/src/agent/kun-runtime.test.ts
+++ b/src/renderer/src/agent/kun-runtime.test.ts
@@ -20,13 +20,14 @@ function settings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: defaultKunRuntimeSettings()
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/renderer/src/agent/kun-runtime.ts b/src/renderer/src/agent/kun-runtime.ts
index a5363c9b0..0d63ac107 100644
--- a/src/renderer/src/agent/kun-runtime.ts
+++ b/src/renderer/src/agent/kun-runtime.ts
@@ -155,7 +155,12 @@ export class KunRuntimeProvider implements AgentProvider {
   async createThread(input: {
     workspace?: string
     title?: string
+    titleAuto?: boolean
     mode?: KunThreadMode
+    agentId?: string
+    providerId?: string
+    model?: string
+    systemPrompt?: string
   }): Promise<NormalizedThread> {
     const settings = await rendererRuntimeClient.getSettings()
     const runtime = getKunRuntimeSettings(settings)
@@ -165,10 +170,14 @@ export class KunRuntimeProvider implements AgentProvider {
       JSON.stringify({
         workspace: input.workspace || settings.workspaceRoot || '~',
         title: input.title,
-        model: runtime.model,
+        ...(input.titleAuto !== undefined ? { titleAuto: input.titleAuto } : {}),
+        model: input.model?.trim() || runtime.model,
         mode: normalizeThreadMode(input.mode),
         approvalPolicy: runtime.approvalPolicy,
-        sandboxMode: runtime.sandboxMode
+        sandboxMode: runtime.sandboxMode,
+        ...(input.providerId?.trim() ? { providerId: input.providerId.trim() } : {}),
+        ...(input.agentId?.trim() ? { agentId: input.agentId.trim() } : {}),
+        ...(input.systemPrompt?.trim() ? { systemPrompt: input.systemPrompt.trim() } : {})
       })
     )
     if (!response.ok) {
@@ -366,11 +375,11 @@ export class KunRuntimeProvider implements AgentProvider {
     }
   }
 
-  async renameThread(threadId: string, title: string): Promise<void> {
+  async renameThread(threadId: string, title: string, auto?: boolean): Promise<void> {
     const response = await rendererRuntimeClient.runtimeRequest(
       kunThreadPath(threadId),
       'PATCH',
-      JSON.stringify({ title })
+      JSON.stringify({ title, ...(auto !== undefined ? { titleAuto: auto } : {}) })
     )
     if (!response.ok) {
       throw runtimeErrorToError(readRuntimeError(response.body, 'rename thread failed'))
@@ -388,6 +397,17 @@ export class KunRuntimeProvider implements AgentProvider {
     }
   }
 
+  async updateThreadPinned(threadId: string, pinned: boolean): Promise<void> {
+    const response = await rendererRuntimeClient.runtimeRequest(
+      kunThreadPath(threadId),
+      'PATCH',
+      JSON.stringify({ pinned })
+    )
+    if (!response.ok) {
+      throw runtimeErrorToError(readRuntimeError(response.body, 'update thread pin failed'))
+    }
+  }
+
   async archiveThread(threadId: string, archived: boolean): Promise<void> {
     const response = await window.kunGui.runtimeRequest(
       kunThreadPath(threadId),
diff --git a/src/renderer/src/agent/runtime-client.test.ts b/src/renderer/src/agent/runtime-client.test.ts
index c62f647fd..d087c7de9 100644
--- a/src/renderer/src/agent/runtime-client.test.ts
+++ b/src/renderer/src/agent/runtime-client.test.ts
@@ -17,7 +17,7 @@ function settings(apiKey: string): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: {
@@ -27,6 +27,7 @@ function settings(apiKey: string): AppSettingsV1 {
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/renderer/src/agent/types.ts b/src/renderer/src/agent/types.ts
index 425ab5c1b..943b58bfc 100644
--- a/src/renderer/src/agent/types.ts
+++ b/src/renderer/src/agent/types.ts
@@ -15,11 +15,16 @@ export type RuntimeErrorSeverity = 'info' | 'warning' | 'error'
 
 export type AttachmentReference = {
   id: string
+  kind?: 'image' | 'document'
   name?: string
   mimeType?: string
   byteSize?: number
   width?: number
   height?: number
+  pageCount?: number
+  truncated?: boolean
+  textPreview?: string
+  documentText?: string
   previewUrl?: string
 }
 
@@ -95,6 +100,8 @@ export type UserInputAnswer = {
 export type NormalizedThread = {
   id: string
   title: string
+  /** Whether the title is auto/provisional (true) vs user-set/locked (false); absent = legacy. */
+  titleAuto?: boolean
   updatedAt: string
   model: string
   mode: string
@@ -102,8 +109,17 @@ export type NormalizedThread = {
   status?: string
   approvalPolicy?: ApprovalPolicy
   sandboxMode?: SandboxMode
+  /** Optional provider id when this thread is pinned to a non-default provider. */
+  providerId?: string
+  /** Optional subagent profile id this thread is bound to (primary-agent persona). */
+  agentId?: string
+  /** Optional persona systemPrompt snapshot applied to every ModelRequest on this thread. */
+  systemPrompt?: string
   archived?: boolean
+  pinned?: boolean
   preview?: string
+  /** Whole-conversation summary produced by the summarize route; shown as the list subtitle. */
+  summary?: string
   latestTurnId?: string
   latestTurnStatus?: string
   relation?: 'primary' | 'fork' | 'side'
@@ -265,7 +281,7 @@ export type ChatBlock =
       approvalId: string
       summary: string
       toolName?: string
-      status: 'pending' | 'allowed' | 'denied' | 'error'
+      status: 'pending' | 'submitting' | 'allowed' | 'denied' | 'error'
       errorMessage?: string
       meta?: RuntimeDisclosureMetadata
     }
@@ -405,6 +421,8 @@ export type ThreadEventSink = {
   onRuntimeError?(ev: RuntimeErrorEventPayload): void
   onGoal(ev: { threadId: string; goal: ThreadGoal | null; cleared?: boolean; createdAt?: string }): void
   onTodos?(ev: { threadId: string; todos: ThreadTodoList | null; cleared?: boolean; createdAt?: string }): void
+  /** Thread metadata changed out-of-band (e.g. the backend LLM titler upgraded the title). */
+  onThreadUpdated?(ev: { threadId: string; title?: string; titleAuto?: boolean; status?: string }): void
   onTurnComplete(): void
   onError(err: Error, options?: ThreadErrorOptions): void
   /** Optional: cumulative usage update for the thread. */
@@ -423,7 +441,7 @@ export interface AgentProvider {
   }
   connect(): Promise<void>
   listThreads(options?: ThreadListOptions): Promise<NormalizedThread[]>
-  createThread(input: { workspace?: string; title?: string; mode?: string }): Promise<NormalizedThread>
+  createThread(input: { workspace?: string; title?: string; titleAuto?: boolean; mode?: string; agentId?: string; providerId?: string; model?: string; systemPrompt?: string }): Promise<NormalizedThread>
   getThreadDetail(threadId: string): Promise<{
     blocks: ChatBlock[]
     latestSeq: number
@@ -496,8 +514,14 @@ export interface AgentProvider {
   getMemoryDiagnostics?(): Promise<CoreMemoryDiagnosticsJson>
   steerUserMessage?(threadId: string, turnId: string, text: string): Promise<void>
   interruptTurn(threadId: string, turnId: string, options?: { discard?: boolean }): Promise<void>
-  renameThread(threadId: string, title: string): Promise<void>
+  /**
+   * Rename a thread. `auto` marks the title as provisional/auto (true, e.g. the
+   * client first-message heuristic — the backend LLM titler may upgrade it) or
+   * user-set/locked (false). Omit to leave the title's auto flag unchanged.
+   */
+  renameThread(threadId: string, title: string, auto?: boolean): Promise<void>
   updateThreadWorkspace?(threadId: string, workspace: string): Promise<void>
+  updateThreadPinned?(threadId: string, pinned: boolean): Promise<void>
   archiveThread?(threadId: string, archived: boolean): Promise<void>
   deleteThread(threadId: string): Promise<void>
   compactThread?(threadId: string, reason?: string): Promise<{ replacedTokens: number } | void>
diff --git a/src/renderer/src/components/InitialSetupDialog.tsx b/src/renderer/src/components/InitialSetupDialog.tsx
index 3df702648..0208089f6 100644
--- a/src/renderer/src/components/InitialSetupDialog.tsx
+++ b/src/renderer/src/components/InitialSetupDialog.tsx
@@ -2,9 +2,12 @@ import { type ReactElement, useEffect, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import {
   DEFAULT_MODEL_PROVIDER_ID,
+  KUN_TOOL_PERMISSION_MODES,
+  kunToolPermissionModeSettings,
   normalizeAppSettings,
   type AppSettingsPatch,
   type AppSettingsV1,
+  type KunToolPermissionMode,
   type ModelProviderPreset
 } from '@shared/app-settings'
 import {
@@ -27,9 +30,13 @@ import {
   Eye,
   EyeOff,
   ExternalLink,
+  FolderPen,
+  Hand,
   Image as ImageIcon,
+  LockKeyholeOpen,
   MessageCircle,
   Mic,
+  ShieldQuestion,
   Sparkles,
   Sun,
   Moon,
@@ -51,6 +58,59 @@ const themeOptions: { value: ThemePref; icon: typeof Sun; labelKey: string }[] =
 ]
 const DEEPSEEK_USAGE_URL = 'https://platform.deepseek.com/usage'
 
+type PermissionOption = {
+  value: KunToolPermissionMode
+  labelKey: string
+  descriptionKey: string
+  Icon: typeof Hand
+  iconClass: string
+}
+
+const PERMISSION_OPTIONS: PermissionOption[] = KUN_TOOL_PERMISSION_MODES.map((value) => {
+  switch (value) {
+    case 'always-ask':
+      return {
+        value,
+        labelKey: 'toolPermissionAlwaysAsk',
+        descriptionKey: 'toolPermissionAlwaysAskDesc',
+        Icon: Hand,
+        iconClass: 'border-sky-400/30 bg-sky-500/10 text-sky-700 dark:text-sky-200'
+      }
+    case 'read-only':
+      return {
+        value,
+        labelKey: 'toolPermissionReadOnly',
+        descriptionKey: 'toolPermissionReadOnlyDesc',
+        Icon: Eye,
+        iconClass: 'border-emerald-400/30 bg-emerald-500/10 text-emerald-700 dark:text-emerald-200'
+      }
+    case 'sensitive-ask':
+      return {
+        value,
+        labelKey: 'toolPermissionSensitiveAsk',
+        descriptionKey: 'toolPermissionSensitiveAskDesc',
+        Icon: ShieldQuestion,
+        iconClass: 'border-amber-400/35 bg-amber-500/10 text-amber-700 dark:text-amber-200'
+      }
+    case 'workspace-write':
+      return {
+        value,
+        labelKey: 'toolPermissionWorkspaceWrite',
+        descriptionKey: 'toolPermissionWorkspaceWriteDesc',
+        Icon: FolderPen,
+        iconClass: 'border-indigo-400/30 bg-indigo-500/10 text-indigo-700 dark:text-indigo-200'
+      }
+    case 'bypass':
+      return {
+        value,
+        labelKey: 'toolPermissionBypass',
+        descriptionKey: 'toolPermissionBypassDesc',
+        Icon: LockKeyholeOpen,
+        iconClass: 'border-orange-400/35 bg-orange-500/10 text-orange-700 dark:text-orange-200'
+      }
+  }
+})
+
 type SetupProviderCard = {
   presetId: string
   name: string
@@ -141,7 +201,8 @@ export function InitialSetupDialog(): ReactElement {
   const [drafts, setDrafts] = useState<InitialSetupDrafts | null>(null)
   const [selection, setSelection] = useState<InitialSetupSelection>({
     presetId: DEFAULT_MODEL_PROVIDER_ID,
-    mode: 'api'
+    mode: 'api',
+    permissionMode: 'read-only'
   })
   const [showApiKey, setShowApiKey] = useState(false)
   const [saving, setSaving] = useState(false)
@@ -211,7 +272,7 @@ export function InitialSetupDialog(): ReactElement {
 
   const selectCard = (presetId: string): void => {
     setError(null)
-    setSelection((current) => (current.presetId === presetId ? current : { presetId, mode: 'api' }))
+    setSelection((current) => (current.presetId === presetId ? current : { ...current, presetId, mode: 'api' }))
   }
 
   const selectMode = (mode: InitialSetupSelection['mode']): void => {
@@ -219,6 +280,22 @@ export function InitialSetupDialog(): ReactElement {
     setSelection((current) => ({ ...current, mode }))
   }
 
+  const selectPermissionMode = (permissionMode: KunToolPermissionMode): void => {
+    setError(null)
+    setSelection((current) => ({ ...current, permissionMode }))
+    const current = formRef.current
+    if (!current) return
+    updateForm({
+      agents: {
+        ...current.agents,
+        kun: {
+          ...current.agents.kun,
+          ...kunToolPermissionModeSettings(permissionMode)
+        }
+      }
+    } as SetupFormPatch)
+  }
+
   const cardFilled = (card: SetupProviderCard): boolean => {
     if (!drafts) return false
     if (drafts[card.presetId]?.apiKey.trim()) return true
@@ -465,6 +542,39 @@ export function InitialSetupDialog(): ReactElement {
             </div>
           )}
 
+          <div className="space-y-2.5 sm:space-y-3.5">
+            <label className={labelClass}>
+              {t('firstRunPermissionLabel')}
+            </label>
+            <div className="grid grid-cols-1 gap-2 sm:gap-2.5 min-[520px]:grid-cols-2">
+              {PERMISSION_OPTIONS.map((option) => {
+                const isActive = selection.permissionMode === option.value
+                const Icon = option.Icon
+                return (
+                  <button
+                    key={option.value}
+                    type="button"
+                    onClick={() => selectPermissionMode(option.value)}
+                    className={cardButtonClass(isActive)}
+                  >
+                    <span className="flex min-w-0 items-center gap-2 text-sm font-semibold text-slate-800 dark:text-slate-100">
+                      <span className={`inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-lg border ${option.iconClass}`}>
+                        <Icon className="h-3.5 w-3.5" strokeWidth={1.9} />
+                      </span>
+                      <span className="min-w-0 truncate">{t(option.labelKey)}</span>
+                    </span>
+                    <span className="text-[12px] leading-5 text-slate-500 dark:text-slate-400">
+                      {t(option.descriptionKey)}
+                    </span>
+                  </button>
+                )
+              })}
+            </div>
+            <div className="rounded-xl border border-orange-300/60 bg-orange-50/80 px-4 py-3 text-[12.5px] leading-5 text-orange-800 dark:border-orange-800/60 dark:bg-orange-950/30 dark:text-orange-200">
+              {t('firstRunPermissionFullAccessRisk')}
+            </div>
+          </div>
+
           {regions.length > 0 && (
             <div className="space-y-2.5 sm:space-y-3.5">
               <label className={labelClass}>
diff --git a/src/renderer/src/components/PluginMarketplaceView.test.ts b/src/renderer/src/components/PluginMarketplaceView.test.ts
index 2f1f91d25..fc1dd4f68 100644
--- a/src/renderer/src/components/PluginMarketplaceView.test.ts
+++ b/src/renderer/src/components/PluginMarketplaceView.test.ts
@@ -428,3 +428,62 @@ describe('URL validation guards', () => {
     expect(isAllowedDocsUrl(undefined)).toBe(false)
   })
 })
+
+describe('customMcpConfigFragment HTTPS enforcement', () => {
+  it('rejects a non-https url in a top-level servers object', () => {
+    expect(() => customMcpConfigFragment(
+      'evil',
+      '{"servers":{"evil":{"transport":"streamable-http","url":"http://mcp.evil.com"}}}',
+      {}
+    )).toThrow(/HTTPS/i)
+  })
+
+  it('rejects a non-https url nested under capabilities.mcp.servers', () => {
+    expect(() => customMcpConfigFragment(
+      'evil',
+      '{"capabilities":{"mcp":{"servers":{"evil":{"url":"http://mcp.evil.com"}}}}}',
+      {}
+    )).toThrow(/HTTPS/i)
+  })
+
+  it('rejects a non-https url on a single-server fragment', () => {
+    expect(() => customMcpConfigFragment(
+      'evil',
+      '{"transport":"streamable-http","url":"ftp://mcp.evil.com"}',
+      {}
+    )).toThrow(/HTTPS/i)
+  })
+
+  it('still accepts command-based servers and https urls', () => {
+    expect(() => customMcpConfigFragment(
+      'docs',
+      '{"transport":"stdio","command":"npx","args":["docs-mcp"]}',
+      {}
+    )).not.toThrow()
+    expect(() => customMcpConfigFragment(
+      'vercel',
+      '{"servers":{"vercel":{"transport":"streamable-http","url":"https://mcp.vercel.com"}}}',
+      {}
+    )).not.toThrow()
+  })
+
+  it('does not consult an inherited url via prototype pollution', () => {
+    // If validation read `server.url` directly, an attacker could set
+    // Object.prototype.url to an https string and smuggle a real http url on
+    // the own property. The hasOwnProperty-based lookup must ignore the
+    // inherited key, so the own (http) value is what gets rejected.
+    const proto = Object.prototype as { url?: unknown }
+    const original = proto.url
+    try {
+      proto.url = 'https://decoy.example.com'
+      expect(() => customMcpConfigFragment(
+        'evil',
+        '{"servers":{"evil":{"transport":"streamable-http","url":"http://mcp.evil.com"}}}',
+        {}
+      )).toThrow(/HTTPS/i)
+    } finally {
+      if (original === undefined) delete proto.url
+      else proto.url = original
+    }
+  })
+})
diff --git a/src/renderer/src/components/PluginMarketplaceView.tsx b/src/renderer/src/components/PluginMarketplaceView.tsx
index d0acb3d89..df06a6b91 100644
--- a/src/renderer/src/components/PluginMarketplaceView.tsx
+++ b/src/renderer/src/components/PluginMarketplaceView.tsx
@@ -145,6 +145,28 @@ export function isHttpsUrl(url: unknown): boolean {
   }
 }
 
+/**
+ * Validates that every server entry in a `servers` object that declares a
+ * remote `url` enforces HTTPS. Command-based servers (no `url` field) pass
+ * through. Throws on any non-https url so the caller surfaces a clear error
+ * before the fragment is written into the persisted MCP config.
+ *
+ * Iteration uses Object.entries (own enumerable properties) and the url lookup
+ * uses Object.prototype.hasOwnProperty.call, so a prototype-polluted object
+ * cannot smuggle a non-https url past the check via an inherited `url` key.
+ */
+function validateMcpServersHttps(servers: JsonRecord): void {
+  for (const [id, server] of Object.entries(servers)) {
+    if (!isJsonRecord(server)) {
+      throw new Error(`MCP server "${id}" must be an object`)
+    }
+    if (!Object.prototype.hasOwnProperty.call(server, 'url')) continue
+    if (!isHttpsUrl(server.url)) {
+      throw new Error(`MCP server "${id}" URL must use HTTPS (got ${typeof server.url === 'string' ? server.url : typeof server.url})`)
+    }
+  }
+}
+
 /** Origins whose docs links the OAuth connector preview may open externally. */
 const OAUTH_DOCS_ALLOWED_ORIGINS: readonly string[] = [
   'https://vercel.com',
@@ -332,12 +354,21 @@ export function customMcpConfigFragment(id: string, raw: string, fallback: JsonR
   const trimmed = raw.trim()
   if (!trimmed) return fallback
   const parsed = parseMcpJsonConfig(trimmed)
-  if (isJsonRecord(parsed.servers)) return parsed
+  if (isJsonRecord(parsed.servers)) {
+    validateMcpServersHttps(parsed.servers)
+    return parsed
+  }
   if (isJsonRecord(parsed.capabilities)) {
     const mcp = isJsonRecord(parsed.capabilities.mcp) ? parsed.capabilities.mcp : undefined
-    if (isJsonRecord(mcp?.servers)) return { servers: mcp.servers }
+    if (isJsonRecord(mcp?.servers)) {
+      validateMcpServersHttps(mcp.servers)
+      return { servers: mcp.servers }
+    }
   }
   if (parsed.command !== undefined || parsed.url !== undefined || parsed.transport !== undefined) {
+    if (parsed.url !== undefined && !isHttpsUrl(parsed.url)) {
+      throw new Error(`MCP server URL must use HTTPS: ${String(parsed.url)}`)
+    }
     return { servers: { [id]: parsed } }
   }
   throw new Error('MCP JSON config must include a servers object or a single server object.')
diff --git a/src/renderer/src/components/Workbench.tsx b/src/renderer/src/components/Workbench.tsx
index 8496a78d9..65e360696 100644
--- a/src/renderer/src/components/Workbench.tsx
+++ b/src/renderer/src/components/Workbench.tsx
@@ -29,6 +29,7 @@ import { rendererRuntimeClient } from '../agent/runtime-client'
 import { applyTheme } from '../lib/apply-theme'
 import { useChatStore } from '../store/chat-store'
 import {
+  conversationHasVisionAttachments,
   isClawThread,
   providerIdForComposerModel,
   resolveComposerContextWindowTokens
@@ -140,6 +141,9 @@ const ScheduleTasksView = lazy(() =>
 const WorkflowView = lazy(() =>
   import('./workflow/WorkflowView').then((module) => ({ default: module.WorkflowView }))
 )
+const SubagentDetailPanel = lazy(() =>
+  import('./subagents/SubagentDetailPanel').then((module) => ({ default: module.SubagentDetailPanel }))
+)
 const WorkflowRunPanel = lazy(() =>
   import('./workflow/WorkflowRunPanel').then((module) => ({ default: module.WorkflowRunPanel }))
 )
@@ -247,6 +251,38 @@ function composerReferencesToUserFileReferences(
   }))
 }
 
+function isPdfAttachmentFile(file: File): boolean {
+  return file.type === 'application/pdf' || file.name.toLowerCase().endsWith('.pdf')
+}
+
+function stripTransientAttachmentFields(attachments: AttachmentReference[]): AttachmentReference[] {
+  return attachments.map(({ documentText: _documentText, ...attachment }) => attachment)
+}
+
+function buildComposerDocumentContextPrompt(
+  userPrompt: string,
+  attachments: AttachmentReference[]
+): string {
+  const entries: ComposerFileContextEntry[] = []
+  let remainingChars = COMPOSER_FILE_CONTEXT_MAX_TOTAL_CHARS
+  for (const attachment of attachments) {
+    if (remainingChars <= 0) break
+    if (attachment.kind !== 'document' || !attachment.documentText?.trim()) continue
+    const clipped = clipComposerFileContext(
+      attachment.documentText,
+      remainingChars,
+      attachment.truncated === true
+    )
+    remainingChars -= clipped.consumed
+    entries.push({
+      relativePath: attachment.name || attachment.id,
+      content: clipped.content,
+      ...(clipped.truncated ? { truncated: true } : {})
+    })
+  }
+  return entries.length > 0 ? buildComposerFileContextPrompt(userPrompt, entries) : userPrompt
+}
+
 function sddDraftPlanRelativePath(draft: SddDraft): string {
   const parts = draft.relativePath.replaceAll('\\', '/').split('/').filter(Boolean)
   const draftFolder = parts.at(-2)?.trim() || draft.id.split(':').pop()?.trim() || `draft-${Date.now()}`
@@ -384,6 +420,7 @@ export function Workbench(): ReactElement {
     setComposerModel,
     setThreadSearch,
     renameThread,
+    pinThread,
     archiveThread,
     deleteThread,
     spawnSideConversation,
@@ -445,6 +482,7 @@ export function Workbench(): ReactElement {
       setComposerModel: s.setComposerModel,
       setThreadSearch: s.setThreadSearch,
       renameThread: s.renameThread,
+      pinThread: s.pinThread,
       archiveThread: s.archiveThread,
       deleteThread: s.deleteThread,
       spawnSideConversation: s.spawnSideConversation,
@@ -533,7 +571,7 @@ export function Workbench(): ReactElement {
   const sddTitleSyncTimerRef = useRef<number | null>(null)
   const lastSyncedSddTitleRef = useRef<Record<string, string>>({})
   const timelineBlocks = blocks
-  const lockVisionToTextModelSwitch = route === 'chat' && timelineBlocks.some((block) => block.kind === 'user')
+  const lockVisionToTextModelSwitch = route === 'chat' && conversationHasVisionAttachments(timelineBlocks)
   const timelineLiveReasoning = liveReasoning
   const timelineLiveAssistant = liveAssistant
   const devPreviewBlocks = useMemo<ChatBlock[]>(() => {
@@ -1105,26 +1143,47 @@ export function Workbench(): ReactElement {
   ): Promise<void> => {
     if (!files.length || !attachmentUploadEnabled) return
     const provider = getProvider()
-    if (typeof provider.uploadAttachment !== 'function') {
-      setAttachmentUploadError(t('composerAttachmentUnavailable'))
-      return
-    }
     setAttachmentUploadBusy(true)
     setAttachmentUploadError(null)
     try {
       const workspace = activeComposerWorkspace()
       const attachmentCapabilities = runtimeInfo?.capabilities.attachments
-      if (!attachmentCapabilities) {
-        setAttachmentUploadError(t('composerAttachmentUnavailable'))
-        return
-      }
       const uploaded: AttachmentReference[] = []
       for (const [index, file] of files.entries()) {
-        if (!file.type.startsWith('image/')) continue
-        const prepared = await prepareImageAttachmentUpload(file, attachmentCapabilities)
         const localFilePath =
           options.localFilePaths?.[index] ||
           (typeof window.kunGui?.getPathForFile === 'function' ? window.kunGui.getPathForFile(file) : '')
+        if (isPdfAttachmentFile(file)) {
+          if (!localFilePath || typeof window.kunGui?.readLocalPdfText !== 'function') {
+            throw new Error(t('composerPdfAttachmentUnavailable'))
+          }
+          const result = await window.kunGui.readLocalPdfText({ path: localFilePath })
+          if (!result.ok) throw new Error(result.message)
+          const documentText = result.text.trim()
+          if (!documentText) throw new Error(t('composerPdfAttachmentNoText'))
+          uploaded.push({
+            id: `doc_${result.mtimeMs}_${index}_${file.name || 'pdf'}`,
+            kind: 'document',
+            name: file.name || fileNameFromPath(result.path),
+            mimeType: 'application/pdf',
+            byteSize: result.size,
+            pageCount: result.pageCount,
+            truncated: result.truncated,
+            textPreview: documentText.slice(0, 240),
+            documentText
+          })
+          continue
+        }
+        if (!file.type.startsWith('image/')) {
+          throw new Error(t('composerAttachmentUnsupportedType'))
+        }
+        if (!selectedModelSupportsImageInput) {
+          throw new Error(t('composerAttachmentModelUnsupported'))
+        }
+        if (!attachmentCapabilities || typeof provider.uploadAttachment !== 'function') {
+          throw new Error(t('composerAttachmentUnavailable'))
+        }
+        const prepared = await prepareImageAttachmentUpload(file, attachmentCapabilities)
         const attachment = await provider.uploadAttachment({
           name: file.name || 'image',
           mimeType: prepared.mimeType,
@@ -1136,6 +1195,7 @@ export function Workbench(): ReactElement {
         })
         uploaded.push({
           id: attachment.id,
+          kind: 'image',
           name: attachment.name,
           mimeType: attachment.mimeType,
           width: attachment.width,
@@ -1181,8 +1241,11 @@ export function Workbench(): ReactElement {
   const sendWritePrompt = (value: string): void => {
     const v = value.trim()
     const attachments = composerAttachments
-    const attachmentIds = attachments.map((attachment) => attachment.id)
-    if (!v && attachmentIds.length === 0) return
+    const imageAttachments = attachments.filter((attachment) => attachment.kind !== 'document')
+    const documentAttachments = attachments.filter((attachment) => attachment.kind === 'document')
+    const attachmentIds = imageAttachments.map((attachment) => attachment.id)
+    const publicAttachments = stripTransientAttachmentFields(attachments)
+    if (!v && attachmentIds.length === 0 && documentAttachments.length === 0) return
     if (attachmentIds.length > 0 && !attachmentUploadEnabled) {
       setAttachmentUploadError(t('composerAttachmentModelUnsupported'))
       return
@@ -1217,7 +1280,10 @@ export function Workbench(): ReactElement {
           })
         }
       }
-      const messageText = v || t('composerImageOnlyPrompt')
+      const messageText = buildComposerDocumentContextPrompt(
+        v || (documentAttachments.length > 0 ? t('composerFileOnlyPrompt') : t('composerImageOnlyPrompt')),
+        documentAttachments
+      )
       const activeAgentPreset = writeState.agentPresets.find(
         (preset) => preset.id === writeState.assistantAgentPresetId
       )
@@ -1233,15 +1299,20 @@ export function Workbench(): ReactElement {
         writeState.assistantProviderId.trim() || providerIdForComposerModel(composerModelGroups, model)
       const reasoningEffort = composerReasoningEffortRequestValue(composerReasoningEffort)
       const sent = await sendMessage(prompt, composerMode === 'plan' ? 'plan' : 'agent', {
-        ...(!v && attachmentIds.length > 0 ? { displayText: t('composerImageOnlyDisplay') } : {}),
+        ...(!v && documentAttachments.length > 0
+          ? { displayText: t('composerFileOnlyDisplay', { count: documentAttachments.length }) }
+          : !v && attachmentIds.length > 0
+            ? { displayText: t('composerImageOnlyDisplay') }
+            : {}),
         ...(model ? { model } : {}),
         ...(providerId ? { providerId } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
-        ...(attachmentIds.length ? { attachmentIds, attachments } : {})
+        ...(attachmentIds.length ? { attachmentIds } : {}),
+        ...(publicAttachments.length ? { attachments: publicAttachments } : {})
       })
       if (sent) {
         useWriteWorkspaceStore.getState().clearQuotedSelections()
-        if (attachmentIds.length > 0) clearComposerAttachments()
+        if (attachments.length > 0) clearComposerAttachments()
       }
     })()
   }
@@ -1535,8 +1606,11 @@ export function Workbench(): ReactElement {
     const v = value.trim()
     const draft = useSddDraftStore.getState().activeDraft
     const attachments = composerAttachments
-    const attachmentIds = attachments.map((attachment) => attachment.id)
-    if ((!v && attachmentIds.length === 0) || !draft) return
+    const imageAttachments = attachments.filter((attachment) => attachment.kind !== 'document')
+    const documentAttachments = attachments.filter((attachment) => attachment.kind === 'document')
+    const attachmentIds = imageAttachments.map((attachment) => attachment.id)
+    const publicAttachments = stripTransientAttachmentFields(attachments)
+    if ((!v && attachmentIds.length === 0 && documentAttachments.length === 0) || !draft) return
     if (attachmentIds.length > 0 && !attachmentUploadEnabled) {
       setAttachmentUploadError(t('composerAttachmentModelUnsupported'))
       return
@@ -1545,7 +1619,10 @@ export function Workbench(): ReactElement {
     if (!threadId) return
     const snapshot = useSddDraftStore.getState()
     void saveActiveSddDraftToDisk()
-    const userPrompt = v || t('composerImageOnlyPrompt')
+    const userPrompt = buildComposerDocumentContextPrompt(
+      v || (documentAttachments.length > 0 ? t('composerFileOnlyPrompt') : t('composerImageOnlyPrompt')),
+      documentAttachments
+    )
     // Apply the armed framework only if its injected prompt is still in the
     // message being sent — editing it away, clearing the composer, or switching
     // drafts all leave a value that no longer contains it, so it is dropped.
@@ -1566,16 +1643,19 @@ export function Workbench(): ReactElement {
     const providerId = resolvedWriteAssistantProviderId.trim()
     const reasoningEffort = composerReasoningEffortRequestValue(composerReasoningEffort)
     const sent = await sendMessage(prompt, composerMode === 'plan' ? 'plan' : 'agent', {
-      displayText: v || t('composerImageOnlyDisplay'),
+      displayText: v || (documentAttachments.length > 0
+        ? t('composerFileOnlyDisplay', { count: documentAttachments.length })
+        : t('composerImageOnlyDisplay')),
       ...(model ? { model } : {}),
       ...(providerId ? { providerId } : {}),
       ...(reasoningEffort ? { reasoningEffort } : {}),
-      ...(attachmentIds.length ? { attachmentIds, attachments } : {})
+      ...(attachmentIds.length ? { attachmentIds } : {}),
+      ...(publicAttachments.length ? { attachments: publicAttachments } : {})
     })
     if (sent) {
       pendingSddFrameworkRef.current = null
       pendingSddFrameworkPromptRef.current = null
-      if (attachmentIds.length > 0) clearComposerAttachments()
+      if (attachments.length > 0) clearComposerAttachments()
     } else {
       // Restore the composer (incl. any framework prompt) so a retry re-applies
       // the same guidance the user still sees; the refs are intentionally kept.
@@ -1907,29 +1987,33 @@ export function Workbench(): ReactElement {
   const handleSendAsync = async (): Promise<void> => {
     const v = input.trim()
     const attachments = route === 'chat' || route === 'write' ? composerAttachments : []
-    const attachmentIds = attachments.map((attachment) => attachment.id)
+    const imageAttachments = attachments.filter((attachment) => attachment.kind !== 'document')
+    const documentAttachments = attachments.filter((attachment) => attachment.kind === 'document')
+    const attachmentIds = imageAttachments.map((attachment) => attachment.id)
+    const publicAttachments = stripTransientAttachmentFields(attachments)
     const fileReferences = route === 'chat' ? composerFileReferences : []
     const userFileReferences = composerReferencesToUserFileReferences(fileReferences)
     const reasoningEffort = composerReasoningEffortRequestValue(composerReasoningEffort)
-    if (!v && attachmentIds.length === 0 && fileReferences.length === 0) return
+    if (!v && attachmentIds.length === 0 && documentAttachments.length === 0 && fileReferences.length === 0) return
     if (attachmentIds.length > 0 && !attachmentUploadEnabled) {
       setAttachmentUploadError(t('composerAttachmentModelUnsupported'))
       return
     }
+    const contextAttachmentCount = fileReferences.length + documentAttachments.length
     const emptyPrompt =
-      fileReferences.length > 0 && attachmentIds.length > 0
+      contextAttachmentCount > 0 && attachmentIds.length > 0
         ? t('composerFileAndImageOnlyPrompt')
-        : fileReferences.length > 0
+        : contextAttachmentCount > 0
           ? t('composerFileOnlyPrompt')
           : t('composerImageOnlyPrompt')
     const emptyDisplayText = v
       ? undefined
-      : fileReferences.length > 0 && attachmentIds.length > 0
-        ? t('composerFileAndImageOnlyDisplay', { count: fileReferences.length })
-        : fileReferences.length > 0
-          ? t('composerFileOnlyDisplay', { count: fileReferences.length })
+      : contextAttachmentCount > 0 && attachmentIds.length > 0
+        ? t('composerFileAndImageOnlyDisplay', { count: contextAttachmentCount })
+        : contextAttachmentCount > 0
+          ? t('composerFileOnlyDisplay', { count: contextAttachmentCount })
           : t('composerImageOnlyDisplay')
-    const messageText = v || emptyPrompt
+    const messageText = buildComposerDocumentContextPrompt(v || emptyPrompt, documentAttachments)
     const prepareChatMessage = async (): Promise<{ text: string; displayText?: string } | null> => {
       if (fileReferences.length === 0) {
         return {
@@ -1976,7 +2060,8 @@ export function Workbench(): ReactElement {
       void sendPlanTurn(prepared.text, {
         ...(prepared.displayText ? { displayText: prepared.displayText } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
-        ...(attachmentIds.length ? { attachmentIds, attachments } : {}),
+        ...(attachmentIds.length ? { attachmentIds } : {}),
+        ...(publicAttachments.length ? { attachments: publicAttachments } : {}),
         ...(userFileReferences.length ? { fileReferences: userFileReferences } : {})
       })
       return
@@ -2083,7 +2168,8 @@ export function Workbench(): ReactElement {
     void sendMessage(prepared.text, composerMode === 'plan' ? 'plan' : 'agent', {
       ...(prepared.displayText ? { displayText: prepared.displayText } : {}),
       ...(reasoningEffort ? { reasoningEffort } : {}),
-      ...(attachmentIds.length ? { attachmentIds, attachments } : {}),
+      ...(attachmentIds.length ? { attachmentIds } : {}),
+      ...(publicAttachments.length ? { attachments: publicAttachments } : {}),
       ...(userFileReferences.length ? { fileReferences: userFileReferences } : {})
     })
   }
@@ -2152,7 +2238,7 @@ export function Workbench(): ReactElement {
     setConnectPhoneSidebarOpen((open) => !open)
   }
 
-  const sidebarView: 'chat' | 'write' | 'claw' | 'schedule' | 'workflow' =
+  const sidebarView: 'chat' | 'write' | 'claw' | 'schedule' | 'workflow' | 'subagents' =
     route === 'claw' || (route === 'plugins' && pluginHostRoute === 'claw')
       ? 'claw'
       : route === 'schedule'
@@ -2337,6 +2423,11 @@ export function Workbench(): ReactElement {
                 onCollapse={closeRightPanel}
                 className="h-full max-h-full w-full"
               />
+            ) : rightPanelMode === 'subagents' ? (
+              <SubagentDetailPanel
+                className="h-full max-h-full w-full"
+                onCollapse={closeRightPanel}
+              />
             ) : rightPanelMode === 'changes' ? (
               <ChangeInspector
                 blocks={blocks}
@@ -2461,6 +2552,7 @@ export function Workbench(): ReactElement {
               onThreadSearchChange={setThreadSearch}
               onSelectThread={openThread}
               onRenameThread={renameThread}
+              onPinThread={pinThread}
               onArchiveThread={(id) => archiveThread(id, true)}
               onDeleteThread={deleteThread}
               onRestoreThread={(id) => archiveThread(id, false)}
diff --git a/src/renderer/src/components/chat/FloatingComposer.tsx b/src/renderer/src/components/chat/FloatingComposer.tsx
index 30cfd6eee..7c1fe7c8e 100644
--- a/src/renderer/src/components/chat/FloatingComposer.tsx
+++ b/src/renderer/src/components/chat/FloatingComposer.tsx
@@ -91,6 +91,9 @@ import {
   FloatingComposerModelPicker,
   type ComposerReasoningEffort
 } from './FloatingComposerModelPicker'
+import { FloatingComposerAgentPicker } from './FloatingComposerAgentPicker'
+import { FloatingComposerUserInputPanel } from './FloatingComposerUserInputPanel'
+import { useComposerUserInput, type PendingUserInputBlock } from './use-composer-user-input'
 import {
   FloatingComposerQueuedMessages,
   type QueuedComposerMessage
@@ -314,6 +317,10 @@ function imageMimeTypeFromFileName(name: string | undefined): string | undefined
   return undefined
 }
 
+function isPdfFile(file: File): boolean {
+  return file.type === 'application/pdf' || file.name.toLowerCase().endsWith('.pdf')
+}
+
 function comparablePath(path: string | undefined): string {
   return (path ?? '').replace(/\\/g, '/').replace(/\/+$/g, '').toLowerCase()
 }
@@ -522,7 +529,22 @@ export function FloatingComposer({
   const clearActiveThreadGoal = useChatStore((s) => s.clearActiveThreadGoal)
   const clawChannels = useChatStore((s) => s.clawChannels)
   const activeClawChannelId = useChatStore((s) => s.activeClawChannelId)
+  const blocks = useChatStore((s) => s.blocks)
+  const resolveUserInput = useChatStore((s) => s.resolveUserInput)
   const compact = variant === 'compact'
+  // The pending ask-user request for the active thread, surfaced as a panel
+  // docked above this composer. Only the main chat composer hosts it: `blocks`
+  // is the active thread's, so a compact side composer would otherwise mirror
+  // it. The timeline bubble remains the record in every surface.
+  const pendingUserInputBlock = useMemo<PendingUserInputBlock | null>(() => {
+    if (compact || route !== 'chat') return null
+    for (let i = blocks.length - 1; i >= 0; i -= 1) {
+      const block = blocks[i]
+      if (block.kind === 'user_input' && block.status === 'pending') return block
+    }
+    return null
+  }, [blocks, compact, route])
+  const userInput = useComposerUserInput(pendingUserInputBlock, resolveUserInput)
   const fileInputRef = useRef<HTMLInputElement | null>(null)
   const speechToTextSettings = useSpeechToTextSettings()
   const dictationInputRef = useRef(input)
@@ -658,26 +680,19 @@ export function FloatingComposer({
     typeof runtimeSkillCount === 'number' ? runtimeSkillCount : lastKnownSkillCountRef.current
   const canShowContextCapacity =
     !compact && route === 'chat' && Boolean(activeThreadId) && effectiveContextWindow > 0
-  // Freeze the measured total for the duration of a turn: the runtime can emit
-  // several `usage` events while streaming, and tracking them live makes the
-  // chip jitter (visible flicker). Adopt the latest value only while idle.
   const liveMeasuredTotal =
     lastTurnUsage && lastTurnUsage.threadId === activeThreadId
       ? lastTurnUsage.snapshot.inputTokens
       : null
-  const measuredTotalRef = useRef<number | null>(null)
-  if (!busy) measuredTotalRef.current = liveMeasuredTotal
-  const measuredContextTotal = busy ? measuredTotalRef.current : liveMeasuredTotal
+  const measuredContextTotal = liveMeasuredTotal
   // The message estimate feeds the per-category split (popover), the
   // no-measured-total fallback, AND the sanity check that rejects an inflated
   // measured total (some providers over-report prompt_tokens — see
-  // buildContextCapacity). We therefore need it whenever the gauge is idle, not
-  // just when the popover is open. Never subscribe to `blocks` while streaming
-  // with the popover closed — blocks churn on every delta and re-render the
-  // whole composer; the frozen ref is good enough for that transient window.
-  const needMessageEstimate =
-    canShowContextCapacity && (contextCapacityOpen || measuredContextTotal == null || !busy)
-  const subscribeContextBlocks = needMessageEstimate && (contextCapacityOpen || !busy)
+  // buildContextCapacity). We therefore keep it live whenever the gauge can render, not
+  // just when the popover is open. Subscribe while streaming too so the context
+  // usage ring reflects the assistant reply as it becomes future context.
+  const needMessageEstimate = canShowContextCapacity
+  const subscribeContextBlocks = needMessageEstimate
   const contextBlocks = useChatStore((s) => (subscribeContextBlocks ? s.blocks : EMPTY_CONTEXT_BLOCKS))
   const conversationTokensRef = useRef(0)
   const conversationTokens = useMemo(() => {
@@ -730,6 +745,8 @@ export function FloatingComposer({
   const goalRuntimeStartedAtRef = useRef<number | null>(null)
   const placeholder = !runtimeReady
     ? t('runtimeActionNeedsConnection')
+    : pendingUserInputBlock
+      ? t('userInputComposerPlaceholder')
     : !hasActiveThread && !effectiveWorkspaceRoot
       ? t('workspaceRequiredToCreateThread')
       : goalPanelOpen && route !== 'claw'
@@ -1320,6 +1337,21 @@ export function FloatingComposer({
   }
 
   const handlePrimaryAction = (): void => {
+    // While an ask-user request is pending, a plain text reply answers the
+    // current question instead of being sent/queued as a chat message. Routing
+    // through resolveUserInput (not onSend) bypasses the busy-turn queue. Slash
+    // commands (input starting with "/") fall through so they stay escape
+    // hatches; an empty composer is a no-op (chips still work via the panel).
+    if (userInput.active) {
+      const trimmed = input.trim()
+      if (!trimmed.startsWith('/')) {
+        if (trimmed && userInput.submitTypedText(input)) {
+          setInput('')
+          draft.focusComposer()
+        }
+        return
+      }
+    }
     if (highlightedSlashCommand) {
       if (highlightedSlashCommand.disabled) return
       applySlashCommand(highlightedSlashCommand.id)
@@ -1378,6 +1410,14 @@ export function FloatingComposer({
         return
       }
     }
+    // Trailing fallback for a pending ask: text that began with "/" but matched
+    // no real command (e.g. a free-form answer like "/usr/local/bin") still
+    // answers the current question instead of leaking into chat via onSend.
+    if (userInput.active && input.trim() && userInput.submitTypedText(input)) {
+      setInput('')
+      draft.focusComposer()
+      return
+    }
     onSend()
   }
   dictationPrimaryActionRef.current = primaryActionDisabled ? null : handlePrimaryAction
@@ -1433,6 +1473,15 @@ export function FloatingComposer({
       }
     }
 
+    // Esc cancels a pending ask-user request. (Option picking is click-only:
+    // a bare-digit accelerator would hijack the first character of a
+    // digit-leading custom answer, which the type-to-answer design must allow.)
+    if (!composing && userInput.active && event.key === 'Escape') {
+      event.preventDefault()
+      userInput.cancel()
+      return
+    }
+
     if (!sendByEnter || composing) return
 
     event.preventDefault()
@@ -1495,7 +1544,8 @@ export function FloatingComposer({
   const handleComposerDragOver = (event: ReactDragEvent<HTMLDivElement>): void => {
     const dataTransferTypes = Array.from(event.dataTransfer.types ?? [])
     const canAcceptImages = canPickAttachment && imageTransferHasImages(event.dataTransfer)
-    if (!dataTransferTypes.includes('Files') && !canAcceptImages) return
+    const canAcceptPdf = canPickAttachment && Array.from(event.dataTransfer.files ?? []).some(isPdfFile)
+    if (!dataTransferTypes.includes('Files') && !canAcceptImages && !canAcceptPdf) return
     event.preventDefault()
     event.dataTransfer.dropEffect = 'copy'
   }
@@ -1528,11 +1578,12 @@ export function FloatingComposer({
     const rawFiles = Array.from(event.dataTransfer.files ?? [])
     const isImageLike = (file: File): boolean =>
       isImageMimeType(file.type) || Boolean(imageMimeTypeFromFileName(file.name))
-    const pathFiles = rawFiles.filter((file) => !isImageLike(file))
-    if (imageFiles.length === 0 && pathFiles.length === 0) return
+    const pdfFiles = canPickAttachment ? rawFiles.filter(isPdfFile) : []
+    const pathFiles = rawFiles.filter((file) => !isImageLike(file) && !isPdfFile(file))
+    if (imageFiles.length === 0 && pdfFiles.length === 0 && pathFiles.length === 0) return
     event.preventDefault()
-    if (imageFiles.length > 0 && onPickAttachments) {
-      onPickAttachments(imageFiles)
+    if ((imageFiles.length > 0 || pdfFiles.length > 0) && onPickAttachments) {
+      onPickAttachments([...imageFiles, ...pdfFiles])
     }
     if (pathFiles.length > 0) {
       const paths: string[] = []
@@ -1562,7 +1613,7 @@ export function FloatingComposer({
       />
 
       <div className="relative">
-        {showGoalFloater && activeThreadGoal ? (
+        {showGoalFloater && activeThreadGoal && !pendingUserInputBlock ? (
           <div className="pointer-events-none absolute inset-x-3 bottom-full z-20 mb-2 flex justify-center">
             <div className="pointer-events-auto flex min-h-11 w-full max-w-[46rem] items-center gap-2 rounded-full border border-ds-border bg-ds-card/95 px-3 py-1.5 text-ds-muted shadow-[0_12px_34px_rgba(20,47,95,0.10)] backdrop-blur-xl dark:bg-ds-card/90">
               <Target className="h-3.5 w-3.5 shrink-0 text-ds-faint" strokeWidth={1.9} />
@@ -1844,7 +1895,7 @@ export function FloatingComposer({
           </div>
         ) : null}
 
-        {goalPanelOpen && slashQuery == null ? (
+        {goalPanelOpen && slashQuery == null && !pendingUserInputBlock ? (
           <div
             ref={goalPanelRef}
             className="absolute inset-x-2 bottom-full z-30 mb-3 overflow-hidden rounded-[26px] border border-ds-border bg-ds-card/95 p-3 shadow-[0_18px_52px_rgba(20,47,95,0.14)] backdrop-blur-xl dark:bg-ds-card/90"
@@ -1930,6 +1981,10 @@ export function FloatingComposer({
           </div>
         ) : null}
 
+        {userInput.active ? (
+          <FloatingComposerUserInputPanel controller={userInput} t={t} />
+        ) : null}
+
         <div
           className={`ds-composer-shell ds-chat-composer ds-frosted ds-no-drag flex flex-col gap-1 px-3 pb-2 pt-2 transition ${
             draft.focused ? 'ds-chat-composer-focus' : ''
@@ -2060,10 +2115,19 @@ export function FloatingComposer({
                   <span
                     key={attachment.id}
                     className="ds-no-drag inline-flex h-7 max-w-full items-center gap-1.5 rounded-lg border border-ds-border-muted bg-ds-card/80 px-2 text-[12px] font-medium text-ds-muted"
-                    title={attachment.id}
+                    title={attachment.name || attachment.id}
                   >
-                    <ImagePlus className="h-3.5 w-3.5 shrink-0 text-ds-faint" strokeWidth={1.8} />
+                    {attachment.kind === 'document' ? (
+                      <FileText className="h-3.5 w-3.5 shrink-0 text-ds-faint" strokeWidth={1.8} />
+                    ) : (
+                      <ImagePlus className="h-3.5 w-3.5 shrink-0 text-ds-faint" strokeWidth={1.8} />
+                    )}
                     <span className="max-w-40 truncate">{attachment.name || attachment.id}</span>
+                    {attachment.kind === 'document' && attachment.pageCount ? (
+                      <span className="shrink-0 text-[11px] text-ds-faint">
+                        {attachment.pageCount}p{attachment.truncated ? '+' : ''}
+                      </span>
+                    ) : null}
                     {onRemoveAttachment ? (
                       <button
                         type="button"
@@ -2089,7 +2153,7 @@ export function FloatingComposer({
             <input
               ref={fileInputRef}
               type="file"
-              accept="image/png,image/jpeg,image/webp"
+              accept="image/png,image/jpeg,image/webp,application/pdf,.pdf"
               multiple
               className="hidden"
               onChange={handleAttachmentInput}
@@ -2254,6 +2318,9 @@ export function FloatingComposer({
                   onConfigureProviders={onConfigureProviders}
                 />
               )}
+              {hideModelPicker ? null : (
+                <FloatingComposerAgentPicker compact={compact} disabled={!canChangeModel} />
+              )}
               {showVoiceDictation ? (
                 <button
                   type="button"
diff --git a/src/renderer/src/components/chat/FloatingComposerAgentPicker.tsx b/src/renderer/src/components/chat/FloatingComposerAgentPicker.tsx
new file mode 100644
index 000000000..6ce1d74cc
--- /dev/null
+++ b/src/renderer/src/components/chat/FloatingComposerAgentPicker.tsx
@@ -0,0 +1,134 @@
+import type { ReactElement } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { Bot, ChevronDown } from 'lucide-react'
+import type { KunSubagentProfileV1 } from '@shared/app-settings'
+import { rendererRuntimeClient } from '../../agent/runtime-client'
+import { useChatStore } from '../../store/chat-store'
+
+type Props = {
+  /** When true, render only the icon. */
+  compact?: boolean
+  /** Disable selection (e.g. busy or non-chat route). */
+  disabled?: boolean
+}
+
+function isAvailableForPrimary(profile: KunSubagentProfileV1): boolean {
+  return profile.enabled && (profile.mode === 'primary' || profile.mode === 'all')
+}
+
+export function FloatingComposerAgentPicker({ compact = false, disabled }: Props): ReactElement | null {
+  const composerAgentId = useChatStore((s) => s.composerAgentId)
+  const setComposerAgentId = useChatStore((s) => s.setComposerAgentId)
+  const [agents, setAgents] = useState<KunSubagentProfileV1[]>([])
+  const [open, setOpen] = useState(false)
+  const rootRef = useRef<HTMLDivElement | null>(null)
+  const loadedRef = useRef(false)
+
+  const loadAgents = useCallback(async (force = false): Promise<void> => {
+    try {
+      const settings = await rendererRuntimeClient.getSettings({ forceRefresh: force })
+      const profiles = settings.agents?.kun?.subagents?.profiles ?? []
+      setAgents(profiles.filter(isAvailableForPrimary))
+      loadedRef.current = true
+    } catch {
+      /* swallow — picker just won't show entries */
+    }
+  }, [])
+
+  useEffect(() => { void loadAgents() }, [loadAgents])
+
+  // Reload when the menu opens to pick up edits made in SubagentsView
+  // mid-session. Force a refresh so a just-created agent shows immediately
+  // rather than waiting out the settings cache.
+  useEffect(() => {
+    if (open && loadedRef.current) void loadAgents(true)
+  }, [open, loadAgents])
+
+  // Close on outside click.
+  useEffect(() => {
+    if (!open) return
+    const handler = (event: MouseEvent): void => {
+      if (!rootRef.current?.contains(event.target as Node)) setOpen(false)
+    }
+    window.addEventListener('mousedown', handler)
+    return () => window.removeEventListener('mousedown', handler)
+  }, [open])
+
+  const active = agents.find((profile) => profile.id === composerAgentId)
+
+  // Don't render the picker when no primary-capable agent exists — it
+  // would just be dead UI clutter.
+  if (agents.length === 0 && !composerAgentId) return null
+
+  const clearAgent = (): void => {
+    setComposerAgentId('')
+    setOpen(false)
+  }
+  const pickAgent = (id: string): void => {
+    setComposerAgentId(id)
+    setOpen(false)
+  }
+
+  return (
+    <div ref={rootRef} className="ds-no-drag relative">
+      <button
+        type="button"
+        disabled={disabled}
+        onClick={() => setOpen((s) => !s)}
+        className={`flex h-7 items-center gap-1 rounded-full border border-ds-border bg-ds-raised px-2 text-xs text-ds-muted transition hover:bg-ds-hover hover:text-ds-ink disabled:cursor-not-allowed disabled:opacity-60 ${active ? 'text-ds-ink' : ''}`}
+        title={active ? `Agent: ${active.name}` : 'Pick agent persona for new chats'}
+      >
+        {active?.color ? (
+          <span className="inline-block h-3 w-3 rounded-full" style={{ backgroundColor: active.color }} />
+        ) : (
+          <Bot className="h-3.5 w-3.5" strokeWidth={1.75} />
+        )}
+        {!compact ? (
+          <span className="max-w-[120px] truncate">{active ? active.name : 'Default'}</span>
+        ) : null}
+        <ChevronDown className="h-3 w-3 opacity-60" strokeWidth={1.75} />
+      </button>
+      {open ? (
+        <div className="absolute bottom-full right-0 z-30 mb-2 w-64 overflow-hidden rounded-lg border border-ds-border bg-ds-main shadow-xl">
+          <div className="px-3 py-2 text-[10px] uppercase tracking-wider text-ds-faint">Agent persona</div>
+          <button
+            type="button"
+            onClick={clearAgent}
+            className={`flex w-full items-center gap-2 px-3 py-2 text-left text-sm hover:bg-ds-hover ${!composerAgentId ? 'bg-ds-subtle' : ''}`}
+          >
+            <Bot className="h-4 w-4 text-ds-muted" strokeWidth={1.75} />
+            <span className="flex-1 text-ds-ink">Default (runtime)</span>
+          </button>
+          {agents.length === 0 ? (
+            <p className="px-3 py-2 text-xs text-ds-muted">No agents available</p>
+          ) : null}
+          {agents.map((profile) => (
+            <button
+              key={profile.id}
+              type="button"
+              onClick={() => pickAgent(profile.id)}
+              className={`flex w-full items-start gap-2 px-3 py-2 text-left text-sm hover:bg-ds-hover ${composerAgentId === profile.id ? 'bg-ds-subtle' : ''}`}
+            >
+              <span
+                className="mt-0.5 inline-block h-3.5 w-3.5 shrink-0 rounded-full"
+                style={{ backgroundColor: profile.color ?? '#3b82f6' }}
+              />
+              <span className="min-w-0 flex-1">
+                <span className="block truncate text-ds-ink">{profile.name}</span>
+                {profile.description ? (
+                  <span className="block truncate text-xs text-ds-muted">{profile.description}</span>
+                ) : null}
+                <span className="block text-[10px] text-ds-faint">
+                  {profile.providerId ? `${profile.providerId}:` : ''}{profile.model ?? 'inherit'}
+                </span>
+              </span>
+            </button>
+          ))}
+          <div className="border-t border-ds-border px-3 py-2 text-[11px] text-ds-faint">
+            Applies to the next new chat.
+          </div>
+        </div>
+      ) : null}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/chat/FloatingComposerModelPicker.tsx b/src/renderer/src/components/chat/FloatingComposerModelPicker.tsx
index c04055827..cb5cdb198 100644
--- a/src/renderer/src/components/chat/FloatingComposerModelPicker.tsx
+++ b/src/renderer/src/components/chat/FloatingComposerModelPicker.tsx
@@ -169,10 +169,10 @@ export function FloatingComposerModelPicker({
     ? filterComposerModelIds(activeProviderGroup.modelIds, modelFilter)
     : []
   const comboboxWidthClass = stretch
-    ? 'min-w-0 flex-1 max-w-[284px]'
+    ? 'min-w-0 flex-1 max-w-[min(284px,45vw)] overflow-hidden'
     : compact
-      ? 'w-[184px] max-w-[184px] shrink-0'
-      : 'w-[248px] max-w-[260px] shrink-0'
+      ? 'w-[184px] max-w-[184px] shrink-0 overflow-hidden'
+      : 'w-[248px] max-w-[min(260px,42vw)] shrink-0 overflow-hidden'
 
   useEffect(() => {
     if (!reasoningEnabled) return
@@ -489,7 +489,7 @@ export function FloatingComposerModelPicker({
           aria-expanded={menuOpen}
           aria-haspopup="menu"
           aria-label={t('composerModelControls')}
-          className={`flex h-9 min-w-0 flex-1 items-center justify-end gap-1 rounded-full py-2 pl-3 pr-1 text-[13px] font-medium outline-none transition ${
+          className={`flex h-9 min-w-0 flex-1 items-center justify-end gap-1 overflow-hidden rounded-full py-2 pl-3 pr-1 text-[13px] font-medium outline-none transition ${
             canOpenModelControls
               ? 'text-current focus-visible:ring-2 focus-visible:ring-accent/25'
               : 'cursor-not-allowed text-ds-faint'
@@ -499,7 +499,7 @@ export function FloatingComposerModelPicker({
             {modelLabel}
           </span>
           {reasoningEnabled ? (
-            <span className="shrink-0 text-[12px] font-semibold text-ds-faint">
+            <span className="max-w-[72px] shrink-0 truncate text-[12px] font-semibold text-ds-faint" title={currentReasoningLabel}>
               {currentReasoningLabel}
             </span>
           ) : null}
@@ -514,10 +514,10 @@ export function FloatingComposerModelPicker({
 
   return (
     <div
-      className={`ds-composer-model-picker ds-no-drag relative h-9 shrink-0 items-center rounded-full transition ${
+      className={`ds-composer-model-picker ds-no-drag relative h-9 min-w-0 shrink-0 items-center overflow-hidden rounded-full transition ${
         canOpenModelControls ? 'text-ds-muted hover:bg-ds-hover hover:text-ds-ink' : 'text-ds-faint'
       } ${
-        compact ? 'max-w-[220px]' : 'max-w-[260px]'
+        compact ? 'max-w-[220px]' : 'max-w-[min(260px,42vw)]'
       }`}
       ref={(node) => {
         pickerRef.current = node
@@ -527,7 +527,7 @@ export function FloatingComposerModelPicker({
         type="button"
         disabled={!canOpenModelControls}
         onClick={() => setMenuOpen((open) => !open)}
-        className={`flex h-9 max-w-full items-center gap-1.5 rounded-full px-2.5 text-[13.5px] font-semibold transition disabled:cursor-not-allowed ${
+        className={`flex h-9 max-w-full min-w-0 items-center gap-1.5 overflow-hidden rounded-full px-2.5 text-[13.5px] font-semibold transition disabled:cursor-not-allowed ${
           canOpenModelControls ? 'hover:bg-ds-hover' : ''
         }`}
         aria-expanded={menuOpen}
@@ -535,9 +535,9 @@ export function FloatingComposerModelPicker({
         aria-label={t('composerModelControls')}
         title={controlsTitle}
       >
-        <span className="min-w-0 whitespace-nowrap">{modelLabel}</span>
+        <span className="min-w-0 truncate">{modelLabel}</span>
         {reasoningEnabled ? (
-          <span className="shrink-0 text-ds-faint">
+          <span className="max-w-[72px] shrink-0 truncate text-ds-faint" title={t(reasoningLabelKey(currentReasoning))}>
             {t(reasoningLabelKey(currentReasoning))}
           </span>
         ) : null}
diff --git a/src/renderer/src/components/chat/FloatingComposerUserInputPanel.tsx b/src/renderer/src/components/chat/FloatingComposerUserInputPanel.tsx
new file mode 100644
index 000000000..13cc482ee
--- /dev/null
+++ b/src/renderer/src/components/chat/FloatingComposerUserInputPanel.tsx
@@ -0,0 +1,189 @@
+import type { ReactElement } from 'react'
+import { Check, CornerDownLeft, HelpCircle, X } from 'lucide-react'
+import type { UserInputOption, UserInputQuestion } from '../../agent/types'
+import type { ComposerUserInputController } from './use-composer-user-input'
+import { optionsNeedRows, shouldShowQuestionHeader } from './user-input-panel-logic'
+
+type Translate = (key: string, options?: Record<string, unknown>) => string
+
+/**
+ * The ask-user input surface, docked directly above the composer. The common
+ * single-question case renders as bare chips (no header / progress / dismiss);
+ * multi-question asks add a light stepper. Selecting advances and auto-submits
+ * on the last question — see {@link ComposerUserInputController}. The timeline
+ * keeps the immutable record; this is only the input.
+ */
+export function FloatingComposerUserInputPanel({
+  controller,
+  t
+}: {
+  controller: ComposerUserInputController
+  t: Translate
+}): ReactElement | null {
+  const { currentQuestion, total, index } = controller
+  if (!controller.active || !currentQuestion) return null
+  const multi = total > 1
+  const options = currentQuestion.options
+  const hasOptions = options.length > 0
+  const useRows = optionsNeedRows(options)
+  const showHeader = shouldShowQuestionHeader(currentQuestion, total)
+
+  return (
+    <div
+      role="group"
+      aria-label={t('userInputPanelTitle')}
+      className="ds-no-drag absolute inset-x-2 bottom-full z-30 mb-3 overflow-hidden rounded-[26px] border border-accent/30 bg-ds-card/95 p-3.5 shadow-[0_18px_52px_rgba(20,47,95,0.14)] backdrop-blur-xl dark:bg-ds-card/90"
+    >
+      {multi ? (
+        <div className="mb-2.5">
+          <div className="flex items-center justify-between gap-2">
+            <div className="flex min-w-0 items-center gap-2">
+              <HelpCircle className="h-4 w-4 shrink-0 text-accent" strokeWidth={1.9} />
+              <span className="truncate text-[13px] font-semibold text-ds-ink">
+                {t('userInputPanelTitle')}
+              </span>
+            </div>
+            <div className="flex shrink-0 items-center gap-2">
+              <span className="text-[11.5px] font-medium text-ds-faint">
+                {index + 1}/{total}
+              </span>
+              <button
+                type="button"
+                onClick={controller.cancel}
+                aria-label={t('userInputCancel')}
+                title={t('userInputCancel')}
+                className="rounded-lg p-1 text-ds-faint transition hover:bg-ds-hover hover:text-ds-ink"
+              >
+                <X className="h-3.5 w-3.5" strokeWidth={2} />
+              </button>
+            </div>
+          </div>
+          <div className="mt-2 flex gap-1">
+            {controller.questions.map((question, i) => (
+              <span
+                key={question.id}
+                className={`h-[3px] flex-1 rounded-full transition ${
+                  controller.isAnswered(question.id) || i === index
+                    ? 'bg-accent'
+                    : 'bg-ds-border-muted'
+                }`}
+              />
+            ))}
+          </div>
+        </div>
+      ) : null}
+
+      {showHeader ? (
+        <div className="mb-1 text-[12px] font-semibold text-ds-muted">{currentQuestion.header}</div>
+      ) : null}
+
+      <p className="whitespace-pre-wrap break-words text-[14px] font-semibold leading-6 text-ds-ink [overflow-wrap:anywhere]">
+        {currentQuestion.question}
+      </p>
+
+      {hasOptions ? (
+        useRows ? (
+          <div className="mt-2.5 flex flex-col gap-1.5">
+            {options.map((option) => (
+              <OptionRow
+                key={option.label}
+                option={option}
+                selected={controller.isSelected(currentQuestion.id, option.label)}
+                onSelect={() => controller.chooseOption(currentQuestion, option)}
+              />
+            ))}
+          </div>
+        ) : (
+          <div className="mt-2.5 flex flex-wrap gap-2">
+            {options.map((option) => (
+              <OptionChip
+                key={option.label}
+                option={option}
+                selected={controller.isSelected(currentQuestion.id, option.label)}
+                onSelect={() => controller.chooseOption(currentQuestion, option)}
+              />
+            ))}
+          </div>
+        )
+      ) : (
+        <div className="mt-2.5 flex items-center gap-2 rounded-2xl border border-ds-border-muted bg-ds-card/70 px-3 py-2 text-[12.5px] text-ds-muted">
+          <CornerDownLeft className="h-3.5 w-3.5 shrink-0 text-accent" strokeWidth={1.9} />
+          <span className="min-w-0">{t('userInputPanelFreeformHint')}</span>
+        </div>
+      )}
+
+      {hasOptions ? (
+        <div className="mt-2.5 flex items-center gap-1.5 text-[11.5px] text-ds-faint">
+          <CornerDownLeft className="h-3 w-3 shrink-0" strokeWidth={1.9} />
+          <span className="min-w-0">{t('userInputPanelCustomHint')}</span>
+        </div>
+      ) : null}
+    </div>
+  )
+}
+
+function OptionChip({
+  option,
+  selected,
+  onSelect
+}: {
+  option: UserInputOption
+  selected: boolean
+  onSelect: () => void
+}): ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={onSelect}
+      title={option.description || undefined}
+      className={`inline-flex min-w-0 items-center gap-1.5 rounded-full border px-3 py-1.5 text-[13px] font-medium transition ${
+        selected
+          ? 'border-accent/45 bg-accent/12 text-ds-ink'
+          : 'border-ds-border-muted bg-ds-card/80 text-ds-muted hover:border-ds-border hover:bg-ds-card hover:text-ds-ink'
+      }`}
+    >
+      {selected ? <Check className="h-3 w-3 shrink-0 text-accent" strokeWidth={2.4} /> : null}
+      <span className="min-w-0 truncate">{option.label}</span>
+    </button>
+  )
+}
+
+function OptionRow({
+  option,
+  selected,
+  onSelect
+}: {
+  option: UserInputOption
+  selected: boolean
+  onSelect: () => void
+}): ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={onSelect}
+      className={`group flex min-w-0 items-start gap-2.5 rounded-[14px] border px-3 py-2 text-left transition ${
+        selected
+          ? 'border-accent/40 bg-accent/10 text-ds-ink ring-1 ring-accent/10'
+          : 'border-ds-border-muted bg-ds-card/80 text-ds-muted hover:border-ds-border hover:bg-ds-card hover:text-ds-ink'
+      }`}
+    >
+      <span
+        className={`mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-full border transition ${
+          selected ? 'border-accent bg-accent/10' : 'border-ds-border group-hover:border-ds-muted'
+        }`}
+      >
+        {selected ? <span className="h-2 w-2 rounded-full bg-accent" /> : null}
+      </span>
+      <span className="min-w-0">
+        <span className="block break-words text-[13px] font-semibold [overflow-wrap:anywhere]">
+          {option.label}
+        </span>
+        {option.description ? (
+          <span className="mt-0.5 block break-words text-[12px] leading-5 text-ds-faint [overflow-wrap:anywhere]">
+            {option.description}
+          </span>
+        ) : null}
+      </span>
+    </button>
+  )
+}
diff --git a/src/renderer/src/components/chat/GitBranchPicker.tsx b/src/renderer/src/components/chat/GitBranchPicker.tsx
index e26177447..2a590fcea 100644
--- a/src/renderer/src/components/chat/GitBranchPicker.tsx
+++ b/src/renderer/src/components/chat/GitBranchPicker.tsx
@@ -1,16 +1,35 @@
 import { useCallback, useEffect, useMemo, useRef, useState, type ReactElement } from 'react'
+import { createPortal } from 'react-dom'
 import { AlertCircle, Check, ChevronDown, GitBranch, Loader2, Plus, Search } from 'lucide-react'
 import { useTranslation } from 'react-i18next'
 import type { GitBranchesResult } from '@shared/git-branches'
 import { getProvider } from '../../agent/registry'
+import { middleEllipsize } from '../../lib/middle-ellipsize'
 import { markThreadWorktree, saveThreadWorktreeRegistry } from '../../lib/thread-worktree-registry'
 import { useChatStore } from '../../store/chat-store'
 import { rememberCodeWorkspaceRoots } from '../../store/chat-store-helpers'
 
+const BRANCH_ROW_LABEL_MAX_LENGTH = 42
+const BRANCH_TRIGGER_LABEL_MAX_LENGTH = 32
+const BRANCH_FOOTER_LABEL_MAX_LENGTH = 34
+
 type Props = {
   workspaceRoot: string
 }
 
+type BranchTooltip = {
+  text: string
+  x: number
+  y: number
+}
+
+function branchTooltipPosition(clientX: number, clientY: number): { x: number; y: number } {
+  const width = Math.min(544, Math.max(0, window.innerWidth - 32))
+  const x = Math.max(16, Math.min(clientX + 12, window.innerWidth - width - 16))
+  const y = Math.max(16, Math.min(clientY + 14, window.innerHeight - 96))
+  return { x, y }
+}
+
 export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
   const { t } = useTranslation('common')
   const root = workspaceRoot.trim()
@@ -20,6 +39,7 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
   const [loading, setLoading] = useState(false)
   const [actingBranch, setActingBranch] = useState<string | null>(null)
   const [error, setError] = useState<string | null>(null)
+  const [tooltip, setTooltip] = useState<BranchTooltip | null>(null)
   const wrapRef = useRef<HTMLDivElement | null>(null)
   const inputRef = useRef<HTMLInputElement | null>(null)
 
@@ -67,6 +87,10 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
     return () => window.removeEventListener('pointerdown', onPointerDown)
   }, [open])
 
+  useEffect(() => {
+    if (!open) setTooltip(null)
+  }, [open])
+
   const branches = useMemo(() => (result?.ok ? result.branches : []), [result])
   const filteredBranches = useMemo(() => {
     const q = query.trim().toLowerCase()
@@ -88,6 +112,28 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
   const canRunFooterAction = canCreate || canCheckoutWorktree
   const currentBranch = result?.ok ? result.currentBranch : null
   const label = currentBranch || (result?.ok ? t('gitDetached') : t('gitBranchUnavailable'))
+  const footerBranch = canCreate ? trimmedQuery : selectedWorktreeBranch
+  const footerBranchLabel = middleEllipsize(footerBranch, BRANCH_FOOTER_LABEL_MAX_LENGTH)
+  const footerActionLabel = canCreate
+    ? t('gitCreateNamedBranch', { branch: footerBranchLabel })
+    : selectedWorktreeBranch
+      ? t('gitCheckoutNamedBranchWorktree', { branch: footerBranchLabel })
+      : t('gitCreateBranch')
+  const footerActionTitle = canCreate
+    ? t('gitCreateNamedBranch', { branch: trimmedQuery })
+    : selectedWorktreeBranch
+      ? t('gitCheckoutNamedBranchWorktree', { branch: selectedWorktreeBranch })
+      : t('gitCreateBranch')
+  const showTooltip = useCallback((text: string, clientX: number, clientY: number): void => {
+    if (!text.trim()) return
+    setTooltip({ text, ...branchTooltipPosition(clientX, clientY) })
+  }, [])
+  const moveTooltip = useCallback((clientX: number, clientY: number): void => {
+    setTooltip((current) => current ? { ...current, ...branchTooltipPosition(clientX, clientY) } : current)
+  }, [])
+  const hideTooltip = useCallback((): void => {
+    setTooltip(null)
+  }, [])
 
   const moveActiveThreadToWorktree = async (record: {
     projectPath: string
@@ -175,10 +221,10 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
         type="button"
         className="flex h-8 max-w-[320px] min-w-0 items-center gap-2 rounded-lg px-2 text-[14px] font-medium text-ds-muted transition hover:bg-ds-hover hover:text-ds-ink"
         onClick={() => setOpen((v) => !v)}
-        title={t('gitBranch')}
+        aria-label={label}
       >
         <GitBranch className="h-4 w-4 shrink-0" strokeWidth={1.8} />
-        <span className="min-w-0 truncate">{label}</span>
+        <span className="min-w-0 truncate">{middleEllipsize(label, BRANCH_TRIGGER_LABEL_MAX_LENGTH)}</span>
         {loading ? (
           <Loader2 className="h-3.5 w-3.5 shrink-0 animate-spin text-ds-faint" strokeWidth={2} />
         ) : (
@@ -239,10 +285,17 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
                 className="flex w-full items-start gap-3 rounded-lg px-1 py-2.5 text-left text-ds-ink transition hover:bg-ds-hover"
                 onClick={() => void checkoutBranchWorktree(branch.name)}
                 disabled={actingBranch != null}
+                aria-label={branch.name}
+                onPointerEnter={(event) => showTooltip(branch.name, event.clientX, event.clientY)}
+                onPointerMove={(event) => moveTooltip(event.clientX, event.clientY)}
+                onPointerLeave={hideTooltip}
+                onPointerCancel={hideTooltip}
               >
                 <GitBranch className="mt-0.5 h-4 w-4 shrink-0 text-ds-faint" strokeWidth={1.8} />
                 <span className="min-w-0 flex-1">
-                  <span className="block truncate text-[15px] font-medium">{branch.name}</span>
+                  <span className="block truncate text-[15px] font-medium">
+                    {middleEllipsize(branch.name, BRANCH_ROW_LABEL_MAX_LENGTH)}
+                  </span>
                   {branch.current && result?.ok && result.dirtyCount > 0 ? (
                     <span className="mt-0.5 block text-[12px] text-ds-faint">
                       {t('gitDirtyFiles', { count: result.dirtyCount })}
@@ -267,7 +320,13 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
               type="button"
               disabled={!canRunFooterAction || actingBranch != null}
               className="flex w-full items-center gap-3 rounded-lg px-1 py-2 text-left text-[14px] font-medium text-ds-ink transition hover:bg-ds-hover disabled:cursor-not-allowed disabled:opacity-45 disabled:hover:bg-transparent"
+              aria-label={footerActionTitle}
+              onPointerEnter={(event) => showTooltip(footerActionTitle, event.clientX, event.clientY)}
+              onPointerMove={(event) => moveTooltip(event.clientX, event.clientY)}
+              onPointerLeave={hideTooltip}
+              onPointerCancel={hideTooltip}
               onClick={() => {
+                hideTooltip()
                 if (canCreate) {
                   void createBranch()
                 } else {
@@ -281,16 +340,21 @@ export function GitBranchPicker({ workspaceRoot }: Props): ReactElement | null {
                 <Plus className="h-4 w-4 shrink-0 text-ds-muted" strokeWidth={1.9} />
               )}
               <span className="min-w-0 truncate">
-                {canCreate
-                  ? t('gitCreateNamedBranch', { branch: trimmedQuery })
-                  : selectedWorktreeBranch
-                    ? t('gitCheckoutNamedBranchWorktree', { branch: selectedWorktreeBranch })
-                    : t('gitCreateBranch')}
+                {footerActionLabel}
               </span>
             </button>
           </div>
         </div>
       ) : null}
+      {tooltip ? createPortal(
+        <div
+          className="pointer-events-none fixed z-[9999] max-w-[min(34rem,calc(100vw-2rem))] break-all rounded-lg border border-ds-border bg-ds-elevated px-2.5 py-1.5 text-[12px] font-medium leading-5 text-ds-ink shadow-[0_14px_36px_rgba(15,23,42,0.22)]"
+          style={{ left: tooltip.x, top: tooltip.y }}
+        >
+          {tooltip.text}
+        </div>,
+        document.body
+      ) : null}
     </div>
   )
 }
diff --git a/src/renderer/src/components/chat/MessageTimeline.tool-summary.test.ts b/src/renderer/src/components/chat/MessageTimeline.tool-summary.test.ts
index 7059161be..241b6bbbb 100644
--- a/src/renderer/src/components/chat/MessageTimeline.tool-summary.test.ts
+++ b/src/renderer/src/components/chat/MessageTimeline.tool-summary.test.ts
@@ -515,7 +515,7 @@ describe('MessageTimeline Kun runtime metadata smoke', () => {
     expect(html).not.toContain('read detail should stay tucked away')
   })
 
-  it('renders request_user_input without options as a freeform answer field', () => {
+  it('renders a pending request_user_input as a read-only record pointing to the composer', () => {
     const inputBlock: ChatBlock = {
       kind: 'user_input',
       id: 'ui_freeform',
@@ -541,9 +541,11 @@ describe('MessageTimeline Kun runtime metadata smoke', () => {
     )
 
     expect(html).toContain('你更想去南方还是北方？')
-    expect(html).toContain('<textarea')
-    expect(html).not.toContain('userInputOther')
-    expect(html).not.toContain('其他')
+    // Answering moved to the composer-docked panel; the bubble is now the
+    // record, so it no longer hosts interactive inputs — only a pointer + cancel.
+    expect(html).not.toContain('<textarea')
+    expect(html).toContain('Answer below the input box')
+    expect(html).toContain('Cancel')
   })
 
   it('expands the live work timeline by default while keeping tool details collapsed', () => {
diff --git a/src/renderer/src/components/chat/MessageTimeline.tsx b/src/renderer/src/components/chat/MessageTimeline.tsx
index 27ba4603d..402ae0847 100644
--- a/src/renderer/src/components/chat/MessageTimeline.tsx
+++ b/src/renderer/src/components/chat/MessageTimeline.tsx
@@ -483,7 +483,11 @@ function MessageTurn({
   )
   const onlyCompactionProcess = processBlocks.length > 0 && workProcessBlocks.length === 0
   const hasProcessError = workProcessBlocks.some(processBlockHasError)
-  const workExpanded = hasProcessError || (workExpandedOverride ?? isProcessing)
+  // Only force the work process open (and lock it open) while the turn is still
+  // running. Once the turn completes — even if a tool call failed mid-turn — the
+  // panel should auto-collapse like a normal completed turn and stay user-toggleable.
+  const forceExpandForError = isProcessing && hasProcessError
+  const workExpanded = forceExpandForError || (workExpandedOverride ?? isProcessing)
   const reviewBlocks = useMemo(
     () => turn.blocks.filter((block) => block.kind === 'review'),
     [turn.blocks]
@@ -559,7 +563,7 @@ function MessageTurn({
             durationMs={durationMs}
             reasoningDurationMs={reasoningDurationMs}
             expanded={workExpanded}
-            collapsible={!hasProcessError}
+            collapsible={!forceExpandForError}
             onToggle={() => setWorkExpandedOverride((value) => !(value ?? isProcessing))}
           />
           {workExpanded && processSections.length > 0 ? (
diff --git a/src/renderer/src/components/chat/Sidebar.tsx b/src/renderer/src/components/chat/Sidebar.tsx
index 6535eed12..b1df9c040 100644
--- a/src/renderer/src/components/chat/Sidebar.tsx
+++ b/src/renderer/src/components/chat/Sidebar.tsx
@@ -37,7 +37,7 @@ import {
 type Props = {
   threads: NormalizedThread[]
   activeThreadId: string | null
-  activeView: 'chat' | 'write' | 'claw' | 'schedule' | 'workflow'
+  activeView: 'chat' | 'write' | 'claw' | 'schedule' | 'workflow' | 'subagents'
   connectPhoneSidebarOpen: boolean
   pluginsActive: boolean
   runtimeReady: boolean
@@ -46,6 +46,7 @@ type Props = {
   onThreadSearchChange: (query: string) => void
   onSelectThread: (id: string) => void
   onRenameThread: (id: string, title: string) => Promise<void>
+  onPinThread: (id: string, pinned: boolean) => Promise<void>
   onArchiveThread: (id: string) => Promise<void>
   onDeleteThread: (id: string) => Promise<void>
   onRestoreThread: (id: string) => Promise<void>
@@ -77,6 +78,7 @@ export function Sidebar({
   onThreadSearchChange,
   onSelectThread,
   onRenameThread,
+  onPinThread,
   onArchiveThread,
   onDeleteThread,
   onRestoreThread,
@@ -276,6 +278,7 @@ export function Sidebar({
           onOpenRequirementDraft={onOpenRequirementDraft}
           onSelectThread={onSelectThread}
           onRenameThread={onRenameThread}
+          onPinThread={onPinThread}
           onArchiveThread={onArchiveThread}
           onDeleteThread={onDeleteThread}
           onRestoreThread={onRestoreThread}
@@ -302,6 +305,7 @@ export function Sidebar({
         onOpenRequirementDraft={onOpenRequirementDraft}
         onSelectThread={onSelectThread}
         onRenameThread={onRenameThread}
+        onPinThread={onPinThread}
         onArchiveThread={onArchiveThread}
         onDeleteThread={onDeleteThread}
         onRestoreThread={onRestoreThread}
diff --git a/src/renderer/src/components/chat/SidebarProjectsSection.test.ts b/src/renderer/src/components/chat/SidebarProjectsSection.test.ts
index a75a9c8ec..da0fea08e 100644
--- a/src/renderer/src/components/chat/SidebarProjectsSection.test.ts
+++ b/src/renderer/src/components/chat/SidebarProjectsSection.test.ts
@@ -9,6 +9,7 @@ import {
   filterEmptySddAssistantThreadsFromSidebar,
   filterSddDraftHistoryItems,
   mergeSidebarWorkspaceGroupsWithDraftHistory,
+  sortSidebarThreads,
   SddDraftHistoryRows,
   ThreadRow,
   ThreadRenameDialog
@@ -33,6 +34,7 @@ function thread(overrides: Partial<NormalizedThread> & Pick<NormalizedThread, 'i
     ...(overrides.preview ? { preview: overrides.preview } : {}),
     ...(overrides.latestTurnId ? { latestTurnId: overrides.latestTurnId } : {}),
     ...(overrides.status ? { status: overrides.status } : {}),
+    ...(overrides.pinned !== undefined ? { pinned: overrides.pinned } : {}),
     ...(overrides.archived !== undefined ? { archived: overrides.archived } : {})
   }
 }
@@ -268,6 +270,29 @@ describe('SidebarProjectsSection groups', () => {
         .map((item) => item.id)
     ).toEqual(['thread-normal', 'thread-sdd-active-build'])
   })
+
+  it('sorts pinned threads before newer unpinned threads', () => {
+    const sorted = sortSidebarThreads([
+      thread({
+        id: 'recent',
+        workspace: '/tmp/app',
+        updatedAt: '2026-06-03T00:00:00.000Z'
+      }),
+      thread({
+        id: 'pinned-old',
+        workspace: '/tmp/app',
+        updatedAt: '2026-06-01T00:00:00.000Z',
+        pinned: true
+      }),
+      thread({
+        id: 'older',
+        workspace: '/tmp/app',
+        updatedAt: '2026-06-02T00:00:00.000Z'
+      })
+    ])
+
+    expect(sorted.map((item) => item.id)).toEqual(['pinned-old', 'recent', 'older'])
+  })
 })
 
 describe('ThreadRenameDialog', () => {
@@ -319,6 +344,10 @@ describe('ThreadRow', () => {
         showUnread: false,
         onSelect: vi.fn(),
         onContextMenu: vi.fn(),
+        onPreviewOpen: vi.fn(),
+        onPreviewMove: vi.fn(),
+        onPreviewClose: vi.fn(),
+        onPin: vi.fn(),
         onRename: vi.fn(),
         onArchive: vi.fn(),
         onDelete: vi.fn(),
@@ -341,6 +370,37 @@ describe('ThreadRow', () => {
     expect(actionsHtml).toContain('sidebarThreadDelete')
     expect(actionsHtml).not.toContain('Worktree feature/layout-fix')
   })
+
+  it('renders pinned state and an unpin action for pinned threads', () => {
+    const html = renderToStaticMarkup(
+      createElement(ThreadRow, {
+        thread: thread({
+          id: 'thr_pinned',
+          title: 'Pinned thread',
+          workspace: '/Users/zxy/project-a',
+          pinned: true
+        }),
+        active: false,
+        deleting: false,
+        locale: 'en-US',
+        showRunning: false,
+        showUnread: false,
+        onSelect: vi.fn(),
+        onContextMenu: vi.fn(),
+        onPreviewOpen: vi.fn(),
+        onPreviewMove: vi.fn(),
+        onPreviewClose: vi.fn(),
+        onPin: vi.fn(),
+        onRename: vi.fn(),
+        onArchive: vi.fn(),
+        onDelete: vi.fn(),
+        onRestore: vi.fn()
+      })
+    )
+
+    expect(html).toContain('sidebarThreadPinned')
+    expect(html).toContain('sidebarThreadUnpin')
+  })
 })
 
 describe('SddDraftHistoryRows', () => {
diff --git a/src/renderer/src/components/chat/SidebarProjectsSection.tsx b/src/renderer/src/components/chat/SidebarProjectsSection.tsx
index 027f210a8..01bdb41bb 100644
--- a/src/renderer/src/components/chat/SidebarProjectsSection.tsx
+++ b/src/renderer/src/components/chat/SidebarProjectsSection.tsx
@@ -6,19 +6,25 @@ import {
   ChevronDown,
   ChevronRight,
   ClipboardList,
+  ExternalLink,
   Folder,
   FolderPlus,
   FolderOpen,
   GitBranch,
   Loader2,
   PencilLine,
+  Pin,
+  PinOff,
   Plus,
   RotateCcw,
+  ScrollText,
   Search,
-  Trash2
+  Trash2,
+  X
 } from 'lucide-react'
 import type { NormalizedThread } from '../../agent/types'
-import { confirmDialog } from '../../lib/confirm-dialog'
+import { rendererRuntimeClient } from '../../agent/runtime-client'
+import { useChatStore } from '../../store/chat-store'
 import { formatRelativeTime } from '../../lib/format-relative-time'
 import { workspaceLabelFromPath } from '../../lib/workspace-label'
 import { deleteSddDraft } from '../../sdd/sdd-draft-actions'
@@ -58,6 +64,7 @@ type SidebarProjectsSectionProps = {
   onOpenRequirementDraft: (draft: SddDraft) => void
   onSelectThread: (threadId: string) => void
   onRenameThread: (threadId: string, title: string) => Promise<void>
+  onPinThread: (threadId: string, pinned: boolean) => Promise<void>
   onArchiveThread: (threadId: string) => Promise<void>
   onDeleteThread: (threadId: string) => Promise<void>
   onRestoreThread: (threadId: string) => Promise<void>
@@ -71,10 +78,34 @@ type SidebarThreadWorktrees = Record<string, SidebarThreadWorktreeRecord>
 
 type ThreadContextMenuState = {
   thread: NormalizedThread
+  worktreeRecord?: SidebarThreadWorktreeRecord
+  x: number
+  y: number
+}
+
+type WorkspaceContextMenuState = {
+  workspacePath: string
+  x: number
+  y: number
+}
+
+type ThreadPreviewState = {
+  thread: NormalizedThread
+  worktreeRecord?: SidebarThreadWorktreeRecord
   x: number
   y: number
 }
 
+type SidebarActionDialogState = {
+  title: string
+  description: string
+  detail: string
+  confirmLabel: string
+  danger?: boolean
+  submitting: boolean
+  onConfirm: () => Promise<void>
+}
+
 export type RenameThreadDialogState = {
   thread: NormalizedThread
   value: string
@@ -314,6 +345,14 @@ export function filterEmptySddAssistantThreadsFromSidebar(
   )
 }
 
+export function sortSidebarThreads(threads: NormalizedThread[]): NormalizedThread[] {
+  return [...threads].sort((a, b) => {
+    if (a.pinned === true && b.pinned !== true) return -1
+    if (b.pinned === true && a.pinned !== true) return 1
+    return Date.parse(b.updatedAt) - Date.parse(a.updatedAt)
+  })
+}
+
 function sddDraftHistoryForWorkspace(
   draftHistoryByWorkspace: Record<string, SddDraftHistoryItem[]>,
   workspacePath: string
@@ -347,6 +386,7 @@ export function SidebarProjectsSection({
   onOpenRequirementDraft,
   onSelectThread,
   onRenameThread,
+  onPinThread,
   onArchiveThread,
   onDeleteThread,
   onRestoreThread,
@@ -361,6 +401,9 @@ export function SidebarProjectsSection({
   const [draftHistoryRefreshVersion, setDraftHistoryRefreshVersion] = useState(0)
   const [searchOpen, setSearchOpen] = useState(false)
   const [threadContextMenu, setThreadContextMenu] = useState<ThreadContextMenuState | null>(null)
+  const [workspaceContextMenu, setWorkspaceContextMenu] = useState<WorkspaceContextMenuState | null>(null)
+  const [threadPreview, setThreadPreview] = useState<ThreadPreviewState | null>(null)
+  const [actionDialog, setActionDialog] = useState<SidebarActionDialogState | null>(null)
   const [renameThreadDialog, setRenameThreadDialog] = useState<RenameThreadDialogState | null>(null)
   const [draftHistoryByWorkspace, setDraftHistoryByWorkspace] = useState<Record<string, SddDraftHistoryItem[]>>({})
   const [threadWorktrees, setThreadWorktrees] = useState<SidebarThreadWorktrees>(() => readThreadWorktreeRegistry().worktrees)
@@ -448,8 +491,11 @@ export function SidebarProjectsSection({
   }, [draftHistoryRefreshVersion, workspaceHistoryKey])
 
   useEffect(() => {
-    if (!threadContextMenu) return
-    const close = (): void => setThreadContextMenu(null)
+    if (!threadContextMenu && !workspaceContextMenu) return
+    const close = (): void => {
+      setThreadContextMenu(null)
+      setWorkspaceContextMenu(null)
+    }
     const onKeyDown = (event: KeyboardEvent): void => {
       if (event.key === 'Escape') close()
     }
@@ -461,7 +507,7 @@ export function SidebarProjectsSection({
       window.removeEventListener('scroll', close, true)
       window.removeEventListener('keydown', onKeyDown)
     }
-  }, [threadContextMenu])
+  }, [threadContextMenu, workspaceContextMenu])
 
   const toggleAllGroups = (): void => {
     if (displayGroups.length === 0) return
@@ -472,14 +518,93 @@ export function SidebarProjectsSection({
     setCollapsed(Object.fromEntries(displayGroups.map(([workspacePath]) => [workspacePath, true])))
   }
 
+  const openActionDialog = (dialog: Omit<SidebarActionDialogState, 'submitting'>): void => {
+    setThreadPreview(null)
+    setActionDialog({ ...dialog, submitting: false })
+  }
+
+  const closeActionDialog = (): void => {
+    setActionDialog((current) => current?.submitting ? current : null)
+  }
+
+  const submitActionDialog = async (): Promise<void> => {
+    const dialog = actionDialog
+    if (!dialog || dialog.submitting) return
+    setActionDialog((current) => current ? { ...current, submitting: true } : current)
+    try {
+      await dialog.onConfirm()
+      setActionDialog(null)
+    } catch {
+      setActionDialog((current) => current ? { ...current, submitting: false } : current)
+    }
+  }
+
   const handleDeleteThread = async (thread: NormalizedThread): Promise<void> => {
     const threadId = thread.id.trim()
     if (!threadId || deletingThreadIds[threadId]) return
-    const confirmMessage = t('sidebarThreadDeleteConfirm', { title: thread.title })
-    if (!(await confirmDialog(confirmMessage))) return
+    openActionDialog({
+      title: t('sidebarThreadDeleteDialogTitle', { title: thread.title }),
+      description: t('sidebarThreadDeleteDialogDescription'),
+      detail: t('sidebarThreadDeleteDialogDetail'),
+      confirmLabel: t('sidebarThreadDeleteConfirmButton'),
+      danger: true,
+      onConfirm: async () => {
+        setDeletingThreadIds((prev) => ({ ...prev, [threadId]: true }))
+        try {
+          await onDeleteThread(threadId)
+        } finally {
+          setDeletingThreadIds((prev) => {
+            const next = { ...prev }
+            delete next[threadId]
+            return next
+          })
+        }
+      }
+    })
+  }
+
+  const handleArchiveThread = async (thread: NormalizedThread): Promise<void> => {
+    const threadId = thread.id.trim()
+    if (!threadId || deletingThreadIds[threadId]) return
+    openActionDialog({
+      title: t('sidebarThreadArchiveDialogTitle', { title: thread.title }),
+      description: t('sidebarThreadArchiveDialogDescription'),
+      detail: t('sidebarThreadArchiveDialogDetail'),
+      confirmLabel: t('sidebarThreadArchiveConfirmButton'),
+      onConfirm: async () => {
+        setDeletingThreadIds((prev) => ({ ...prev, [threadId]: true }))
+        try {
+          await onArchiveThread(threadId)
+        } finally {
+          setDeletingThreadIds((prev) => {
+            const next = { ...prev }
+            delete next[threadId]
+            return next
+          })
+        }
+      }
+    })
+  }
+
+  const handleSummarizeThread = async (thread: NormalizedThread): Promise<void> => {
+    const threadId = thread.id.trim()
+    if (!threadId || deletingThreadIds[threadId]) return
     setDeletingThreadIds((prev) => ({ ...prev, [threadId]: true }))
     try {
-      await onDeleteThread(threadId)
+      const res = await rendererRuntimeClient.runtimeRequest(
+        `/v1/threads/${encodeURIComponent(threadId)}/summarize`,
+        'POST',
+        '{}'
+      )
+      if (!res.ok) {
+        useChatStore.getState().setError(t('summarizeFailed'))
+        return
+      }
+      // The summary now lives on the thread; refresh the list so the new
+      // subtitle/hover text is picked up from the thread-list projection.
+      await useChatStore.getState().refreshThreads()
+    } catch {
+      useChatStore.getState().setError(t('summarizeFailed'))
     } finally {
       setDeletingThreadIds((prev) => {
         const next = { ...prev }
@@ -489,14 +614,12 @@ export function SidebarProjectsSection({
     }
   }
 
-  const handleArchiveThread = async (thread: NormalizedThread): Promise<void> => {
+  const handleRestoreThread = async (thread: NormalizedThread): Promise<void> => {
     const threadId = thread.id.trim()
     if (!threadId || deletingThreadIds[threadId]) return
-    const confirmMessage = t('sidebarThreadArchiveConfirm', { title: thread.title })
-    if (!(await confirmDialog(confirmMessage))) return
     setDeletingThreadIds((prev) => ({ ...prev, [threadId]: true }))
     try {
-      await onArchiveThread(threadId)
+      await onRestoreThread(threadId)
     } finally {
       setDeletingThreadIds((prev) => {
         const next = { ...prev }
@@ -506,12 +629,12 @@ export function SidebarProjectsSection({
     }
   }
 
-  const handleRestoreThread = async (thread: NormalizedThread): Promise<void> => {
+  const handlePinThread = async (thread: NormalizedThread, pinned: boolean): Promise<void> => {
     const threadId = thread.id.trim()
     if (!threadId || deletingThreadIds[threadId]) return
     setDeletingThreadIds((prev) => ({ ...prev, [threadId]: true }))
     try {
-      await onRestoreThread(threadId)
+      await onPinThread(threadId, pinned)
     } finally {
       setDeletingThreadIds((prev) => {
         const next = { ...prev }
@@ -573,60 +696,117 @@ export function SidebarProjectsSection({
   ): void => {
     event.preventDefault()
     event.stopPropagation()
+    const worktreeRecord = worktreeRecordForSidebarThread(thread, threadWorktrees)
+    setThreadPreview(null)
+    setWorkspaceContextMenu(null)
     setThreadContextMenu({
       thread,
+      ...(worktreeRecord ? { worktreeRecord } : {}),
       x: Math.min(event.clientX, window.innerWidth - 180),
-      y: Math.min(event.clientY, window.innerHeight - 150)
+      y: Math.min(event.clientY, window.innerHeight - 220)
+    })
+  }
+
+  const openWorkspaceContextMenu = (
+    event: ReactMouseEvent<HTMLDivElement>,
+    workspacePath: string
+  ): void => {
+    event.preventDefault()
+    event.stopPropagation()
+    setThreadPreview(null)
+    setThreadContextMenu(null)
+    setWorkspaceContextMenu({
+      workspacePath,
+      x: Math.min(event.clientX, window.innerWidth - 220),
+      y: Math.min(event.clientY, window.innerHeight - 170)
     })
   }
 
+  const openThreadPreview = (
+    event: ReactMouseEvent<HTMLDivElement>,
+    thread: NormalizedThread,
+    worktreeRecord?: SidebarThreadWorktreeRecord
+  ): void => {
+    if (threadContextMenu || workspaceContextMenu || actionDialog || renameThreadDialog) return
+    setThreadPreview({
+      thread,
+      ...(worktreeRecord ? { worktreeRecord } : {}),
+      x: Math.min(event.clientX + 14, Math.max(16, window.innerWidth - 340)),
+      y: Math.min(event.clientY + 10, Math.max(16, window.innerHeight - 180))
+    })
+  }
+
+  const closeThreadPreview = (): void => {
+    setThreadPreview(null)
+  }
+
+  const openWorkspaceInSystem = async (workspacePath: string): Promise<void> => {
+    if (typeof window === 'undefined' || typeof window.kunGui?.openEditorPath !== 'function') return
+    await window.kunGui.openEditorPath({
+      path: workspacePath,
+      workspaceRoot: workspacePath,
+      editorId: 'system'
+    }).catch(() => undefined)
+  }
+
   const handleRemoveWorkspace = async (workspacePath: string): Promise<void> => {
-    const confirmMessage = t('sidebarWorkspaceRemoveConfirm', { path: workspacePath })
-    if (!(await confirmDialog(confirmMessage))) return
-    await onRemoveWorkspace(workspacePath)
+    openActionDialog({
+      title: t('sidebarWorkspaceRemoveDialogTitle', { name: workspaceLabelFromPath(workspacePath) }),
+      description: t('sidebarWorkspaceRemoveDialogDescription'),
+      detail: t('sidebarWorkspaceRemoveDialogDetail'),
+      confirmLabel: t('sidebarWorkspaceRemoveConfirmButton'),
+      danger: true,
+      onConfirm: () => onRemoveWorkspace(workspacePath)
+    })
   }
 
   const handleDeleteRequirementDraft = async (draft: SddDraftHistoryItem): Promise<void> => {
     const draftId = draft.id.trim()
     if (!draftId || deletingDraftIds[draftId]) return
     const workspaceKey = draft.workspaceRoot
-    const confirmMessage = t('sddDraftHistoryDeleteConfirm', { title: draft.title })
-    if (!(await confirmDialog(confirmMessage))) return
-
-    setDeletingDraftIds((prev) => ({ ...prev, [draftId]: true }))
-    setDraftHistoryErrors((prev) => {
-      const next = { ...prev }
-      delete next[workspaceKey]
-      return next
-    })
-    try {
-      const result = await deleteSddDraft(draft)
-      if (!result.ok) {
-        setDraftHistoryErrors((prev) => ({
-          ...prev,
-          [workspaceKey]: t('sddDraftHistoryDeleteFailed', { message: result.message })
-        }))
-        return
+    openActionDialog({
+      title: t('sddDraftHistoryDeleteDialogTitle', { title: draft.title }),
+      description: t('sddDraftHistoryDeleteDialogDescription'),
+      detail: t('sddDraftHistoryDeleteDialogDetail'),
+      confirmLabel: t('sddDraftHistoryDelete'),
+      danger: true,
+      onConfirm: async () => {
+        setDeletingDraftIds((prev) => ({ ...prev, [draftId]: true }))
+        setDraftHistoryErrors((prev) => {
+          const next = { ...prev }
+          delete next[workspaceKey]
+          return next
+        })
+        try {
+          const result = await deleteSddDraft(draft)
+          if (!result.ok) {
+            setDraftHistoryErrors((prev) => ({
+              ...prev,
+              [workspaceKey]: t('sddDraftHistoryDeleteFailed', { message: result.message })
+            }))
+            return
+          }
+          setDraftHistoryByWorkspace((current) => {
+            const next = Object.fromEntries(
+              Object.entries(current)
+                .map(([workspacePath, items]) => [
+                  workspacePath,
+                  items.filter((item) => item.id !== draftId)
+                ] as const)
+                .filter(([, items]) => items.length > 0)
+            )
+            return next
+          })
+          setDraftHistoryRefreshVersion((version) => version + 1)
+        } finally {
+          setDeletingDraftIds((prev) => {
+            const next = { ...prev }
+            delete next[draftId]
+            return next
+          })
+        }
       }
-      setDraftHistoryByWorkspace((current) => {
-        const next = Object.fromEntries(
-          Object.entries(current)
-            .map(([workspacePath, items]) => [
-              workspacePath,
-              items.filter((item) => item.id !== draftId)
-            ] as const)
-            .filter(([, items]) => items.length > 0)
-        )
-        return next
-      })
-      setDraftHistoryRefreshVersion((version) => version + 1)
-    } finally {
-      setDeletingDraftIds((prev) => {
-        const next = { ...prev }
-        delete next[draftId]
-        return next
-      })
-    }
+    })
   }
 
   return (
@@ -693,8 +873,8 @@ export function SidebarProjectsSection({
           const workspaceContext = workspaceContextLabel(workspacePath, folderName)
           const isCollapsed = collapsed[workspacePath] === true
           const draftHistory = sddDraftHistoryForWorkspace(filteredDraftHistoryByWorkspace, workspacePath)
-          const sortedThreads = filterEmptySddAssistantThreadsFromSidebar(list, draftHistory).sort(
-            (a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt)
+          const sortedThreads = sortSidebarThreads(
+            filterEmptySddAssistantThreadsFromSidebar(list, draftHistory)
           )
           const workspaceExpanded = expandedWorkspaces[workspacePath] === true
           const hasOverflow = sortedThreads.length > 5
@@ -708,6 +888,7 @@ export function SidebarProjectsSection({
                 onClick={() =>
                   setCollapsed((current) => ({ ...current, [workspacePath]: !current[workspacePath] }))
                 }
+                onContextMenu={(event) => openWorkspaceContextMenu(event, workspacePath)}
                 className="min-h-[36px] text-[13.5px]"
                 buttonClassName="items-center gap-2 px-2.5 py-2"
                 actionsVisibility="hidden"
@@ -799,6 +980,10 @@ export function SidebarProjectsSection({
                         }
                         onSelect={() => onSelectThread(thread.id)}
                         onContextMenu={(event) => openThreadContextMenu(event, thread)}
+                        onPreviewOpen={(event, worktreeRecord) => openThreadPreview(event, thread, worktreeRecord)}
+                        onPreviewMove={(event, worktreeRecord) => openThreadPreview(event, thread, worktreeRecord)}
+                        onPreviewClose={closeThreadPreview}
+                        onPin={() => void handlePinThread(thread, thread.pinned !== true)}
                         onRename={() => openRenameThreadDialog(thread)}
                         onArchive={() => void handleArchiveThread(thread)}
                         onDelete={() => void handleDeleteThread(thread)}
@@ -837,7 +1022,9 @@ export function SidebarProjectsSection({
           state={threadContextMenu}
           busy={deletingThreadIds[threadContextMenu.thread.id] === true}
           onClose={() => setThreadContextMenu(null)}
+          onPin={() => void handlePinThread(threadContextMenu.thread, threadContextMenu.thread.pinned !== true)}
           onRename={() => openRenameThreadDialog(threadContextMenu.thread)}
+          onSummarize={() => void handleSummarizeThread(threadContextMenu.thread)}
           onArchive={() => void handleArchiveThread(threadContextMenu.thread)}
           onDelete={() => void handleDeleteThread(threadContextMenu.thread)}
           onRestore={() => void handleRestoreThread(threadContextMenu.thread)}
@@ -845,6 +1032,25 @@ export function SidebarProjectsSection({
         />
       ) : null}
 
+      {workspaceContextMenu ? (
+        <WorkspaceContextMenu
+          state={workspaceContextMenu}
+          onClose={() => setWorkspaceContextMenu(null)}
+          onNewThread={() => onCreateThreadInWorkspace(workspaceContextMenu.workspacePath)}
+          onOpenInSystem={() => void openWorkspaceInSystem(workspaceContextMenu.workspacePath)}
+          onRemove={() => void handleRemoveWorkspace(workspaceContextMenu.workspacePath)}
+          t={t}
+        />
+      ) : null}
+
+      {threadPreview ? (
+        <ThreadPreviewCard
+          state={threadPreview}
+          locale={locale}
+          t={t}
+        />
+      ) : null}
+
       {renameThreadDialog ? (
         <ThreadRenameDialog
           state={renameThreadDialog}
@@ -856,6 +1062,15 @@ export function SidebarProjectsSection({
           t={t}
         />
       ) : null}
+
+      {actionDialog ? (
+        <SidebarActionDialog
+          state={actionDialog}
+          onClose={closeActionDialog}
+          onConfirm={() => void submitActionDialog()}
+          t={t}
+        />
+      ) : null}
     </div>
   )
 }
@@ -870,6 +1085,10 @@ type ThreadRowProps = {
   showUnread: boolean
   onSelect: () => void
   onContextMenu: (event: ReactMouseEvent<HTMLDivElement>) => void
+  onPreviewOpen: (event: ReactMouseEvent<HTMLDivElement>, worktreeRecord?: SidebarThreadWorktreeRecord) => void
+  onPreviewMove: (event: ReactMouseEvent<HTMLDivElement>, worktreeRecord?: SidebarThreadWorktreeRecord) => void
+  onPreviewClose: () => void
+  onPin: () => void
   onRename: () => void
   onArchive: () => void
   onDelete: () => void
@@ -1014,6 +1233,10 @@ export function ThreadRow({
   showUnread,
   onSelect,
   onContextMenu,
+  onPreviewOpen,
+  onPreviewMove,
+  onPreviewClose,
+  onPin,
   onRename,
   onArchive,
   onDelete,
@@ -1022,6 +1245,7 @@ export function ThreadRow({
   const { t } = useTranslation('common')
   const showUnreadDot = showUnread && !showRunning
   const archived = thread.archived === true
+  const pinned = thread.pinned === true
   const worktreeLabel = worktreeRecord
     ? t('sidebarThreadWorktree', { branch: worktreeRecord.branch || 'worktree' })
     : ''
@@ -1029,10 +1253,11 @@ export function ThreadRow({
   const ariaLabel = [
     thread.title,
     updatedLabel,
+    pinned ? t('sidebarThreadPinned') : '',
     showRunning ? t('sidebarThreadRunning') : '',
     showUnreadDot ? t('sidebarThreadUnread') : '',
     worktreeLabel
-  ].filter(Boolean).join(' — ')
+  ].filter(Boolean).join(' - ')
 
   return (
     <SidebarTreeRow
@@ -1041,6 +1266,23 @@ export function ThreadRow({
       actionsLayout="overlay"
       actions={
         <>
+          {!archived ? (
+            <SidebarIconButton
+              onClick={onPin}
+              disabled={deleting}
+              tone="accent"
+              title={pinned ? t('sidebarThreadUnpin') : t('sidebarThreadPin')}
+              ariaLabel={pinned ? t('sidebarThreadUnpin') : t('sidebarThreadPin')}
+              active={pinned}
+              stopPropagation
+            >
+              {pinned ? (
+                <PinOff className="h-3 w-3" strokeWidth={1.9} />
+              ) : (
+                <Pin className="h-3 w-3" strokeWidth={1.9} />
+              )}
+            </SidebarIconButton>
+          ) : null}
           <SidebarIconButton
             onClick={archived ? onRestore : onArchive}
             disabled={deleting}
@@ -1073,11 +1315,17 @@ export function ThreadRow({
       buttonClassName="items-center gap-2 px-2.5 py-1.5"
       disabled={deleting}
       ariaLabel={ariaLabel}
-      title={[thread.title, worktreeLabel].filter(Boolean).join('\n')}
+      title={[thread.title, thread.summary?.trim(), worktreeLabel].filter(Boolean).join('\n')}
       onClick={onSelect}
       onContextMenu={onContextMenu}
+      onMouseEnter={(event) => onPreviewOpen(event, worktreeRecord)}
+      onMouseMove={(event) => onPreviewMove(event, worktreeRecord)}
+      onMouseLeave={onPreviewClose}
     >
       <span className="flex min-w-0 flex-1 items-center gap-1.5">
+        {pinned ? (
+          <Pin className="h-3.5 w-3.5 shrink-0 text-accent" strokeWidth={1.9} />
+        ) : null}
         {worktreeRecord ? (
           <span
             className="inline-grid h-5 w-5 shrink-0 place-items-center rounded-full border border-ds-border-muted bg-ds-card/80 text-ds-muted"
@@ -1194,7 +1442,9 @@ function ThreadContextMenu({
   state,
   busy,
   onClose,
+  onPin,
   onRename,
+  onSummarize,
   onArchive,
   onDelete,
   onRestore,
@@ -1203,13 +1453,16 @@ function ThreadContextMenu({
   state: ThreadContextMenuState
   busy: boolean
   onClose: () => void
+  onPin: () => void
   onRename: () => void
+  onSummarize: () => void
   onArchive: () => void
   onDelete: () => void
   onRestore: () => void
   t: (k: string, opts?: Record<string, unknown>) => string
 }): ReactElement {
   const archived = state.thread.archived === true
+  const pinned = state.thread.pinned === true
   const run = (action: () => void): void => {
     onClose()
     action()
@@ -1219,16 +1472,29 @@ function ThreadContextMenu({
     <div
       role="menu"
       aria-label={state.thread.title}
-      className="ds-thread-context-menu ds-no-drag fixed z-50 min-w-[168px] rounded-lg border border-ds-border bg-ds-card/98 p-1 text-[13px] text-ds-ink shadow-[0_16px_42px_rgba(20,47,95,0.16)] backdrop-blur-xl dark:bg-ds-card"
+      className="ds-thread-context-menu ds-no-drag fixed z-50 min-w-[210px] rounded-[16px] border border-ds-border bg-ds-card/95 p-1.5 text-[13px] text-ds-ink shadow-[0_18px_52px_rgba(20,47,95,0.18)] backdrop-blur-xl dark:bg-ds-card"
       style={{ left: state.x, top: state.y }}
       onPointerDown={(event) => event.stopPropagation()}
     >
+      <ThreadContextMenuItem
+        icon={pinned ? <PinOff className="h-3.5 w-3.5" strokeWidth={1.9} /> : <Pin className="h-3.5 w-3.5" strokeWidth={1.9} />}
+        label={pinned ? t('sidebarThreadUnpin') : t('sidebarThreadPin')}
+        disabled={busy || archived}
+        onClick={() => run(onPin)}
+      />
+      <div className="my-1 h-px bg-ds-border-muted" />
       <ThreadContextMenuItem
         icon={<PencilLine className="h-3.5 w-3.5" strokeWidth={1.9} />}
         label={t('sidebarThreadRename')}
         disabled={busy}
         onClick={() => run(onRename)}
       />
+      <ThreadContextMenuItem
+        icon={<ScrollText className="h-3.5 w-3.5" strokeWidth={1.9} />}
+        label={t('summarizeSession')}
+        disabled={busy}
+        onClick={() => run(onSummarize)}
+      />
       <ThreadContextMenuItem
         icon={
           archived
@@ -1251,6 +1517,205 @@ function ThreadContextMenu({
   )
 }
 
+function WorkspaceContextMenu({
+  state,
+  onClose,
+  onNewThread,
+  onOpenInSystem,
+  onRemove,
+  t
+}: {
+  state: WorkspaceContextMenuState
+  onClose: () => void
+  onNewThread: () => void
+  onOpenInSystem: () => void
+  onRemove: () => void
+  t: (k: string, opts?: Record<string, unknown>) => string
+}): ReactElement {
+  const run = (action: () => void): void => {
+    onClose()
+    action()
+  }
+
+  return (
+    <div
+      role="menu"
+      aria-label={state.workspacePath}
+      className="ds-workspace-context-menu ds-no-drag fixed z-50 min-w-[230px] rounded-[16px] border border-ds-border bg-ds-card/95 p-1.5 text-[13px] text-ds-ink shadow-[0_18px_52px_rgba(20,47,95,0.18)] backdrop-blur-xl dark:bg-ds-card"
+      style={{ left: state.x, top: state.y }}
+      onPointerDown={(event) => event.stopPropagation()}
+    >
+      <ThreadContextMenuItem
+        icon={<Plus className="h-3.5 w-3.5" strokeWidth={1.9} />}
+        label={t('sidebarWorkspaceNewThread')}
+        disabled={false}
+        onClick={() => run(onNewThread)}
+      />
+      <ThreadContextMenuItem
+        icon={<ExternalLink className="h-3.5 w-3.5" strokeWidth={1.9} />}
+        label={t('sidebarWorkspaceOpenInSystem')}
+        disabled={false}
+        onClick={() => run(onOpenInSystem)}
+      />
+      <div className="my-1 h-px bg-ds-border-muted" />
+      <ThreadContextMenuItem
+        icon={<Trash2 className="h-3.5 w-3.5" strokeWidth={1.9} />}
+        label={t('sidebarWorkspaceRemove')}
+        disabled={false}
+        danger
+        onClick={() => run(onRemove)}
+      />
+    </div>
+  )
+}
+
+function ThreadPreviewCard({
+  state,
+  locale,
+  t
+}: {
+  state: ThreadPreviewState
+  locale: string
+  t: (k: string, opts?: Record<string, unknown>) => string
+}): ReactElement {
+  const branch = state.worktreeRecord?.branch?.trim() ?? ''
+  const workspace = sidebarWorkspacePathForThread(
+    state.thread,
+    state.worktreeRecord ? { [state.thread.id]: state.worktreeRecord } : {}
+  )
+  const updatedLabel = formatRelativeTime(state.thread.updatedAt, locale)
+  const preview = state.thread.preview?.trim()
+  const summary = state.thread.summary?.trim()
+
+  return (
+    <div
+      role="tooltip"
+      className="ds-no-drag pointer-events-none fixed z-40 w-[320px] rounded-[18px] border border-ds-border bg-ds-card/95 p-3 text-[13px] text-ds-ink shadow-[0_18px_54px_rgba(20,47,95,0.18)] backdrop-blur-xl dark:bg-ds-card/95"
+      style={{ left: state.x, top: state.y }}
+    >
+      <div className="flex items-start gap-2">
+        {state.thread.pinned === true ? (
+          <Pin className="mt-0.5 h-3.5 w-3.5 shrink-0 text-accent" strokeWidth={1.9} />
+        ) : null}
+        <div className="min-w-0 flex-1">
+          <div className="line-clamp-2 text-[14px] font-semibold leading-5 text-ds-ink">
+            {state.thread.title}
+          </div>
+          <div className="mt-2 flex items-center gap-1.5 text-ds-muted">
+            <Folder className="h-3.5 w-3.5 shrink-0" strokeWidth={1.75} />
+            <span className="min-w-0 truncate">{workspaceLabelFromPath(workspace || state.thread.workspace || '')}</span>
+          </div>
+          {branch ? (
+            <div className="mt-1.5 flex items-center gap-1.5 text-ds-muted">
+              <GitBranch className="h-3.5 w-3.5 shrink-0" strokeWidth={1.75} />
+              <span className="min-w-0 truncate">{branch}</span>
+            </div>
+          ) : null}
+          <div className="mt-1.5 text-[12px] text-ds-faint">
+            {t('sidebarThreadPreviewUpdated', { time: updatedLabel })}
+          </div>
+          {summary ? (
+            <p className="mt-2 line-clamp-4 text-[12.5px] leading-5 text-ds-ink/90">
+              {summary}
+            </p>
+          ) : null}
+          {preview ? (
+            <p className="mt-2 line-clamp-3 text-[12.5px] leading-5 text-ds-muted">
+              {preview}
+            </p>
+          ) : (
+            <p className="mt-2 text-[12.5px] leading-5 text-ds-faint">
+              {t('sidebarThreadPreviewEmpty')}
+            </p>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function SidebarActionDialog({
+  state,
+  onClose,
+  onConfirm,
+  t
+}: {
+  state: SidebarActionDialogState
+  onClose: () => void
+  onConfirm: () => void
+  t: (k: string, opts?: Record<string, unknown>) => string
+}): ReactElement {
+  useEffect(() => {
+    if (state.submitting) return
+    const onKeyDown = (event: KeyboardEvent): void => {
+      if (event.key === 'Escape') onClose()
+    }
+    window.addEventListener('keydown', onKeyDown)
+    return () => window.removeEventListener('keydown', onKeyDown)
+  }, [onClose, state.submitting])
+
+  return (
+    <div
+      role="dialog"
+      aria-modal="true"
+      aria-labelledby="sidebar-action-dialog-title"
+      className="ds-no-drag fixed inset-0 z-[90] flex items-end justify-center bg-slate-950/12 px-4 pb-10 backdrop-blur-[2px] dark:bg-black/30 sm:items-center sm:pb-0"
+      onMouseDown={onClose}
+    >
+      <div
+        onMouseDown={(event) => event.stopPropagation()}
+        className="w-full max-w-[520px] rounded-[26px] border border-ds-border bg-ds-card/96 p-6 shadow-[0_26px_82px_rgba(20,47,95,0.24)] backdrop-blur-xl dark:bg-ds-card"
+      >
+        <div className="flex items-start justify-between gap-4">
+          <div className="min-w-0">
+            <h2
+              id="sidebar-action-dialog-title"
+              className="text-[22px] font-semibold tracking-[-0.04em] text-ds-ink"
+            >
+              {state.title}
+            </h2>
+            <p className="mt-2 text-[14px] leading-6 text-ds-muted">{state.description}</p>
+          </div>
+          <button
+            type="button"
+            disabled={state.submitting}
+            onClick={onClose}
+            className="grid h-8 w-8 shrink-0 place-items-center rounded-full text-ds-faint transition hover:bg-[var(--ds-sidebar-row-hover)] hover:text-ds-ink disabled:cursor-wait disabled:opacity-50"
+            aria-label={t('cancel')}
+          >
+            <X className="h-4 w-4" strokeWidth={1.9} />
+          </button>
+        </div>
+        <p className="mt-4 rounded-2xl border border-ds-border-muted bg-ds-main/55 px-3.5 py-3 text-[13px] leading-6 text-ds-muted">
+          {state.detail}
+        </p>
+        <div className="mt-5 flex justify-end gap-2">
+          <button
+            type="button"
+            disabled={state.submitting}
+            onClick={onClose}
+            className="rounded-2xl px-4 py-2 text-[14px] font-medium text-ds-muted transition hover:bg-[var(--ds-sidebar-row-hover)] hover:text-ds-ink disabled:cursor-wait disabled:opacity-60"
+          >
+            {t('cancel')}
+          </button>
+          <button
+            type="button"
+            disabled={state.submitting}
+            onClick={onConfirm}
+            className={`rounded-2xl px-5 py-2 text-[14px] font-semibold transition disabled:cursor-wait disabled:opacity-60 ${
+              state.danger
+                ? 'bg-red-500/12 text-red-600 hover:bg-red-500/18 dark:text-red-300'
+                : 'bg-accent text-white hover:brightness-110'
+            }`}
+          >
+            {state.submitting ? t('loading') : state.confirmLabel}
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
 function ThreadContextMenuItem({
   icon,
   label,
diff --git a/src/renderer/src/components/chat/StreamdownCode.test.ts b/src/renderer/src/components/chat/StreamdownCode.test.ts
index 16d4ae1be..ded42120a 100644
--- a/src/renderer/src/components/chat/StreamdownCode.test.ts
+++ b/src/renderer/src/components/chat/StreamdownCode.test.ts
@@ -4,7 +4,7 @@ import { renderToStaticMarkup } from 'react-dom/server'
 import { StreamdownCode } from './StreamdownCode'
 
 describe('StreamdownCode plain text fences', () => {
-  it('renders text fenced blocks without code block chrome', () => {
+  it('renders text fenced blocks with plain text code block chrome', () => {
     const html = renderToStaticMarkup(
       createElement(
         StreamdownCode,
@@ -13,13 +13,27 @@ describe('StreamdownCode plain text fences', () => {
       )
     )
 
-    expect(html).toContain('ds-plain-text-block')
-    expect(html).toContain('ds-plain-code-block')
+    expect(html).toContain('ds-code-block-header')
+    expect(html).toContain('plain text')
     expect(html).toContain('refactor(chat): simplify composer')
     expect(html).toContain('- Keep only Stop')
-    expect(html).not.toContain('ds-code-block-header')
-    expect(html).not.toContain('Download code')
-    expect(html).not.toContain('Copy code')
+    expect(html).toContain('Download code')
+    expect(html).toContain('Copy code')
+  })
+
+  it('renders language-less fenced blocks with plain text code block chrome', () => {
+    const html = renderToStaticMarkup(
+      createElement(
+        StreamdownCode,
+        { 'data-block': true },
+        'echo hello\n'
+      )
+    )
+
+    expect(html).toContain('data-language="plain text"')
+    expect(html).toContain('plain text')
+    expect(html).toContain('echo hello')
+    expect(html).toContain('Copy code')
   })
 
   it('hides empty plain text fenced blocks', () => {
diff --git a/src/renderer/src/components/chat/StreamdownCode.tsx b/src/renderer/src/components/chat/StreamdownCode.tsx
index e1a0dc80c..9a396be2e 100644
--- a/src/renderer/src/components/chat/StreamdownCode.tsx
+++ b/src/renderer/src/components/chat/StreamdownCode.tsx
@@ -95,15 +95,8 @@ function isPlainTextLanguage(language: string): boolean {
   return PLAIN_TEXT_LANGUAGES.has(language.trim().toLowerCase())
 }
 
-function PlainTextBlock({ code }: { code: string }): ReactNode {
-  const trimmedCode = code.replace(TRAILING_NEWLINES_REGEX, '')
-  if (!trimmedCode.trim()) return null
-
-  return (
-    <div className="ds-plain-text-block ds-plain-code-block" data-streamdown="plain-text-block">
-      {trimmedCode}
-    </div>
-  )
+function displayCodeLanguage(language: string): string {
+  return isPlainTextLanguage(language) ? 'plain text' : language
 }
 
 function inlineFileReference(text: string): { text: string; target: FileReferenceTarget } | null {
@@ -184,6 +177,7 @@ function CodeBlock({
   const [expanded, setExpanded] = useState(false)
   const bodyRef = useRef<HTMLDivElement>(null)
   const copyResetRef = useRef<number | null>(null)
+  const displayLanguage = displayCodeLanguage(language)
 
   useEffect(() => {
     let cancelled = false
@@ -240,7 +234,7 @@ function CodeBlock({
   return (
     <div
       className="ds-code-block"
-      data-language={language}
+      data-language={displayLanguage}
       data-streamdown="code-block"
       style={{
         contentVisibility: 'auto',
@@ -248,7 +242,7 @@ function CodeBlock({
       }}
     >
       <div className="ds-code-block-header" data-streamdown="code-block-header">
-        <span className="ds-code-block-language">{language || 'text'}</span>
+        <span className="ds-code-block-language">{displayLanguage}</span>
         <div className="ds-code-block-actions">
           <button
             type="button"
@@ -352,8 +346,8 @@ function CodeComponent({ node, className, children, ...props }: CodeProps) {
   const match = className?.match(LANGUAGE_REGEX)
   const language = match?.[1] ?? ''
 
-  if (isPlainTextLanguage(language)) {
-    return <PlainTextBlock code={text} />
+  if (isPlainTextLanguage(language) && !text.replace(TRAILING_NEWLINES_REGEX, '').trim()) {
+    return null
   }
 
   return <CodeBlock code={text} language={language} />
diff --git a/src/renderer/src/components/chat/SubagentCallCard.tsx b/src/renderer/src/components/chat/SubagentCallCard.tsx
new file mode 100644
index 000000000..9f14ff02f
--- /dev/null
+++ b/src/renderer/src/components/chat/SubagentCallCard.tsx
@@ -0,0 +1,656 @@
+import type { ReactElement } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Check, ChevronDown, ChevronRight, ExternalLink, Hourglass, Loader2, TriangleAlert } from 'lucide-react'
+import type { ChatBlock, ToolBlock } from '../../agent/types'
+import { useChatStore } from '../../store/chat-store'
+import { AgentKun } from '../subagents/AgentKun'
+
+/**
+ * "Kun Crew" — the subagent (`delegate_task`) visualization for the chat
+ * timeline. A single delegation renders as one {@link SubagentCallCard}; sibling
+ * delegations of one turn coalesce under a {@link SwarmHeader} (only N >= 2).
+ *
+ * Three independent visual channels: AgentKun **pose** = role, **motion** =
+ * liveness, **disc ring + status dot** = status. Bound only to fields that
+ * exist today (`block.meta.child` + guarded parse of the tool `detail` JSON);
+ * every read degrades gracefully so a contract change never blanks the card.
+ */
+
+type CardStatus = 'queued' | 'running' | 'done' | 'failed' | 'awaiting-permission'
+
+const KNOWN_POSE_IDS = new Set([
+  'general',
+  'explore',
+  'design-reviewer',
+  'over-engineering-reviewer',
+  'code-review',
+  'compaction',
+  'title',
+  'summary'
+])
+
+const REDUCED_MOTION_QUERY = '(prefers-reduced-motion: reduce)'
+
+/** Parsed shape of the `delegate_task` tool `detail` JSON (all optional). */
+type DelegateDetail = {
+  summary?: string
+  error?: string
+  profile?: string
+  toolPolicy?: string
+  toolInvocations?: number
+  durationMs?: number
+  queuedMs?: number
+  totalTokens?: number
+}
+
+function parseDelegateDetail(detail: string | undefined): DelegateDetail {
+  if (!detail || !detail.trim()) return {}
+  let raw: unknown
+  try {
+    raw = JSON.parse(detail)
+  } catch {
+    return {}
+  }
+  if (!raw || typeof raw !== 'object') return {}
+  const obj = raw as Record<string, unknown>
+  const usage = obj.usage && typeof obj.usage === 'object' ? (obj.usage as Record<string, unknown>) : undefined
+  const str = (v: unknown): string | undefined =>
+    typeof v === 'string' && v.trim() ? v.trim() : undefined
+  const num = (v: unknown): number | undefined =>
+    typeof v === 'number' && Number.isFinite(v) ? v : undefined
+  return {
+    summary: str(obj.summary),
+    error: str(obj.error),
+    profile: str(obj.profile),
+    toolPolicy: str(obj.toolPolicy),
+    toolInvocations: num(obj.toolInvocations),
+    durationMs: num(obj.durationMs),
+    queuedMs: num(obj.queuedMs),
+    totalTokens: usage ? num(usage.totalTokens) : undefined
+  }
+}
+
+type ChildMeta = {
+  childId?: string
+  childLabel?: string
+  childStatus?: string
+  childSeq?: number
+  parentTurnId?: string
+}
+
+function readChildMeta(block: ChatBlock): ChildMeta {
+  const meta =
+    block.kind === 'tool' || block.kind === 'approval' || block.kind === 'user'
+      ? block.meta
+      : undefined
+  const child = meta?.child && typeof meta.child === 'object' ? (meta.child as Record<string, unknown>) : null
+  if (!child) return {}
+  const str = (v: unknown): string | undefined =>
+    typeof v === 'string' && v.trim() ? v.trim() : undefined
+  return {
+    childId: str(child.childId),
+    childLabel: str(child.childLabel),
+    childStatus: str(child.childStatus),
+    childSeq: typeof child.childSeq === 'number' ? child.childSeq : undefined,
+    parentTurnId: str(child.parentTurnId)
+  }
+}
+
+/**
+ * Map the child run + block status to one of five card states. `childStatus`
+ * (when present) wins; otherwise fall back to `block.status`.
+ */
+function resolveStatus(block: ChatBlock, child: ChildMeta): CardStatus {
+  const cs = child.childStatus
+  if (cs === 'queued') return 'queued'
+  if (cs === 'running') return 'running'
+  if (cs === 'completed') return 'done'
+  if (cs === 'failed' || cs === 'aborted') return 'failed'
+  // Pending approval surfaced as an approval block alongside the child.
+  if (block.kind === 'approval' && block.status === 'pending') return 'awaiting-permission'
+  const blockStatus =
+    'status' in block && typeof block.status === 'string' ? block.status : undefined
+  if (blockStatus === 'running') return 'running'
+  if (blockStatus === 'error') return 'failed'
+  if (blockStatus === 'success') return 'done'
+  return 'running'
+}
+
+function isTerminal(status: CardStatus): boolean {
+  return status === 'done' || status === 'failed'
+}
+
+/** Deterministic hue from a string, so same-pose custom agents differ. */
+function hashHue(input: string): number {
+  let h = 0
+  for (let i = 0; i < input.length; i += 1) {
+    h = (h * 31 + input.charCodeAt(i)) | 0
+  }
+  return Math.abs(h) % 360
+}
+
+function useReducedMotion(): boolean {
+  const [reduced, setReduced] = useState(false)
+  useEffect(() => {
+    if (typeof window === 'undefined' || !window.matchMedia) return
+    const mq = window.matchMedia(REDUCED_MOTION_QUERY)
+    setReduced(mq.matches)
+    const onChange = (e: MediaQueryListEvent): void => setReduced(e.matches)
+    mq.addEventListener?.('change', onChange)
+    return () => mq.removeEventListener?.('change', onChange)
+  }, [])
+  return reduced
+}
+
+/** Freeze animation when the card scrolls out of the viewport. */
+function useOnScreen(ref: React.RefObject<Element | null>): boolean {
+  const [onScreen, setOnScreen] = useState(true)
+  useEffect(() => {
+    const el = ref.current
+    if (!el || typeof IntersectionObserver === 'undefined') return
+    const io = new IntersectionObserver((entries) => {
+      const entry = entries[0]
+      if (entry) setOnScreen(entry.isIntersecting)
+    })
+    io.observe(el)
+    return () => io.disconnect()
+  }, [ref])
+  return onScreen
+}
+
+function mmss(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000))
+  const m = Math.floor(total / 60)
+  const s = total % 60
+  return `${m}:${s.toString().padStart(2, '0')}`
+}
+
+/**
+ * Live elapsed ticker. While `running`, ticks `now - createdAt` once a second;
+ * on a terminal status it freezes at `durationMs` (or the last tick). Local-only.
+ */
+function useElapsed(
+  status: CardStatus,
+  createdAt: string | undefined,
+  durationMs: number | undefined
+): string {
+  const start = useMemo(() => {
+    const parsed = createdAt ? Date.parse(createdAt) : NaN
+    return Number.isFinite(parsed) ? parsed : Date.now()
+  }, [createdAt])
+  const [now, setNow] = useState(() => Date.now())
+  const running = status === 'running' || status === 'awaiting-permission' || status === 'queued'
+  useEffect(() => {
+    if (!running) return
+    const id = window.setInterval(() => setNow(Date.now()), 1000)
+    return () => window.clearInterval(id)
+  }, [running])
+  if (status === 'queued') return '—'
+  if (isTerminal(status) && typeof durationMs === 'number') return mmss(durationMs)
+  return mmss(now - start)
+}
+
+const DISC_BG: Record<CardStatus, string> = {
+  queued: 'radial-gradient(circle at 50% 36%,#fff 0%,#eef4fb 80%)',
+  running: 'radial-gradient(circle at 50% 36%,#fff 0%,#e3eefb 82%)',
+  done: 'radial-gradient(circle at 50% 36%,#fff 0%,#e4f5ee 82%)',
+  failed: 'radial-gradient(circle at 50% 36%,#fff 0%,#fbe6e4 82%)',
+  'awaiting-permission': 'radial-gradient(circle at 50% 36%,#fff 0%,#fbf0df 82%)'
+}
+const DISC_RING: Record<CardStatus, string> = {
+  queued: 'inset 0 0 0 1px rgba(188,214,245,0.7)',
+  running: 'inset 0 0 0 1px var(--ds-accent, #3b82d8)',
+  done: 'inset 0 0 0 1px #8fd9bf',
+  failed: 'inset 0 0 0 1px #efa8a2',
+  'awaiting-permission': 'inset 0 0 0 1px #e8c486'
+}
+
+function StatusDot({ status }: { status: CardStatus }): ReactElement {
+  const ring = 'absolute -bottom-px -right-px flex h-[13px] w-[13px] items-center justify-center rounded-full border-[2.5px] border-ds-card'
+  if (status === 'done') {
+    return (
+      <span className={`${ring} bg-emerald-500 dark:bg-emerald-400`}>
+        <Check className="h-2 w-2 text-white" strokeWidth={3.5} />
+      </span>
+    )
+  }
+  if (status === 'failed') {
+    return (
+      <span className={`${ring} bg-red-500 dark:bg-red-400`}>
+        <TriangleAlert className="h-2 w-2 text-white" strokeWidth={3} />
+      </span>
+    )
+  }
+  if (status === 'queued') {
+    return <span className={`${ring} bg-ds-faint/60`} />
+  }
+  if (status === 'awaiting-permission') {
+    return <span className={`${ring} bg-amber-500`} />
+  }
+  // running: pulsing accent dot
+  return <span className={`${ring} ds-subagent-dot-pulse bg-accent`} />
+}
+
+function StatusPill({ status, t }: { status: CardStatus; t: (k: string) => string }): ReactElement | null {
+  const base = 'whitespace-nowrap rounded-full px-2 py-[2px] text-[10.5px] font-semibold'
+  switch (status) {
+    case 'queued':
+      return <span className={`${base} bg-ds-card-muted text-ds-muted`}>{t('subagentStatusQueued')}</span>
+    case 'running':
+      return <span className={`${base} bg-accent/10 text-accent`}>{t('subagentStatusRunning')}</span>
+    case 'done':
+      return (
+        <span className={`${base} text-ds-success bg-ds-success-soft`}>{t('subagentStatusDone')}</span>
+      )
+    case 'failed':
+      return (
+        <span className={`${base} text-ds-danger bg-ds-danger-soft`}>{t('subagentStatusFailed')}</span>
+      )
+    case 'awaiting-permission':
+      return (
+        <span className={`${base} bg-amber-500/10 text-amber-600 dark:text-amber-300`}>
+          {t('subagentStatusAwaiting')}
+        </span>
+      )
+    default:
+      return null
+  }
+}
+
+/** 2.5px liveness lane directly under the trigger row. */
+function LaneHairline({ status, animate }: { status: CardStatus; animate: boolean }): ReactElement | null {
+  if (status === 'queued') return null
+  const base = 'relative h-[2.5px] w-full overflow-hidden bg-ds-border-muted'
+  if (status === 'running') {
+    return (
+      <div className={base}>
+        {animate ? (
+          <span className="ds-subagent-lane-sweep absolute top-0 h-full w-2/5 rounded-[2px]" />
+        ) : (
+          <span className="absolute inset-y-0 left-0 w-1/3 bg-accent/60" />
+        )}
+      </div>
+    )
+  }
+  if (status === 'done') {
+    return (
+      <div className={base}>
+        <span className="absolute inset-0 bg-emerald-500" />
+      </div>
+    )
+  }
+  if (status === 'failed') {
+    return (
+      <div className={base}>
+        <span className="absolute inset-y-0 left-0 w-[62%] bg-red-500" />
+      </div>
+    )
+  }
+  // awaiting-permission: striped amber, paused
+  return (
+    <div className={base}>
+      <span
+        className="absolute inset-0 opacity-60"
+        style={{
+          backgroundImage:
+            'repeating-linear-gradient(45deg,#dd9444 0 6px,transparent 6px 12px)'
+        }}
+      />
+    </div>
+  )
+}
+
+function AvatarDisc({
+  poseId,
+  status,
+  hue,
+  compact,
+  animate
+}: {
+  poseId: string
+  status: CardStatus
+  hue: number | null
+  compact: boolean
+  animate: boolean
+}): ReactElement {
+  // Failed: keep the pose, freeze motion, tint disc red (reads "stuck", not "asleep").
+  // Queued: AgentKun's disabled (resting) path, grayscale + static.
+  const disabled = status === 'queued'
+  const frozen = !animate || status === 'failed' || isTerminal(status)
+  const size = compact ? 'h-9 w-9' : 'h-11 w-11'
+  const inner = compact ? 'h-[31px] w-[31px]' : 'h-9 w-9'
+  // Hash-tint for same-pose custom agents — applied to the wrapper gradient only.
+  const bg =
+    hue !== null && status !== 'failed' && status !== 'done'
+      ? `radial-gradient(circle at 50% 36%,#fff 0%,hsl(${hue} 60% 94%) 82%)`
+      : DISC_BG[status]
+  return (
+    <span
+      className={`relative flex ${size} shrink-0 items-center justify-center rounded-full ${
+        frozen ? 'ds-subagent-frozen' : ''
+      }`}
+      style={{ background: bg, boxShadow: DISC_RING[status] }}
+    >
+      <AgentKun id={poseId} disabled={disabled} className={inner} />
+      <StatusDot status={status} />
+    </span>
+  )
+}
+
+function MetaChip({ children, title }: { children: React.ReactNode; title?: string }): ReactElement {
+  return (
+    <span
+      className="rounded-[7px] border border-ds-border-muted bg-ds-card-muted/45 px-2 py-[3px] text-[10.5px] text-ds-muted"
+      title={title}
+    >
+      {children}
+    </span>
+  )
+}
+
+export function SubagentCallCard({
+  block,
+  compact = false,
+  inGroup = false
+}: {
+  block: ChatBlock
+  /** Smaller avatar variant used inside a swarm group. */
+  compact?: boolean
+  /** Inside a SwarmHeader group: suppress own shell, inline-toggle only. */
+  inGroup?: boolean
+}): ReactElement | null {
+  const { t } = useTranslation('common')
+  const selectThread = useChatStore((s) => s.selectThread)
+  const reducedMotion = useReducedMotion()
+  const ref = useRef<HTMLElement | null>(null)
+  const onScreen = useOnScreen(ref)
+
+  const child = readChildMeta(block)
+  const detail = useMemo(
+    () => parseDelegateDetail(block.kind === 'tool' ? (block as ToolBlock).detail : undefined),
+    [block]
+  )
+  const status = resolveStatus(block, child)
+  const animate = !reducedMotion && onScreen && status === 'running'
+
+  // Pose key: detail.profile → childLabel → block toolName → 'custom'.
+  const poseId = detail.profile || child.childLabel || child.childId || 'custom'
+  const isKnownPose = KNOWN_POSE_IDS.has(poseId)
+  const hue = isKnownPose ? null : hashHue(poseId)
+
+  // Name priority: localized name for a known built-in role → the model's label
+  // → a custom profile's own name → a short name derived from the task → default.
+  const taskText = block.kind === 'tool' ? splitTaskLine(block as ToolBlock) : undefined
+  const roleName =
+    (detail.profile && KNOWN_POSE_IDS.has(detail.profile)
+      ? t(`subagentsPanel.role.${detail.profile}.name`, detail.profile)
+      : undefined) ||
+    child.childLabel?.trim() ||
+    detail.profile?.trim() ||
+    taskText?.trim().split(/\s+/).slice(0, 6).join(' ').slice(0, 28) ||
+    t('subagentDefaultName')
+  const taskParts = [detail.profile || child.childLabel, detail.summary || (block.kind === 'tool' ? splitTaskLine(block as ToolBlock) : undefined)]
+    .filter((p): p is string => Boolean(p && p.trim()))
+  const taskLine = taskParts.join(' · ')
+
+  const elapsed = useElapsed(status, block.createdAt, detail.durationMs)
+  const steps = detail.toolInvocations
+
+  // Auto-expand once on first terminal transition iff summary/error present.
+  const hasBody = Boolean(detail.summary?.trim() || detail.error?.trim())
+  const [userToggled, setUserToggled] = useState<boolean | null>(null)
+  const autoExpandedRef = useRef(false)
+  const [autoExpanded, setAutoExpanded] = useState(false)
+  useEffect(() => {
+    if (autoExpandedRef.current) return
+    if (isTerminal(status) && hasBody && !inGroup) {
+      autoExpandedRef.current = true
+      setAutoExpanded(true)
+    }
+  }, [status, hasBody, inGroup])
+  const expanded = (userToggled ?? autoExpanded) && hasBody
+
+  const childId = child.childId
+  const openChild = (): void => {
+    if (!childId) return
+    void selectThread(childId).catch(() => undefined)
+  }
+
+  // Stagger sweep/pulse per child so a swarm reads as independent.
+  const staggerDelay = typeof child.childSeq === 'number' ? `${(child.childSeq % 6) * 0.18}s` : '0s'
+
+  const shellClass = inGroup
+    ? 'overflow-hidden border-t border-ds-border-muted first:border-t-0'
+    : 'ds-subagent-mount overflow-hidden rounded-[20px] border border-ds-border bg-ds-card/80 shadow-[0_16px_40px_rgba(86,103,136,0.08)] backdrop-blur-xl'
+  const failBorder = !inGroup && status === 'failed' ? ' border-ds-danger/60' : ''
+
+  return (
+    <section
+      ref={ref as React.RefObject<HTMLElement>}
+      className={`${shellClass}${failBorder}`}
+      style={{ ['--ds-subagent-stagger' as string]: staggerDelay }}
+      aria-label={`${roleName} · ${pillText(status, t)}`}
+    >
+      <div
+        role={hasBody ? 'button' : undefined}
+        tabIndex={hasBody ? 0 : undefined}
+        aria-expanded={hasBody ? expanded : undefined}
+        onClick={() => {
+          if (hasBody) setUserToggled(!expanded)
+        }}
+        onKeyDown={(e) => {
+          if (!hasBody) return
+          if (e.key === 'Enter' || e.key === ' ') {
+            e.preventDefault()
+            setUserToggled(!expanded)
+          }
+        }}
+        className={`flex items-center gap-3 px-4 ${compact ? 'py-2.5' : 'py-3'} text-left ${
+          hasBody ? 'cursor-pointer transition hover:bg-ds-hover/30' : ''
+        }`}
+      >
+        <AvatarDisc poseId={poseId} status={status} hue={hue} compact={compact} animate={animate} />
+        <span className="min-w-0 flex-1">
+          <span className="flex items-center gap-2">
+            <span className="truncate text-[14px] font-semibold text-ds-ink">{roleName}</span>
+            {!compact || !inGroup ? <StatusPill status={status} t={t} /> : null}
+          </span>
+          {taskLine ? (
+            <span className="mt-0.5 block truncate text-[12.5px] text-ds-muted">{taskLine}</span>
+          ) : null}
+        </span>
+        <span className="shrink-0 text-right tabular-nums">
+          <span className="block text-[13px] font-semibold text-ds-ink">{elapsed}</span>
+          <span className="mt-px block text-[10.5px] text-ds-faint">
+            {typeof steps === 'number'
+              ? t('subagentSteps', { count: steps })
+              : status === 'queued' && typeof detail.queuedMs === 'number'
+                ? t('subagentQueuedHint')
+                : ''}
+          </span>
+        </span>
+        {hasBody ? (
+          expanded ? (
+            <ChevronDown className="h-4 w-4 shrink-0 text-ds-faint" strokeWidth={1.8} />
+          ) : (
+            <ChevronRight className="h-4 w-4 shrink-0 text-ds-faint" strokeWidth={1.8} />
+          )
+        ) : (
+          <ChevronRight className="h-4 w-4 shrink-0 text-ds-faint/40" strokeWidth={1.8} />
+        )}
+      </div>
+
+      <LaneHairline status={status} animate={animate} />
+
+      {expanded ? (
+        <div className="border-t border-ds-border-muted/70 px-4 py-3.5">
+          {detail.error?.trim() ? (
+            <pre className="whitespace-pre-wrap break-words rounded-[10px] border border-red-200/80 bg-red-50/80 px-3 py-2.5 font-mono text-[12px] leading-5 text-ds-danger dark:border-red-800/40 dark:bg-red-500/10">
+              {detail.error}
+            </pre>
+          ) : detail.summary?.trim() ? (
+            <p className="whitespace-pre-wrap text-[14px] leading-6 text-ds-muted">{detail.summary}</p>
+          ) : null}
+
+          <div className="mt-3 flex flex-wrap items-center gap-1.5">
+            {detail.profile ? <MetaChip title={detail.profile}>{detail.profile}</MetaChip> : null}
+            {typeof detail.totalTokens === 'number' && detail.totalTokens > 0 ? (
+              <MetaChip>{t('subagentTokensChip', { count: detail.totalTokens })}</MetaChip>
+            ) : null}
+            {detail.toolPolicy ? (
+              <MetaChip>
+                {detail.toolPolicy === 'readOnly' ? t('subagentPolicyReadOnly') : t('subagentPolicyFull')}
+              </MetaChip>
+            ) : null}
+            <span className="ml-auto" />
+            {childId ? (
+              <button
+                type="button"
+                onClick={(e) => {
+                  e.stopPropagation()
+                  openChild()
+                }}
+                className="inline-flex items-center gap-1.5 rounded-[9px] bg-accent/10 px-3 py-1.5 text-[12px] font-semibold text-accent transition hover:bg-accent/15"
+              >
+                {t('subagentOpenSession')}
+                <ExternalLink className="h-3 w-3" strokeWidth={2} />
+              </button>
+            ) : null}
+          </div>
+        </div>
+      ) : null}
+    </section>
+  )
+}
+
+function pillText(status: CardStatus, t: (k: string) => string): string {
+  switch (status) {
+    case 'queued':
+      return t('subagentStatusQueued')
+    case 'running':
+      return t('subagentStatusRunning')
+    case 'done':
+      return t('subagentStatusDone')
+    case 'failed':
+      return t('subagentStatusFailed')
+    case 'awaiting-permission':
+      return t('subagentStatusAwaiting')
+    default:
+      return ''
+  }
+}
+
+/** Best-effort task one-liner from a generic delegate_task summary string. */
+function splitTaskLine(block: ToolBlock): string | undefined {
+  const raw = block.summary?.trim()
+  if (!raw) return undefined
+  const stripped = raw.replace(/^delegate_task\s*:\s*/i, '').trim()
+  if (!stripped || stripped.length > 160) return undefined
+  return stripped
+}
+
+/**
+ * Coalesces sibling {@link SubagentCallCard}s of one turn. Renders a single
+ * full card for N=1 (no header); for N>=2 wraps them under a {@link SwarmHeader}
+ * with a stacked-avatar cluster and an aggregate count line.
+ */
+export function SubagentGroup({ blocks }: { blocks: ChatBlock[] }): ReactElement | null {
+  const { t } = useTranslation('common')
+  const [collapsed, setCollapsed] = useState(false)
+  const reducedMotion = useReducedMotion()
+
+  if (blocks.length === 0) return null
+  // N=1: single full card, no swarm header.
+  if (blocks.length === 1) {
+    return <SubagentCallCard block={blocks[0]} />
+  }
+
+  const sorted = [...blocks].sort((a, b) => {
+    const sa = readChildMeta(a).childSeq ?? 0
+    const sb = readChildMeta(b).childSeq ?? 0
+    return sa - sb
+  })
+
+  let running = 0
+  let queued = 0
+  let done = 0
+  for (const b of sorted) {
+    const s = resolveStatus(b, readChildMeta(b))
+    if (s === 'running' || s === 'awaiting-permission') running += 1
+    else if (s === 'queued') queued += 1
+    else if (s === 'done') done += 1
+  }
+  const anyRunning = running > 0 || queued > 0
+
+  const clusterPoses = sorted.slice(0, 5).map((b) => {
+    const c = readChildMeta(b)
+    const d = parseDelegateDetail(b.kind === 'tool' ? (b as ToolBlock).detail : undefined)
+    return d.profile || c.childLabel || c.childId || 'custom'
+  })
+  const overflow = sorted.length - clusterPoses.length
+
+  const summaryParts: string[] = []
+  if (running > 0) summaryParts.push(t('subagentSwarmRunning', { count: running }))
+  if (queued > 0) summaryParts.push(t('subagentSwarmQueued', { count: queued }))
+  if (done > 0) summaryParts.push(t('subagentSwarmDone', { count: done }))
+
+  return (
+    <section className="ds-subagent-mount overflow-hidden rounded-[20px] border border-ds-border bg-ds-card/80 shadow-[0_16px_40px_rgba(86,103,136,0.08)] backdrop-blur-xl">
+      <button
+        type="button"
+        onClick={() => setCollapsed((v) => !v)}
+        aria-expanded={!collapsed}
+        className="flex w-full items-center gap-3 border-b border-ds-border-muted bg-gradient-to-b from-ds-card to-ds-card-muted/40 px-4 py-3 text-left transition hover:bg-ds-hover/30"
+      >
+        {anyRunning && !reducedMotion ? (
+          <Loader2 className="h-4 w-4 shrink-0 animate-spin text-accent" strokeWidth={2.2} />
+        ) : anyRunning ? (
+          <Hourglass className="h-4 w-4 shrink-0 text-accent" strokeWidth={2} />
+        ) : (
+          <Check className="h-4 w-4 shrink-0 text-ds-success" strokeWidth={2.4} />
+        )}
+        <span className="min-w-0 flex-1 text-[12.5px] font-semibold text-ds-heading">
+          {t('subagentSwarmTitle', { count: sorted.length })}
+          {summaryParts.length > 0 ? (
+            <span className="font-normal text-ds-muted"> · {summaryParts.join(' · ')}</span>
+          ) : null}
+        </span>
+        <span className="flex shrink-0">
+          {clusterPoses.map((pose, i) => (
+            <span
+              key={`${pose}-${i}`}
+              className="flex h-6 w-6 items-center justify-center rounded-full border-2 border-ds-card"
+              style={{
+                marginLeft: i === 0 ? 0 : -8,
+                background: 'radial-gradient(circle at 50% 36%,#fff,#eef4fb)'
+              }}
+            >
+              <AgentKun id={pose} className="h-5 w-5" />
+            </span>
+          ))}
+          {overflow > 0 ? (
+            <span
+              className="flex h-6 w-6 items-center justify-center rounded-full border-2 border-ds-card bg-ds-card-muted text-[9px] font-semibold text-ds-muted"
+              style={{ marginLeft: -8 }}
+            >
+              +{overflow}
+            </span>
+          ) : null}
+        </span>
+        {collapsed ? (
+          <ChevronRight className="h-4 w-4 shrink-0 text-ds-faint" strokeWidth={1.8} />
+        ) : (
+          <ChevronDown className="h-4 w-4 shrink-0 text-ds-faint" strokeWidth={1.8} />
+        )}
+      </button>
+      {!collapsed ? (
+        <div>
+          {sorted.map((b) => (
+            <SubagentCallCard key={b.id} block={b} compact inGroup />
+          ))}
+        </div>
+      ) : null}
+    </section>
+  )
+}
diff --git a/src/renderer/src/components/chat/WorkbenchTopBar.tsx b/src/renderer/src/components/chat/WorkbenchTopBar.tsx
index 8cc4faaec..f15db1dc8 100644
--- a/src/renderer/src/components/chat/WorkbenchTopBar.tsx
+++ b/src/renderer/src/components/chat/WorkbenchTopBar.tsx
@@ -4,6 +4,7 @@ import type { EditorInfo } from '@shared/editor'
 import type { GuiUpdateState } from '@shared/gui-update'
 import {
   ArrowUpCircle,
+  Bot,
   Check,
   ChevronDown,
   Code2,
@@ -30,6 +31,7 @@ export type RightPanelMode =
   | 'file'
   | 'plan'
   | 'sdd-ai'
+  | 'subagents'
   | null
 
 type Props = {
@@ -86,7 +88,8 @@ export function WorkbenchTopBar({
     { mode: 'todo' as const, label: t('rightPanelTodo'), icon: ListTodo },
     ...(planPanelEnabled ? [{ mode: 'plan' as const, label: t('rightPanelPlan'), icon: ClipboardList }] : []),
     { mode: 'changes' as const, label: t('rightPanelChanges'), icon: FileEdit },
-    { mode: 'browser' as const, label: t('rightPanelBrowser'), icon: Globe2 }
+    { mode: 'browser' as const, label: t('rightPanelBrowser'), icon: Globe2 },
+    { mode: 'subagents' as const, label: t('rightPanelSubagents'), icon: Bot }
   ]
   const selectedEditor = useMemo(
     () => editors.find((editor) => editor.id === selectedEditorId) ?? editors[0],
diff --git a/src/renderer/src/components/chat/WorkspaceModeTabs.tsx b/src/renderer/src/components/chat/WorkspaceModeTabs.tsx
index a96364c75..ab0f038e8 100644
--- a/src/renderer/src/components/chat/WorkspaceModeTabs.tsx
+++ b/src/renderer/src/components/chat/WorkspaceModeTabs.tsx
@@ -3,7 +3,7 @@ import { Code2, PencilLine } from 'lucide-react'
 import { useTranslation } from 'react-i18next'
 
 type Props = {
-  activeView: 'chat' | 'write' | 'claw' | 'schedule' | 'workflow'
+  activeView: 'chat' | 'write' | 'claw' | 'schedule' | 'workflow' | 'subagents'
   onCodeOpen: () => void
   onWriteOpen: () => void
 }
diff --git a/src/renderer/src/components/chat/message-timeline-bubbles.tsx b/src/renderer/src/components/chat/message-timeline-bubbles.tsx
index 50668a44d..91c837177 100644
--- a/src/renderer/src/components/chat/message-timeline-bubbles.tsx
+++ b/src/renderer/src/components/chat/message-timeline-bubbles.tsx
@@ -3,8 +3,8 @@ import { memo, useEffect, useMemo, useRef, useState } from 'react'
 import ReactMarkdown from 'react-markdown'
 import remarkGfm from 'remark-gfm'
 import { useTranslation } from 'react-i18next'
-import { Check, ChevronDown, ChevronRight, Copy, Download, File, FileEdit, GitFork, ImageIcon, Loader2, MessageSquareQuote, PencilLine, RotateCcw, Terminal, Video, Wrench } from 'lucide-react'
-import type { AttachmentReference, ChatBlock, GeneratedFileReference, RuntimeDisclosureMetadata, ToolBlock, UserFileReference, UserInputAnswer, UserInputQuestion } from '../../agent/types'
+import { ArrowDown, Check, ChevronDown, ChevronRight, Copy, Download, File, FileEdit, GitFork, ImageIcon, Loader2, MessageSquareQuote, PencilLine, RotateCcw, Terminal, Video, Wrench } from 'lucide-react'
+import type { AttachmentReference, ChatBlock, GeneratedFileReference, RuntimeDisclosureMetadata, ToolBlock, UserFileReference, UserInputAnswer } from '../../agent/types'
 import { extractUnifiedDiffText } from '../../lib/diff-stats'
 import { useChatStore } from '../../store/chat-store'
 import { getProvider } from '../../agent/registry'
@@ -16,6 +16,7 @@ import { AssistantMarkdown } from './AssistantMarkdown'
 import { ImagePreviewLightbox } from './ImagePreviewLightbox'
 import { ModelMetaTag, WritePromptMetaDisclosure } from './message-timeline-cards'
 import { readNumber, formatDuration, formatToolTitle } from './message-timeline-tools'
+import { answersByQuestionId, shouldShowQuestionHeader } from './user-input-panel-logic'
 
 const COPY_FEEDBACK_RESET_MS = 1600
 
@@ -234,9 +235,6 @@ function ClawInboundMessageCard({
   )
 }
 
-const USER_INPUT_OTHER_LABEL = 'Other'
-const USER_INPUT_FREEFORM_LABEL = 'Answer'
-
 function metaStringArray(meta: Record<string, unknown> | undefined, key: string): string[] {
   const value = meta?.[key]
   if (!Array.isArray(value)) return []
@@ -1013,28 +1011,9 @@ function UserInputBubble({
     setAnswers(answersByQuestionId(block.answers))
   }, [block.id, block.answers])
 
-  const chooseOption = (question: UserInputQuestion, label: string, value = label): void => {
-    setAnswers((prev) => ({
-      ...prev,
-      [question.id]: { id: question.id, label, value }
-    }))
-  }
-
-  const canSubmit = block.questions.every((question) => {
-    const answer = answers[question.id]
-    if (!answer) return false
-    if (question.options.length === 0 || answer.label === USER_INPUT_OTHER_LABEL) {
-      return answer.value.trim().length > 0
-    }
-    return true
-  })
-
-  const submit = (): void => {
-    if (!canSubmit || !pending) return
-    const ordered = block.questions.map((question) => answers[question.id]).filter(Boolean)
-    void resolveUserInput(block.id, { kind: 'submit', answers: ordered })
-  }
-
+  // Answering moved to the composer-docked panel (FloatingComposerUserInputPanel);
+  // this bubble is now the read-only record of what was asked and answered. It
+  // keeps only the cancel affordance while pending.
   const cancel = (): void => {
     if (!pending) return
     void resolveUserInput(block.id, { kind: 'cancel' })
@@ -1130,13 +1109,9 @@ function UserInputBubble({
         {block.questions.map((question, index) => {
           const answer = answers[question.id]
           const hasOptions = question.options.length > 0
-          const otherSelected = answer?.label === USER_INPUT_OTHER_LABEL
           const submittedAnswer = done ? (answer?.value || answer?.label || '') : ''
           const showProgress = questionCount > 1
-          const showHeader =
-            typeof question.header === 'string' &&
-            question.header.trim().length > 0 &&
-            !(questionCount === 1 && question.header.trim().toLowerCase() === 'input')
+          const showHeader = shouldShowQuestionHeader(question, questionCount)
           return (
             <div
               key={question.id}
@@ -1187,114 +1162,18 @@ function UserInputBubble({
                   {statusLabel}
                 </div>
               ) : hasOptions ? (
-                <div className="mt-3 grid gap-2">
-                  {question.options.map((option) => {
-                    const selected = answer?.label === option.label && answer.value === option.label
-                    return (
-                      <button
-                        key={option.label}
-                        type="button"
-                        disabled={done}
-                        onClick={() => chooseOption(question, option.label)}
-                        className={`group flex min-w-0 gap-2.5 rounded-[10px] border px-3 py-2.5 text-left transition disabled:cursor-default ${
-                          selected
-                            ? 'border-accent/35 bg-accent/10 text-ds-ink ring-1 ring-accent/10'
-                            : 'border-ds-border-muted bg-ds-card/78 text-ds-muted hover:border-ds-border hover:bg-ds-card hover:text-ds-ink'
-                        }`}
-                      >
-                        <span
-                          className={`mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-full border transition ${
-                            selected
-                              ? 'border-accent bg-accent/10'
-                              : 'border-ds-border bg-transparent group-hover:border-ds-muted'
-                          }`}
-                        >
-                          {selected ? <span className="h-2 w-2 rounded-full bg-accent" /> : null}
-                        </span>
-                        <span className="min-w-0">
-                          <span className="block break-words text-[13px] font-semibold [overflow-wrap:anywhere]">
-                            {option.label}
-                          </span>
-                          {option.description ? (
-                            <span className="mt-0.5 block break-words text-[12px] leading-5 text-ds-faint [overflow-wrap:anywhere]">
-                              {option.description}
-                            </span>
-                          ) : null}
-                        </span>
-                      </button>
-                    )
-                  })}
-                  <button
-                    type="button"
-                    disabled={done}
-                    onClick={() =>
-                      chooseOption(
-                        question,
-                        USER_INPUT_OTHER_LABEL,
-                        answer?.label === USER_INPUT_OTHER_LABEL ? answer.value : ''
-                      )
-                    }
-                    className={`group flex min-w-0 gap-2.5 rounded-[10px] border px-3 py-2.5 text-left transition disabled:cursor-default ${
-                      otherSelected
-                        ? 'border-accent/35 bg-accent/10 text-ds-ink ring-1 ring-accent/10'
-                        : 'border-ds-border-muted bg-ds-card/78 text-ds-muted hover:border-ds-border hover:bg-ds-card hover:text-ds-ink'
-                    }`}
-                  >
+                <div className="mt-2.5 flex flex-wrap gap-1.5">
+                  {question.options.map((option) => (
                     <span
-                      className={`mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-full border transition ${
-                        otherSelected
-                          ? 'border-accent bg-accent/10'
-                          : 'border-ds-border bg-transparent group-hover:border-ds-muted'
-                      }`}
+                      key={option.label}
+                      title={option.description || undefined}
+                      className="inline-flex min-w-0 max-w-full items-center rounded-full border border-ds-border-muted bg-ds-card/70 px-2.5 py-1 text-[12px] text-ds-muted"
                     >
-                      {otherSelected ? <span className="h-2 w-2 rounded-full bg-accent" /> : null}
-                    </span>
-                    <span className="min-w-0">
-                      <span className="block text-[13px] font-semibold">{t('userInputOther')}</span>
-                      <span className="mt-0.5 block text-[12px] leading-5 text-ds-faint">
-                        {t('userInputOtherDescription')}
-                      </span>
+                      <span className="truncate">{option.label}</span>
                     </span>
-                  </button>
-                  {otherSelected ? (
-                    <textarea
-                      rows={2}
-                      disabled={done}
-                      value={answer?.value ?? ''}
-                      onChange={(e) =>
-                        chooseOption(question, USER_INPUT_OTHER_LABEL, e.target.value)
-                      }
-                      onKeyDown={(e) => {
-                        if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
-                          e.preventDefault()
-                          submit()
-                        }
-                      }}
-                      placeholder={t('userInputCustomPlaceholder')}
-                      className="min-h-20 resize-y rounded-[10px] border border-ds-border-muted bg-ds-card/90 px-3 py-2 text-[13px] leading-5 text-ds-ink outline-none transition placeholder:text-ds-faint focus:border-accent/45 focus:ring-2 focus:ring-accent/10 disabled:cursor-default disabled:opacity-80"
-                    />
-                  ) : null}
-                </div>
-              ) : (
-                <div className="mt-3">
-                  <textarea
-                    rows={3}
-                    disabled={done}
-                    value={answer?.value ?? ''}
-                    onChange={(e) =>
-                      chooseOption(question, USER_INPUT_FREEFORM_LABEL, e.target.value)
-                    }
-                    onKeyDown={(e) => {
-                      if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
-                        e.preventDefault()
-                        submit()
-                      }
-                      }}
-                      placeholder={t('userInputCustomPlaceholder')}
-                    className="min-h-24 w-full resize-y rounded-[10px] border border-ds-border-muted bg-ds-card/90 px-3 py-2.5 text-[13px] leading-5 text-ds-ink outline-none transition placeholder:text-ds-faint focus:border-accent/45 focus:ring-2 focus:ring-accent/10 disabled:cursor-default disabled:opacity-80"
-                  />
+                  ))}
                 </div>
-              )}
+              ) : null}
             </div>
           )
         })}
@@ -1305,16 +1184,11 @@ function UserInputBubble({
       ) : null}
 
       {pending ? (
-        <div className="mt-3 flex flex-wrap gap-2 border-t border-ds-border-muted pt-3">
-          <button
-            type="button"
-            disabled={!canSubmit}
-            className="inline-flex min-h-8 items-center gap-1.5 rounded-[9px] bg-ds-ink px-3 py-1.5 text-[13px] font-semibold text-white shadow-sm transition hover:opacity-90 disabled:cursor-not-allowed disabled:opacity-45 dark:text-black"
-            onClick={submit}
-          >
-            <Check className="h-3.5 w-3.5" strokeWidth={2} />
-            {t('userInputSubmit')}
-          </button>
+        <div className="mt-3 flex flex-wrap items-center justify-between gap-2 border-t border-ds-border-muted pt-3">
+          <span className="inline-flex min-w-0 items-center gap-1.5 text-[12px] font-medium text-accent">
+            <ArrowDown className="h-3.5 w-3.5 shrink-0" strokeWidth={2} />
+            <span className="min-w-0">{t('userInputAnswerBelowHint')}</span>
+          </span>
           <button
             type="button"
             className="min-h-8 rounded-[9px] border border-ds-border-muted bg-ds-card/80 px-3 py-1.5 text-[13px] font-medium text-ds-muted transition hover:bg-ds-hover hover:text-ds-ink"
@@ -1328,16 +1202,6 @@ function UserInputBubble({
   )
 }
 
-function answersByQuestionId(
-  answers: UserInputAnswer[] | undefined
-): Record<string, UserInputAnswer> {
-  const out: Record<string, UserInputAnswer> = {}
-  for (const answer of answers ?? []) {
-    out[answer.id] = answer
-  }
-  return out
-}
-
 function formatMessageDateTime(input: string, locale: string): string {
   const date = new Date(input)
   if (Number.isNaN(date.getTime())) return input
@@ -1444,7 +1308,8 @@ function MessageBubbleImpl({
     return <UserInputBubble block={block} nested={nested} />
   }
   if (block.kind === 'approval') {
-    const done = block.status !== 'pending'
+    const submitting = block.status === 'submitting'
+    const done = block.status !== 'pending' && !submitting
     const statusLabel =
       block.status === 'allowed'
         ? t('approvalAllowed')
@@ -1452,7 +1317,9 @@ function MessageBubbleImpl({
           ? t('approvalDenied')
           : block.status === 'error'
             ? t('approvalFailed')
-            : t('approvalPending')
+            : submitting
+              ? t('approvalSubmitting')
+              : t('approvalPending')
     return (
       <div
         className={`rounded-[22px] border px-4 py-4 text-[13px] leading-6 shadow-[0_12px_30px_rgba(86,103,136,0.04)] ${
@@ -1475,18 +1342,23 @@ function MessageBubbleImpl({
           <div className="mt-3 flex flex-wrap gap-2">
             <button
               type="button"
-              className="rounded-lg bg-emerald-600 px-3 py-1.5 text-[13px] font-medium text-white hover:bg-emerald-700"
+              disabled={submitting}
+              className="rounded-lg bg-emerald-600 px-3 py-1.5 text-[13px] font-medium text-white hover:bg-emerald-700 disabled:cursor-wait disabled:opacity-60"
               onClick={() => void resolveApproval(block.id, 'allow')}
             >
               {t('approvalAllow')}
             </button>
             <button
               type="button"
-              className="rounded-lg border border-ds-border bg-ds-card px-3 py-1.5 text-[13px] font-medium text-ds-ink hover:bg-ds-hover"
+              disabled={submitting}
+              className="rounded-lg border border-ds-border bg-ds-card px-3 py-1.5 text-[13px] font-medium text-ds-ink hover:bg-ds-hover disabled:cursor-wait disabled:opacity-60"
               onClick={() => void resolveApproval(block.id, 'deny')}
             >
               {t('approvalDeny')}
             </button>
+            {submitting ? (
+              <span className="self-center text-[12px] font-medium text-ds-muted">{statusLabel}</span>
+            ) : null}
           </div>
         ) : (
           <p className="mt-2 text-[12px] font-medium text-ds-muted">{statusLabel}</p>
@@ -1533,7 +1405,9 @@ function MessageBubbleImpl({
 
 function ToolEntry({ block, nested = false }: { block: ToolBlock; nested?: boolean }): ReactElement {
   const { t } = useTranslation('common')
-  const [open, setOpen] = useState(() => block.status === 'error' || block.status === 'running')
+  // Errored tool calls stay collapsed by default — only the red header is shown so the
+  // (often verbose) error payload doesn't disrupt reading. The user can still expand it.
+  const [open, setOpen] = useState(() => block.status === 'running')
 
   useEffect(() => {
     if (block.status === 'running') {
diff --git a/src/renderer/src/components/chat/message-timeline-process.tsx b/src/renderer/src/components/chat/message-timeline-process.tsx
index 4cfa5ed8d..5e4bf128a 100644
--- a/src/renderer/src/components/chat/message-timeline-process.tsx
+++ b/src/renderer/src/components/chat/message-timeline-process.tsx
@@ -1,7 +1,21 @@
 import type { KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent, ReactElement, RefObject } from 'react'
 import { useState } from 'react'
 import { useTranslation } from 'react-i18next'
-import { ChevronDown, ChevronRight, Minimize2 } from 'lucide-react'
+import type { LucideIcon } from 'lucide-react'
+import {
+  Brain,
+  BookOpen,
+  ChevronDown,
+  ChevronRight,
+  FolderOpen,
+  ListTodo,
+  MessageSquareQuote,
+  Minimize2,
+  PencilLine,
+  Search,
+  Terminal,
+  Wrench
+} from 'lucide-react'
 import type { ChatBlock, ToolBlock } from '../../agent/types'
 import { extractUnifiedDiffText } from '../../lib/diff-stats'
 import { useDeferredRender } from '../../hooks/use-deferred-render'
@@ -13,17 +27,56 @@ import { AssistantMarkdown } from './AssistantMarkdown'
 import { MessageBubble } from './message-timeline-bubbles'
 import { blockHasPendingRuntimeWork, splitThink } from './message-timeline-turns'
 import { formatDuration, formatToolTitle } from './message-timeline-tools'
+import { SubagentGroup } from './SubagentCallCard'
 
 export type ProcessSection = {
   id: string
-  kind: 'reasoning' | 'execution' | 'output'
+  kind: 'reasoning' | 'execution' | 'output' | 'subagent'
   blocks: ChatBlock[]
 }
 
+/**
+ * A `delegate_task` tool call (or any block carrying child runtime metadata)
+ * is rendered as a "Kun Crew" subagent card, not a generic tool row.
+ */
+export function isSubagentBlock(block: ChatBlock): boolean {
+  if (block.kind !== 'tool') return false
+  const meta = block.meta
+  if (meta?.child && typeof meta.child === 'object') return true
+  const toolName = typeof meta?.toolName === 'string' ? meta.toolName.trim() : ''
+  return toolName === 'delegate_task'
+}
+
+function subagentParentTurnId(block: ChatBlock): string {
+  if (block.kind !== 'tool') return ''
+  const child = block.meta?.child
+  if (child && typeof child === 'object') {
+    const parent = (child as Record<string, unknown>).parentTurnId
+    if (typeof parent === 'string' && parent.trim()) return parent.trim()
+  }
+  return ''
+}
+
 export function groupProcessSections(blocks: ChatBlock[]): ProcessSection[] {
   const sections: ProcessSection[] = []
 
   for (const block of blocks) {
+    if (isSubagentBlock(block)) {
+      const last = sections[sections.length - 1]
+      // Coalesce sibling delegations of one turn (same parentTurnId) into one
+      // swarm section. Blocks without a parentTurnId only merge with an
+      // adjacent parentTurnId-less subagent run.
+      if (last && last.kind === 'subagent') {
+        const lastParent = subagentParentTurnId(last.blocks[0])
+        const parent = subagentParentTurnId(block)
+        if (lastParent === parent) {
+          last.blocks.push(block)
+          continue
+        }
+      }
+      sections.push({ id: `subagent-${block.id}`, kind: 'subagent', blocks: [block] })
+      continue
+    }
     const kind =
       block.kind === 'reasoning'
         ? 'reasoning'
@@ -154,6 +207,11 @@ export function ProcessSectionRow({
 }): ReactElement {
   const { t } = useTranslation('common')
   const [userExpanded, setUserExpanded] = useState<boolean | null>(null)
+
+  if (section.kind === 'subagent') {
+    return <SubagentGroup blocks={section.blocks} />
+  }
+
   const assistantBlocks =
     section.kind === 'output'
       ? section.blocks.filter(
@@ -165,7 +223,7 @@ export function ProcessSectionRow({
   const errorTone = processSectionErrorTone(section.blocks)
   const hasError = errorTone !== null
   const defaultExpanded =
-    hasError ||
+    (processing && hasError) ||
     sectionHasPendingApproval(section) ||
     (active && section.kind === 'reasoning') ||
     (processing && section.kind === 'execution' && sectionHasRequestUserInput(section))
@@ -176,6 +234,7 @@ export function ProcessSectionRow({
     reasoningDurationMs,
     singleReasoningSection
   })
+  const SectionIcon = processSectionIcon(section)
   const reasoningText = section.kind === 'reasoning' ? getReasoningSectionText(section) : ''
   const canToggleSection = hasDetails && !forceExpanded
   const showActiveError = active && hasError
@@ -226,6 +285,7 @@ export function ProcessSectionRow({
               <span className={`h-2 w-2 rounded-full ${processErrorDotClass(errorTone)}`} />
             </span>
           ) : null}
+          {SectionIcon ? <ProcessGlyph Icon={SectionIcon} /> : null}
           <span className={active && !hasError ? 'ds-shiny-text' : ''}>{title}</span>
           {expanded ? (
             <ChevronDown className="h-3.5 w-3.5 shrink-0 opacity-45" strokeWidth={1.8} />
@@ -244,6 +304,7 @@ export function ProcessSectionRow({
               <span className={`h-2 w-2 rounded-full ${processErrorDotClass(errorTone)}`} />
             </span>
           ) : null}
+          {SectionIcon ? <ProcessGlyph Icon={SectionIcon} /> : null}
           <span className={active && !hasError ? 'ds-shiny-text' : ''}>{title}</span>
         </div>
       )}
@@ -316,13 +377,15 @@ function ProcessStackRows({
         const autoOpenPending = processBlockIsAutoOpenPending(block, processing) || isPendingApproval(block)
         const errorTone = processBlockErrorTone(block)
         const isError = errorTone !== null
-        const defaultOpen = isError
+        // Tool-call errors stay collapsed (red header only); other error blocks still auto-open.
+        const defaultOpen = isError && block.kind !== 'tool'
         const forceOpen = autoOpenPending || autoOpenRequestInput
         const userClosed = closedBlockIds.has(block.id)
         const userOpened = openBlockId === block.id
         const open = canExpand && (forceOpen || userOpened || (defaultOpen && !userClosed))
         const rowActive = processBlockIsActive(block, processing)
         const canToggle = canExpand && !forceOpen
+        const RowIcon = processBlockIcon(block)
         const handleToggle = (): void => {
           if (!canToggle) return
           if (open) {
@@ -369,6 +432,7 @@ function ProcessStackRows({
                   : 'text-ds-faint hover:text-ds-muted'
               } ${canToggle ? 'cursor-pointer hover:bg-ds-hover/45' : 'cursor-default'}`}
             >
+              {RowIcon ? <ProcessGlyph Icon={RowIcon} /> : null}
               <span className={`min-w-0 flex-1 truncate ${rowActive && !isError ? 'ds-shiny-text' : ''}`}>
                 <ProcessSummaryText block={block} summary={summary} />
               </span>
@@ -429,7 +493,8 @@ function ProcessEntryRow({
   const errorTone = processBlockErrorTone(block)
   const isError = errorTone !== null
   const forceOpen = isAutoOpenPending || isAssistantProcessText || isStreamingAssistant
-  const defaultOpen = isError
+  // Tool-call errors stay collapsed (red header only); other error blocks still auto-open.
+  const defaultOpen = isError && block.kind !== 'tool'
   const open =
     canExpand &&
     (forceOpen || (userOpen ?? defaultOpen))
@@ -438,6 +503,7 @@ function ProcessEntryRow({
   const rowActive = isRunningTool || isAutoOpenPending || isStreamingAssistant
   const wrapSummary = (block.kind === 'system' && !canExpand) || isAssistantProcessText
   const canToggle = canExpand && !forceOpen
+  const RowIcon = processBlockIcon(block)
   const handleToggle = (): void => {
     if (!canToggle) return
     setUserOpen(!open)
@@ -471,9 +537,7 @@ function ProcessEntryRow({
             : 'cursor-default'
         }`}
       >
-        {!rowActive && block.kind === 'compaction' ? (
-          <Minimize2 className="mt-1 h-3 w-3 shrink-0 opacity-70" strokeWidth={2} />
-        ) : null}
+        {RowIcon ? <ProcessGlyph Icon={RowIcon} className="mt-1" /> : null}
         <span
           className={`min-w-0 flex-1 ${wrapSummary ? 'whitespace-pre-wrap break-words' : 'truncate'} ${
             rowActive && !isError ? 'ds-shiny-text' : ''
@@ -525,6 +589,16 @@ function ProcessEntryRow({
   )
 }
 
+function ProcessGlyph({
+  Icon,
+  className = 'mt-0.5'
+}: {
+  Icon: LucideIcon
+  className?: string
+}): ReactElement {
+  return <Icon className={`${className} h-3.5 w-3.5 shrink-0 opacity-75`} strokeWidth={1.9} />
+}
+
 function describeProcessSection(
   section: ProcessSection,
   t: (key: string, opts?: Record<string, unknown>) => string,
@@ -611,6 +685,74 @@ function summarizeExecutionSection(
   return t('processSteps', { count: blocks.length })
 }
 
+function processSectionIcon(section: ProcessSection): LucideIcon | null {
+  if (section.kind === 'reasoning') return Brain
+  if (section.kind === 'output') return MessageSquareQuote
+
+  const toolIcons = section.blocks
+    .map(processBlockIcon)
+    .filter((icon): icon is LucideIcon => icon !== null)
+  if (toolIcons.length === 0) return null
+  const [first] = toolIcons
+  return toolIcons.every((icon) => icon === first) ? first : Wrench
+}
+
+function processBlockIcon(block: ChatBlock): LucideIcon | null {
+  if (block.kind === 'reasoning') return Brain
+  if (block.kind === 'assistant') return MessageSquareQuote
+  if (block.kind === 'compaction') return Minimize2
+  if (block.kind === 'approval') return Wrench
+  if (block.kind === 'user_input') return MessageSquareQuote
+  if (block.kind !== 'tool') return null
+  return toolBlockIcon(block)
+}
+
+function toolBlockIcon(block: ToolBlock): LucideIcon {
+  const toolName = toolNameForBlock(block)
+  switch (toolName) {
+    case 'bash':
+    case 'shell':
+    case 'terminal':
+    case 'run_command':
+    case 'exec':
+      return Terminal
+    case 'read':
+    case 'read_file':
+      return BookOpen
+    case 'write':
+    case 'write_file':
+    case 'edit':
+    case 'edit_file':
+    case 'apply_patch':
+    case 'create_file':
+      return PencilLine
+    case 'grep':
+    case 'grep_files':
+    case 'search':
+    case 'search_files':
+    case 'find':
+      return Search
+    case 'ls':
+    case 'list':
+    case 'list_dir':
+      return FolderOpen
+    case 'create_plan':
+    case 'update_plan':
+      return ListTodo
+    default:
+      break
+  }
+
+  if (block.toolKind === 'command_execution') return Terminal
+  if (block.toolKind === 'file_change') return PencilLine
+  return Wrench
+}
+
+function toolNameForBlock(block: ToolBlock): string {
+  const rawSummary = block.summary?.trim() ?? ''
+  return (extractToolName(rawSummary) || readMetaString(block.meta, 'toolName') || '').toLowerCase()
+}
+
 function splitVerb(summary: string): { verb: string; rest: string } {
   const trimmed = summary.trim()
   if (!trimmed) return { verb: '', rest: '' }
@@ -746,6 +888,10 @@ function builtInToolLabel(
     case 'bash':
     case 'shell':
       return t('toolBuiltinBash')
+    case 'delegate_task':
+      // Routed to SubagentCallCard before the generic row; labeled here as a
+      // defensive fallback so an ungrouped delegate block never reads as raw JSON.
+      return t('toolBuiltinDelegate')
     default:
       return undefined
   }
@@ -872,8 +1018,7 @@ export function summarizeToolBlock(
   t: (key: string, opts?: Record<string, unknown>) => string
 ): string {
   const rawSummary = block.summary?.trim() ?? ''
-  const metaToolName = readMetaString(block.meta, 'toolName')
-  const toolName = extractToolName(rawSummary) || metaToolName || ''
+  const toolName = toolNameForBlock(block)
   const label = builtInToolLabel(toolName, t) || humanizeToolName(toolName) || formatToolTitle(block, t)
   const sourceText = [rawSummary, block.detail ?? ''].filter(Boolean).join('\n')
   const filePath = toolFilePath(block)
diff --git a/src/renderer/src/components/chat/use-composer-user-input.ts b/src/renderer/src/components/chat/use-composer-user-input.ts
new file mode 100644
index 000000000..3c429e8b8
--- /dev/null
+++ b/src/renderer/src/components/chat/use-composer-user-input.ts
@@ -0,0 +1,160 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type {
+  ChatBlock,
+  UserInputAnswer,
+  UserInputOption,
+  UserInputQuestion
+} from '../../agent/types'
+import {
+  allAnswered,
+  answerFromOption,
+  answerFromTypedText,
+  answersByQuestionId,
+  nextUnansweredIndex,
+  orderedAnswers
+} from './user-input-panel-logic'
+
+export type PendingUserInputBlock = Extract<ChatBlock, { kind: 'user_input' }>
+
+type ResolveUserInput = (
+  blockId: string,
+  action: { kind: 'submit'; answers: UserInputAnswer[] } | { kind: 'cancel' }
+) => Promise<void>
+
+/**
+ * Drives the composer-docked ask-user panel. Owns the in-progress answer map
+ * and the stepper index so both the panel (presentational) and the composer's
+ * send/keyboard handlers (type-to-answer) operate on one source of truth.
+ *
+ * Selecting an option or typing an answer for the current question advances to
+ * the next unanswered question, and auto-submits once the last one resolves —
+ * so the common single-question case is a single click.
+ */
+export type ComposerUserInputController = {
+  /** True when there is a pending block with at least one question to answer. */
+  active: boolean
+  block: PendingUserInputBlock | null
+  questions: UserInputQuestion[]
+  /** Index of the question currently shown in the panel. */
+  index: number
+  total: number
+  currentQuestion: UserInputQuestion | null
+  answers: Record<string, UserInputAnswer>
+  isSelected: (questionId: string, optionLabel: string) => boolean
+  isAnswered: (questionId: string) => boolean
+  chooseOption: (question: UserInputQuestion, option: UserInputOption) => void
+  /** Returns true when the text was consumed as the current question's answer. */
+  submitTypedText: (text: string) => boolean
+  goToIndex: (index: number) => void
+  cancel: () => void
+}
+
+export function useComposerUserInput(
+  block: PendingUserInputBlock | null,
+  resolveUserInput: ResolveUserInput
+): ComposerUserInputController {
+  const [answers, setAnswers] = useState<Record<string, UserInputAnswer>>({})
+  const [index, setIndex] = useState(0)
+  // Synchronous one-shot guard: the store only flips block.status away from
+  // 'pending' after the submit RPC resolves, so without this a rapid second
+  // selection (double-click) would dispatch a second submit for the same ask
+  // during the in-flight window. Re-armed when a fresh block arrives.
+  const resolvedRef = useRef(false)
+
+  const blockId = block?.id ?? null
+  const blockAnswers = block?.answers
+  useEffect(() => {
+    setAnswers(answersByQuestionId(blockAnswers))
+    setIndex(0)
+    resolvedRef.current = false
+  }, [blockId, blockAnswers])
+
+  const questions = useMemo(() => block?.questions ?? [], [block])
+  const total = questions.length
+  const safeIndex = total > 0 ? Math.min(index, total - 1) : 0
+  const currentQuestion = total > 0 ? questions[safeIndex] : null
+
+  const applyAnswer = useCallback(
+    (answer: UserInputAnswer) => {
+      if (!block || resolvedRef.current) return
+      const nextMap = { ...answers, [answer.id]: answer }
+      setAnswers(nextMap)
+      if (allAnswered(questions, nextMap)) {
+        resolvedRef.current = true
+        void resolveUserInput(block.id, {
+          kind: 'submit',
+          answers: orderedAnswers(questions, nextMap)
+        })
+        return
+      }
+      setIndex((current) => nextUnansweredIndex(questions, nextMap, current))
+    },
+    [answers, block, questions, resolveUserInput]
+  )
+
+  const chooseOption = useCallback(
+    (question: UserInputQuestion, option: UserInputOption) => {
+      applyAnswer(answerFromOption(question, option))
+    },
+    [applyAnswer]
+  )
+
+  const submitTypedText = useCallback(
+    (text: string): boolean => {
+      if (!currentQuestion || text.trim().length === 0) return false
+      applyAnswer(answerFromTypedText(currentQuestion, text))
+      return true
+    },
+    [applyAnswer, currentQuestion]
+  )
+
+  const cancel = useCallback(() => {
+    if (!block || resolvedRef.current) return
+    resolvedRef.current = true
+    void resolveUserInput(block.id, { kind: 'cancel' })
+  }, [block, resolveUserInput])
+
+  const isSelected = useCallback(
+    (questionId: string, optionLabel: string): boolean => {
+      const answer = answers[questionId]
+      return Boolean(answer && answer.label === optionLabel && answer.value === optionLabel)
+    },
+    [answers]
+  )
+
+  const isAnswered = useCallback(
+    (questionId: string): boolean => Boolean(answers[questionId]),
+    [answers]
+  )
+
+  return useMemo(
+    () => ({
+      active: Boolean(block) && total > 0,
+      block,
+      questions,
+      index: safeIndex,
+      total,
+      currentQuestion,
+      answers,
+      isSelected,
+      isAnswered,
+      chooseOption,
+      submitTypedText,
+      goToIndex: setIndex,
+      cancel
+    }),
+    [
+      answers,
+      block,
+      cancel,
+      chooseOption,
+      currentQuestion,
+      isAnswered,
+      isSelected,
+      questions,
+      safeIndex,
+      submitTypedText,
+      total
+    ]
+  )
+}
diff --git a/src/renderer/src/components/chat/user-input-panel-logic.test.ts b/src/renderer/src/components/chat/user-input-panel-logic.test.ts
new file mode 100644
index 000000000..c3e379c4f
--- /dev/null
+++ b/src/renderer/src/components/chat/user-input-panel-logic.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest'
+import type { UserInputQuestion } from '../../agent/types'
+import {
+  USER_INPUT_FREEFORM_LABEL,
+  USER_INPUT_OTHER_LABEL,
+  allAnswered,
+  answerFromOption,
+  answerFromTypedText,
+  answersByQuestionId,
+  isQuestionAnswered,
+  nextUnansweredIndex,
+  optionsNeedRows,
+  orderedAnswers,
+  shouldShowQuestionHeader
+} from './user-input-panel-logic'
+
+const optionQuestion: UserInputQuestion = {
+  id: 'db',
+  header: 'Scope',
+  question: 'Which database?',
+  options: [
+    { label: 'PostgreSQL', description: '' },
+    { label: 'SQLite', description: 'Embedded' }
+  ]
+}
+
+const freeformQuestion: UserInputQuestion = {
+  id: 'name',
+  header: '',
+  question: 'Service name?',
+  options: []
+}
+
+describe('answerFromOption', () => {
+  it('uses the option label as both label and value', () => {
+    expect(answerFromOption(optionQuestion, optionQuestion.options[0])).toEqual({
+      id: 'db',
+      label: 'PostgreSQL',
+      value: 'PostgreSQL'
+    })
+  })
+})
+
+describe('answerFromTypedText', () => {
+  it('collapses an exact (case/space-insensitive) match onto the option', () => {
+    expect(answerFromTypedText(optionQuestion, '  postgresql ')).toEqual({
+      id: 'db',
+      label: 'PostgreSQL',
+      value: 'PostgreSQL'
+    })
+  })
+
+  it('maps unmatched text on an options question to Other', () => {
+    expect(answerFromTypedText(optionQuestion, 'Turso')).toEqual({
+      id: 'db',
+      label: USER_INPUT_OTHER_LABEL,
+      value: 'Turso'
+    })
+  })
+
+  it('maps text on a free-form question to the freeform label', () => {
+    expect(answerFromTypedText(freeformQuestion, '  billing-api ')).toEqual({
+      id: 'name',
+      label: USER_INPUT_FREEFORM_LABEL,
+      value: 'billing-api'
+    })
+  })
+})
+
+describe('isQuestionAnswered', () => {
+  it('treats a chosen option as answered', () => {
+    expect(isQuestionAnswered(optionQuestion, answerFromOption(optionQuestion, optionQuestion.options[0]))).toBe(true)
+  })
+
+  it('requires non-empty value for Other / free-form', () => {
+    expect(isQuestionAnswered(optionQuestion, { id: 'db', label: USER_INPUT_OTHER_LABEL, value: '   ' })).toBe(false)
+    expect(isQuestionAnswered(optionQuestion, { id: 'db', label: USER_INPUT_OTHER_LABEL, value: 'Turso' })).toBe(true)
+    expect(isQuestionAnswered(freeformQuestion, { id: 'name', label: USER_INPUT_FREEFORM_LABEL, value: '' })).toBe(false)
+  })
+
+  it('is false when there is no answer', () => {
+    expect(isQuestionAnswered(optionQuestion, undefined)).toBe(false)
+  })
+})
+
+describe('multi-question flow helpers', () => {
+  const questions = [optionQuestion, freeformQuestion]
+
+  it('reports all-answered only once every question resolves', () => {
+    const partial = { db: answerFromOption(optionQuestion, optionQuestion.options[0]) }
+    expect(allAnswered(questions, partial)).toBe(false)
+    const full = { ...partial, name: answerFromTypedText(freeformQuestion, 'svc') }
+    expect(allAnswered(questions, full)).toBe(true)
+  })
+
+  it('advances to the next unanswered question, wrapping', () => {
+    const map = { db: answerFromOption(optionQuestion, optionQuestion.options[0]) }
+    expect(nextUnansweredIndex(questions, map, 0)).toBe(1)
+    const full = { ...map, name: answerFromTypedText(freeformQuestion, 'svc') }
+    expect(nextUnansweredIndex(questions, full, 0)).toBe(0)
+  })
+
+  it('orders answers by question order, skipping gaps', () => {
+    const map = { name: answerFromTypedText(freeformQuestion, 'svc') }
+    expect(orderedAnswers(questions, map)).toEqual([{ id: 'name', label: 'Answer', value: 'svc' }])
+  })
+})
+
+describe('answersByQuestionId', () => {
+  it('keys answers and tolerates undefined', () => {
+    expect(answersByQuestionId(undefined)).toEqual({})
+    expect(answersByQuestionId([{ id: 'a', label: 'x', value: 'x' }])).toEqual({
+      a: { id: 'a', label: 'x', value: 'x' }
+    })
+  })
+})
+
+describe('presentation helpers', () => {
+  it('uses rows only when an option carries a description', () => {
+    expect(optionsNeedRows(optionQuestion.options)).toBe(true)
+    expect(optionsNeedRows([{ label: 'A', description: '' }])).toBe(false)
+  })
+
+  it('suppresses the placeholder "input" header for a lone question', () => {
+    expect(shouldShowQuestionHeader({ ...freeformQuestion, header: 'input' }, 1)).toBe(false)
+    expect(shouldShowQuestionHeader({ ...freeformQuestion, header: 'input' }, 2)).toBe(true)
+    expect(shouldShowQuestionHeader(optionQuestion, 1)).toBe(true)
+    expect(shouldShowQuestionHeader(freeformQuestion, 1)).toBe(false)
+  })
+})
diff --git a/src/renderer/src/components/chat/user-input-panel-logic.ts b/src/renderer/src/components/chat/user-input-panel-logic.ts
new file mode 100644
index 000000000..309122c2b
--- /dev/null
+++ b/src/renderer/src/components/chat/user-input-panel-logic.ts
@@ -0,0 +1,122 @@
+import type { UserInputAnswer, UserInputOption, UserInputQuestion } from '../../agent/types'
+
+/**
+ * Shared, framework-free helpers for the user_input / ask-user interaction.
+ *
+ * The runtime models each question as having exactly one answer
+ * (`UserInputAnswer` = `{ id, label, value }`), so selection is single-choice
+ * per question. Free-form questions (no options) and the "type your own"
+ * escape hatch both resolve to a synthetic label below.
+ *
+ * Both the composer-docked panel and the (read-only) timeline bubble import
+ * these so the answer shape never drifts between the two surfaces.
+ */
+export const USER_INPUT_OTHER_LABEL = 'Other'
+export const USER_INPUT_FREEFORM_LABEL = 'Answer'
+
+export function answersByQuestionId(
+  answers: UserInputAnswer[] | undefined
+): Record<string, UserInputAnswer> {
+  const out: Record<string, UserInputAnswer> = {}
+  for (const answer of answers ?? []) {
+    out[answer.id] = answer
+  }
+  return out
+}
+
+export function answerFromOption(
+  question: UserInputQuestion,
+  option: UserInputOption
+): UserInputAnswer {
+  return { id: question.id, label: option.label, value: option.label }
+}
+
+/**
+ * Map free-typed composer text onto the current question. An exact (case- and
+ * whitespace-insensitive) match against an option collapses to that option;
+ * otherwise it becomes a custom "Other" answer (options present) or a plain
+ * free-form "Answer" (no options).
+ */
+export function answerFromTypedText(
+  question: UserInputQuestion,
+  text: string
+): UserInputAnswer {
+  const trimmed = text.trim()
+  const matched = question.options.find(
+    (option) => option.label.trim().toLowerCase() === trimmed.toLowerCase()
+  )
+  if (matched) {
+    return { id: question.id, label: matched.label, value: matched.label }
+  }
+  const label = question.options.length > 0 ? USER_INPUT_OTHER_LABEL : USER_INPUT_FREEFORM_LABEL
+  return { id: question.id, label, value: trimmed }
+}
+
+export function isQuestionAnswered(
+  question: UserInputQuestion,
+  answer: UserInputAnswer | undefined
+): boolean {
+  if (!answer) return false
+  if (question.options.length === 0 || answer.label === USER_INPUT_OTHER_LABEL) {
+    return answer.value.trim().length > 0
+  }
+  return true
+}
+
+export function allAnswered(
+  questions: UserInputQuestion[],
+  map: Record<string, UserInputAnswer>
+): boolean {
+  return questions.every((question) => isQuestionAnswered(question, map[question.id]))
+}
+
+export function orderedAnswers(
+  questions: UserInputQuestion[],
+  map: Record<string, UserInputAnswer>
+): UserInputAnswer[] {
+  const out: UserInputAnswer[] = []
+  for (const question of questions) {
+    const answer = map[question.id]
+    if (answer) out.push(answer)
+  }
+  return out
+}
+
+/**
+ * The next question that still needs an answer, scanning forward (wrapping)
+ * from `from`. Returns `from` when everything is answered, so callers should
+ * check {@link allAnswered} first to decide submit-vs-advance.
+ */
+export function nextUnansweredIndex(
+  questions: UserInputQuestion[],
+  map: Record<string, UserInputAnswer>,
+  from: number
+): number {
+  const total = questions.length
+  for (let offset = 1; offset <= total; offset += 1) {
+    const idx = (from + offset) % total
+    if (!isQuestionAnswered(questions[idx], map[questions[idx].id])) {
+      return idx
+    }
+  }
+  return from
+}
+
+/** Options carrying descriptions render as full-width rows; bare ones as chips. */
+export function optionsNeedRows(options: UserInputOption[]): boolean {
+  return options.some((option) => option.description?.trim().length > 0)
+}
+
+/**
+ * The runtime sometimes sends a placeholder header of "input" for a lone
+ * question; that adds no information, so it is suppressed.
+ */
+export function shouldShowQuestionHeader(
+  question: UserInputQuestion,
+  totalQuestions: number
+): boolean {
+  const header = question.header?.trim()
+  if (!header) return false
+  if (totalQuestions === 1 && header.toLowerCase() === 'input') return false
+  return true
+}
diff --git a/src/renderer/src/components/initial-setup-save.test.ts b/src/renderer/src/components/initial-setup-save.test.ts
index 399dd7a68..843c87fbd 100644
--- a/src/renderer/src/components/initial-setup-save.test.ts
+++ b/src/renderer/src/components/initial-setup-save.test.ts
@@ -35,20 +35,31 @@ function settingsWithActiveXiaomiWithoutKey(): AppSettingsV1 {
 describe('initialSetupSelection', () => {
   it('preselects the active provider card when it is a known preset', () => {
     const selection = initialSetupSelection(settingsWithActiveXiaomiWithoutKey())
-    expect(selection).toEqual({ presetId: 'xiaomi', mode: 'api' })
+    expect(selection).toEqual({ presetId: 'xiaomi', mode: 'api', permissionMode: 'bypass' })
   })
 
   it('preselects the token plan mode for token plan profiles', () => {
     const current = settings({ agents: { kun: { providerId: 'minimax-token-plan' } } })
-    expect(initialSetupSelection(current)).toEqual({ presetId: 'minimax', mode: 'token-plan' })
+    expect(initialSetupSelection(current)).toEqual({
+      presetId: 'minimax',
+      mode: 'token-plan',
+      permissionMode: 'bypass'
+    })
   })
 
   it('falls back to deepseek for unknown or empty active providers', () => {
-    expect(initialSetupSelection(settings())).toEqual({ presetId: 'deepseek', mode: 'api' })
+    expect(initialSetupSelection(settings())).toEqual({ presetId: 'deepseek', mode: 'api', permissionMode: 'bypass' })
     expect(initialSetupSelection(settings({ agents: { kun: { providerId: 'custom-provider-2' } } })))
-      .toEqual({ presetId: 'deepseek', mode: 'api' })
+      .toEqual({ presetId: 'deepseek', mode: 'api', permissionMode: 'bypass' })
     expect(initialSetupSelection(settings({ agents: { kun: { providerId: 'litellm' } } })))
-      .toEqual({ presetId: 'deepseek', mode: 'api' })
+      .toEqual({ presetId: 'deepseek', mode: 'api', permissionMode: 'bypass' })
+  })
+
+  it('preselects the saved permission mode', () => {
+    const current = settings({
+      agents: { kun: { approvalPolicy: 'on-request', sandboxMode: 'workspace-write' } }
+    })
+    expect(initialSetupSelection(current).permissionMode).toBe('workspace-write')
   })
 })
 
@@ -83,7 +94,7 @@ describe('initialSetupDrafts', () => {
     for (const id of excludedIds) {
       expect(drafts[id]).toBeUndefined()
       expect(initialSetupSelection(settings({ agents: { kun: { providerId: id } } })))
-        .toEqual({ presetId: 'deepseek', mode: 'api' })
+        .toEqual({ presetId: 'deepseek', mode: 'api', permissionMode: 'bypass' })
     }
   })
 })
@@ -98,6 +109,68 @@ describe('buildInitialSetupSettings', () => {
     expect(getActiveAgentApiKey(next)).toBe('sk-deepseek-key')
   })
 
+  it('stores the selected default Agent permission mode', () => {
+    const current = settingsWithActiveXiaomiWithoutKey()
+    const drafts = initialSetupDrafts(current)
+    const next = buildInitialSetupSettings(current, drafts, {
+      presetId: 'deepseek',
+      mode: 'api',
+      permissionMode: 'workspace-write'
+    })
+
+    const runtime = getKunRuntimeSettings(next)
+    expect(runtime.approvalPolicy).toBe('on-request')
+    expect(runtime.sandboxMode).toBe('workspace-write')
+  })
+
+  it('preserves a non-UI permission policy when the selector is untouched', () => {
+    // A persisted policy the 5-mode UI cannot represent: stricter approval gate
+    // plus a sandboxed filesystem. Reopening onboarding seeds the selector from
+    // the lossy fromSettings mapping (-> 'read-only'); when the user does not
+    // move it, the save must leave the strict pair intact rather than rewrite it
+    // to 'on-request'/'danger-full-access'.
+    const current = settings({
+      provider: { apiKey: 'sk-deepseek-key' },
+      agents: {
+        kun: { providerId: 'deepseek', approvalPolicy: 'never', sandboxMode: 'external-sandbox' }
+      }
+    })
+    const seededMode = initialSetupSelection(current).permissionMode
+    expect(seededMode).toBe('read-only')
+
+    const next = buildInitialSetupSettings(current, initialSetupDrafts(current), {
+      presetId: 'deepseek',
+      mode: 'api',
+      permissionMode: seededMode
+    })
+
+    const runtime = getKunRuntimeSettings(next)
+    expect(runtime.approvalPolicy).toBe('never')
+    expect(runtime.sandboxMode).toBe('external-sandbox')
+    expect(runtime.approvalPolicy).not.toBe('on-request')
+    expect(runtime.sandboxMode).not.toBe('danger-full-access')
+  })
+
+  it('writes the permission pair only when the user picks a different mode', () => {
+    // Same strict starting policy, but this time the user explicitly chooses a
+    // representable mode, so the concrete pair for that mode must be written.
+    const current = settings({
+      provider: { apiKey: 'sk-deepseek-key' },
+      agents: {
+        kun: { providerId: 'deepseek', approvalPolicy: 'never', sandboxMode: 'external-sandbox' }
+      }
+    })
+    const next = buildInitialSetupSettings(current, initialSetupDrafts(current), {
+      presetId: 'deepseek',
+      mode: 'api',
+      permissionMode: 'workspace-write'
+    })
+
+    const runtime = getKunRuntimeSettings(next)
+    expect(runtime.approvalPolicy).toBe('on-request')
+    expect(runtime.sandboxMode).toBe('workspace-write')
+  })
+
   it('syncs the deepseek draft into the provider profile used by settings', () => {
     const current = settings({
       provider: {
diff --git a/src/renderer/src/components/initial-setup-save.ts b/src/renderer/src/components/initial-setup-save.ts
index da063959d..388c93b93 100644
--- a/src/renderer/src/components/initial-setup-save.ts
+++ b/src/renderer/src/components/initial-setup-save.ts
@@ -1,14 +1,18 @@
 import {
   DEFAULT_MODEL_PROVIDER_ID,
+  KUN_TOOL_PERMISSION_MODES,
   MODEL_PROVIDER_PRESETS,
   applyKunRuntimePatch,
   getKunRuntimeSettings,
   getModelProviderSettings,
+  kunToolPermissionModeFromSettings,
+  kunToolPermissionModeSettings,
   modelProviderPresetProfile,
   modelProviderTokenPlanProfile,
   normalizeAppSettings,
   tokenPlanProviderId,
   type AppSettingsV1,
+  type KunToolPermissionMode,
   type KunRuntimeSettingsPatchV1,
   type ModelProviderPreset,
   type ModelProviderProfileV1
@@ -27,6 +31,7 @@ export type InitialSetupDrafts = Record<string, InitialSetupDraft>
 export type InitialSetupSelection = {
   presetId: string
   mode: InitialSetupAccessMode
+  permissionMode: KunToolPermissionMode
 }
 
 const INITIAL_SETUP_PROVIDER_PRESET_IDS = new Set(['xiaomi', 'minimax'])
@@ -35,7 +40,7 @@ export const INITIAL_SETUP_PROVIDER_PRESETS = MODEL_PROVIDER_PRESETS.filter(
   (preset) => INITIAL_SETUP_PROVIDER_PRESET_IDS.has(preset.id)
 )
 
-export function initialSetupProfileId(selection: InitialSetupSelection): string {
+export function initialSetupProfileId(selection: Pick<InitialSetupSelection, 'presetId' | 'mode'>): string {
   if (selection.presetId === DEFAULT_MODEL_PROVIDER_ID) return DEFAULT_MODEL_PROVIDER_ID
   return selection.mode === 'token-plan' ? tokenPlanProviderId(selection.presetId) : selection.presetId
 }
@@ -66,14 +71,16 @@ export function initialSetupDrafts(settings: AppSettingsV1): InitialSetupDrafts
 
 /** Card and mode to preselect: the active provider when it is one of ours, DeepSeek otherwise. */
 export function initialSetupSelection(settings: AppSettingsV1): InitialSetupSelection {
-  const activeId = getKunRuntimeSettings(settings).providerId.trim()
+  const runtime = getKunRuntimeSettings(settings)
+  const activeId = runtime.providerId.trim()
+  const permissionMode = kunToolPermissionModeFromSettings(runtime)
   for (const preset of INITIAL_SETUP_PROVIDER_PRESETS) {
-    if (activeId === preset.id) return { presetId: preset.id, mode: 'api' }
+    if (activeId === preset.id) return { presetId: preset.id, mode: 'api', permissionMode }
     if (preset.tokenPlan && activeId === tokenPlanProviderId(preset.id)) {
-      return { presetId: preset.id, mode: 'token-plan' }
+      return { presetId: preset.id, mode: 'token-plan', permissionMode }
     }
   }
-  return { presetId: DEFAULT_MODEL_PROVIDER_ID, mode: 'api' }
+  return { presetId: DEFAULT_MODEL_PROVIDER_ID, mode: 'api', permissionMode }
 }
 
 export type InitialSetupAutoWirePlan = {
@@ -126,7 +133,7 @@ export function initialSetupAutoWirePlan(
 export function buildInitialSetupSettings(
   settings: AppSettingsV1,
   drafts: InitialSetupDrafts,
-  selection: InitialSetupSelection
+  selection: Pick<InitialSetupSelection, 'presetId' | 'mode'> & Partial<Pick<InitialSetupSelection, 'permissionMode'>>
 ): AppSettingsV1 {
   const provider = getModelProviderSettings(settings)
   const profiles = new Map(provider.providers.map((profile) => [profile.id, profile]))
@@ -170,10 +177,23 @@ export function buildInitialSetupSettings(
   )
   const switchingProvider = (runtime.providerId.trim() || DEFAULT_MODEL_PROVIDER_ID) !== selectedId
   const wire = initialSetupAutoWirePlan(settings, drafts)
+  // Only rewrite approvalPolicy/sandboxMode when the user actually moved the
+  // permission selector. The mode<->settings mapping is lossy (only 5 of the
+  // policy/sandbox combos are representable), so emitting the pair when the
+  // selection still matches the persisted policy would silently weaken values
+  // the UI cannot represent — e.g. demote approvalPolicy 'never'/'suggest' or
+  // escalate an 'external-sandbox' sandbox. When unchanged we omit the spread
+  // so applyKunRuntimePatch leaves the existing pair untouched.
+  const currentPermissionMode = kunToolPermissionModeFromSettings(runtime)
+  const selectedPermissionMode = selection.permissionMode && KUN_TOOL_PERMISSION_MODES.includes(selection.permissionMode)
+    ? selection.permissionMode
+    : currentPermissionMode
+  const permissionChanged = selectedPermissionMode !== currentPermissionMode
   const kunPatch: KunRuntimeSettingsPatchV1 = {
     providerId: selectedId,
     apiKey: '',
     baseUrl: '',
+    ...(permissionChanged ? kunToolPermissionModeSettings(selectedPermissionMode) : {}),
     ...(switchingProvider && selectedProfile?.models[0] ? { model: selectedProfile.models[0] } : {}),
     ...(wire.speechProviderId
       ? { speechToText: { enabled: true, providerId: wire.speechProviderId } }
diff --git a/src/renderer/src/components/mcp/McpServersEditor.tsx b/src/renderer/src/components/mcp/McpServersEditor.tsx
index 4af14f1d8..a29c2b401 100644
--- a/src/renderer/src/components/mcp/McpServersEditor.tsx
+++ b/src/renderer/src/components/mcp/McpServersEditor.tsx
@@ -269,6 +269,17 @@ function McpServerCard({
               />
               {commandError ? <FieldError message={commandError} /> : null}
             </label>
+            <label className={labelClass}>
+              {t('mcpFormCwd')}
+              <input
+                value={server.cwd}
+                disabled={disabled}
+                placeholder={t('mcpFormCwdPlaceholder')}
+                onChange={(e) => onChange({ cwd: e.target.value })}
+                className={inputClass}
+              />
+              <span className="text-[11px] font-normal text-ds-faint">{t('mcpFormCwdHint')}</span>
+            </label>
             <label className={labelClass}>
               {t('mcpFormArgs')}
               <textarea
diff --git a/src/renderer/src/components/mcp/mcp-config-form.test.ts b/src/renderer/src/components/mcp/mcp-config-form.test.ts
index e82e28457..c9b7526d7 100644
--- a/src/renderer/src/components/mcp/mcp-config-form.test.ts
+++ b/src/renderer/src/components/mcp/mcp-config-form.test.ts
@@ -37,6 +37,7 @@ describe('parseMcpConfigText', () => {
             github: {
               transport: 'stdio',
               command: 'npx',
+              cwd: '/workspace/project',
               args: ['-y', 'gh-mcp'],
               env: { TOKEN: 'abc' }
             }
@@ -49,6 +50,7 @@ describe('parseMcpConfigText', () => {
     expect(server.name).toBe('github')
     expect(server.transport).toBe('stdio')
     expect(server.command).toBe('npx')
+    expect(server.cwd).toBe('/workspace/project')
     expect(server.args).toEqual(['-y', 'gh-mcp'])
     expect(server.env).toEqual([{ key: 'TOKEN', value: 'abc' }])
     // No explicit trustScope / roots -> defaults to user.
@@ -174,6 +176,7 @@ describe('serializeMcpConfig', () => {
       ...createBlankMcpServer('stdio'),
       name: 's',
       command: 'run',
+      cwd: '/workspace/project',
       args: ['--flag'],
       env: [{ key: 'K', value: 'V' }],
       // url/headers should be ignored for stdio
@@ -183,6 +186,7 @@ describe('serializeMcpConfig', () => {
     expect(serializeMcpServer(stdio)).toEqual({
       transport: 'stdio',
       command: 'run',
+      cwd: '/workspace/project',
       args: ['--flag'],
       env: { K: 'V' },
       trustScope: 'user'
@@ -195,6 +199,7 @@ describe('serializeMcpConfig', () => {
       headers: [{ key: 'Authorization', value: 'Bearer x' }],
       // command/args/env should be ignored for http
       command: 'ignored',
+      cwd: '/ignored',
       args: ['ignored'],
       env: [{ key: 'IGN', value: 'V' }]
     }
diff --git a/src/renderer/src/components/mcp/mcp-config-form.ts b/src/renderer/src/components/mcp/mcp-config-form.ts
index 515789f1a..090bab986 100644
--- a/src/renderer/src/components/mcp/mcp-config-form.ts
+++ b/src/renderer/src/components/mcp/mcp-config-form.ts
@@ -25,6 +25,8 @@ export type McpFormServer = {
   enabled: boolean
   transport: McpTransport
   command: string
+  /** Working directory for stdio servers. Blank = runtime default/fallback. */
+  cwd: string
   /** One CLI argument per entry; edited as a multiline textarea (one/line). */
   args: string[]
   env: McpKeyValue[]
@@ -118,6 +120,7 @@ function parseServerEntry(name: string, raw: unknown): McpFormServer {
     enabled,
     transport,
     command,
+    cwd: asString(record.cwd).trim(),
     args: asStringArray(record.args),
     env: asKeyValues(record.env),
     url,
@@ -136,6 +139,7 @@ export function createBlankMcpServer(transport: McpTransport = 'stdio'): McpForm
     enabled: true,
     transport,
     command: '',
+    cwd: '',
     args: [],
     env: [],
     url: '',
@@ -200,6 +204,7 @@ export function serializeMcpServer(server: McpFormServer): Record<string, unknow
 
   if (server.transport === 'stdio') {
     if (server.command.trim()) out.command = server.command.trim()
+    if (server.cwd.trim()) out.cwd = server.cwd.trim()
     const args = server.args.map((arg) => arg).filter((arg) => arg.length > 0)
     if (args.length > 0) out.args = args
     const env = keyValuesToRecord(server.env)
diff --git a/src/renderer/src/components/sdd/SddDraftEditorView.tsx b/src/renderer/src/components/sdd/SddDraftEditorView.tsx
index 3856fbb5d..b3bcd09d2 100644
--- a/src/renderer/src/components/sdd/SddDraftEditorView.tsx
+++ b/src/renderer/src/components/sdd/SddDraftEditorView.tsx
@@ -132,7 +132,7 @@ function SddDesignContextBar({
   const chipClass = (active: boolean): string =>
     `rounded-full border px-2.5 py-1 text-[12px] transition-colors ${
       active
-        ? 'border-ds-accent bg-ds-accent/12 text-ds-accent'
+        ? 'border-accent bg-accent/12 text-accent'
         : 'border-ds-border-muted bg-ds-main/40 text-ds-muted hover:text-ds-ink'
     }`
   return (
@@ -143,7 +143,7 @@ function SddDesignContextBar({
         className="flex w-full items-center justify-between gap-3 px-3 py-2 text-left"
       >
         <span className="flex items-center gap-1.5 text-[13px] font-medium text-ds-ink">
-          <Sparkles className="h-3.5 w-3.5 text-ds-accent" />
+          <Sparkles className="h-3.5 w-3.5 text-accent" />
           {t('sddDesignContextTitle')}
         </span>
         <span className="min-w-0 flex-1 truncate text-right text-[12px] text-ds-faint">{summary}</span>
@@ -185,7 +185,7 @@ function SddDesignContextBar({
                 value={brandColor}
                 placeholder={t('sddDesignBrandColorPlaceholder')}
                 onChange={(e) => onChange({ brandColor: e.target.value })}
-                className="h-7 flex-1 rounded-lg border border-ds-border-muted bg-ds-main/40 px-2 text-[12px] text-ds-ink outline-none focus:border-ds-accent"
+                className="h-7 flex-1 rounded-lg border border-ds-border-muted bg-ds-main/40 px-2 text-[12px] text-ds-ink outline-none focus:border-accent"
               />
               {brandColor ? (
                 <button
diff --git a/src/renderer/src/components/settings-section-agents.test.ts b/src/renderer/src/components/settings-section-agents.test.ts
index 29ae94c54..26aee4e46 100644
--- a/src/renderer/src/components/settings-section-agents.test.ts
+++ b/src/renderer/src/components/settings-section-agents.test.ts
@@ -47,9 +47,9 @@ const labels: Record<string, string> = {
   modelProviderBaseUrl: 'Provider base URL',
   modelProviderEndpointFormat: 'Endpoint format',
   modelProviderFetchEmpty: 'No models found',
-  modelEndpointChatCompletions: '/v1/chat/completions',
-  modelEndpointResponses: '/v1/responses',
-  modelEndpointMessages: '/v1/messages',
+  modelEndpointChatCompletions: '/v1/chat/completions (openai)',
+  modelEndpointResponses: '/v1/responses (openai)',
+  modelEndpointMessages: '/v1/messages (anthropic)',
   modelEndpointCustomEndpoint: 'Custom full endpoint',
   modelProviderModels: 'Provider models',
   modelProviderImageCapability: 'Image capability',
@@ -484,7 +484,7 @@ describe('AgentsSettingsSection Kun diagnostics smoke', () => {
     expect(providerIdInput).not.toContain('readOnly')
     expect(providerIdInput).not.toContain('readonly')
     expect(html).toContain('Endpoint format')
-    expect(html).toContain('<option value="messages" selected="">/v1/messages</option>')
+    expect(html).toContain('<option value="messages" selected="">/v1/messages (anthropic)</option>')
     expect(html).toContain('<option value="custom_endpoint">Custom full endpoint</option>')
     expect(html).toContain('Enter provider API key')
     expect(html).not.toContain('Inherit API key')
diff --git a/src/renderer/src/components/settings-section-agents.tsx b/src/renderer/src/components/settings-section-agents.tsx
index 07f075183..fc0d870d8 100644
--- a/src/renderer/src/components/settings-section-agents.tsx
+++ b/src/renderer/src/components/settings-section-agents.tsx
@@ -1322,18 +1322,7 @@ export function AgentsSettingsSection({ ctx }: { ctx: Record<string, any> }): Re
                     description={t('kunCompactionSummaryDesc')}
                     wideControl
                     control={
-                      <div className="grid gap-3 sm:grid-cols-4">
-                        <label className="flex min-w-0 flex-col gap-1.5 text-[12px] font-medium text-ds-muted">
-                          {t('kunCompactionSummaryMode')}
-                          <select
-                            className={selectControlClass}
-                            value={contextCompaction.summaryMode}
-                            onChange={(e) => updateContextCompaction({ summaryMode: e.target.value })}
-                          >
-                            <option value="heuristic">{t('kunCompactionSummaryHeuristic')}</option>
-                            <option value="model">{t('kunCompactionSummaryModel')}</option>
-                          </select>
-                        </label>
+                      <div className="grid gap-3 sm:grid-cols-3">
                         <label className="flex min-w-0 flex-col gap-1.5 text-[12px] font-medium text-ds-muted">
                           {t('kunCompactionSummaryTimeout')}
                           <input
diff --git a/src/renderer/src/components/settings-section-claw.test.ts b/src/renderer/src/components/settings-section-claw.test.ts
index e991a8a4f..0624f0998 100644
--- a/src/renderer/src/components/settings-section-claw.test.ts
+++ b/src/renderer/src/components/settings-section-claw.test.ts
@@ -90,11 +90,12 @@ function buildSettings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'medium',
+    uiFontScale: 0.88,
     provider: defaultModelProviderSettings(),
     agents: { kun: defaultKunRuntimeSettings() },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/renderer/src/components/settings-section-general.test.ts b/src/renderer/src/components/settings-section-general.test.ts
new file mode 100644
index 000000000..61f10c896
--- /dev/null
+++ b/src/renderer/src/components/settings-section-general.test.ts
@@ -0,0 +1,122 @@
+import { createElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { GeneralSettingsSection } from './settings-section-general'
+
+const labels: Record<string, string> = {
+  sectionGeneral: 'General',
+  workspaceRoot: 'Default workspace',
+  workspaceRootDesc: 'Default workspace description',
+  workspaceRootPlaceholder: '~/.kun/default_workspace',
+  restoreWorkspaceDefault: 'Restore default',
+  browse: 'Browse'
+}
+
+function t(key: string, values?: Record<string, unknown>): string {
+  if (!values) return labels[key] ?? key
+  return labels[key] ?? key
+}
+
+function baseCtx(): Record<string, unknown> {
+  const noop = () => undefined
+  return {
+    t,
+    tCommon: t,
+    form: {
+      locale: 'zh',
+      theme: 'dark',
+      uiFontScale: 0.88,
+      workspaceRoot: '~/data/code/python/Kook-Voices',
+      cursorSpotlight: true,
+      cursorSpotlightColor: '#3b82f6',
+      appBehavior: {
+        openAtLogin: false,
+        startMinimized: false,
+        closeToTray: false,
+        closeAction: 'ask'
+      },
+      notifications: {
+        turnComplete: false
+      },
+      checkpointCleanup: {
+        enabled: false,
+        intervalDays: 3
+      },
+      log: {
+        enabled: false,
+        retentionDays: 3
+      }
+    },
+    kun: {},
+    update: noop,
+    updateKun: noop,
+    showRuntimeToken: false,
+    setShowRuntimeToken: noop,
+    portError: '',
+    selectControlClass: 'select',
+    openOnboardingPreview: noop,
+    pickWorkspace: async () => undefined,
+    resetWorkspaceToDefault: noop,
+    workspacePickerError: '',
+    logPath: '',
+    logDirOpenError: '',
+    setLogDirOpenError: noop,
+    compactHomePath: (path: string) => path,
+    expandHomePath: (path: string) => path,
+    pickWriteWorkspace: async () => undefined,
+    resetWriteWorkspaceToDefault: noop,
+    writeWorkspacePickerError: '',
+    writeInlineBaseUrlInherited: false,
+    effectiveWriteInlineBaseUrl: '',
+    writeInlineModelInherited: false,
+    effectiveWriteInlineModel: '',
+    setWriteDebugModalOpen: noop,
+    loadWriteDebugEntries: async () => undefined,
+    scrollToAgentSection: noop,
+    agentsSectionRef: { current: null },
+    skillSectionRef: { current: null },
+    mcpSectionRef: { current: null },
+    permissionsSectionRef: { current: null },
+    selectedSkillRoot: null,
+    skillRootOptions: [],
+    skillRootId: '',
+    setSkillRootId: noop,
+    skillNotice: null,
+    openSkillRoot: async () => undefined,
+    openPlugins: noop,
+    mcpConfigPath: '',
+    mcpConfigExists: false,
+    mcpConfigText: '',
+    setMcpConfigText: noop,
+    mcpLoading: false,
+    mcpBusy: false,
+    mcpNotice: null,
+    saveMcpConfig: async () => undefined,
+    loadMcpConfig: async () => undefined,
+    openMcpConfigDir: async () => undefined,
+    pickClawWorkspace: async () => undefined,
+    resetClawWorkspaceToDefault: noop,
+    clawWorkspacePickerError: '',
+    splitSettingsList: (value: string) => value.split('\n').filter(Boolean),
+    listSettingsText: (values: string[]) => values.join('\n')
+  }
+}
+
+describe('GeneralSettingsSection workspace layout', () => {
+  beforeEach(() => {
+    vi.stubGlobal('window', { kunGui: {} })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('keeps the workspace path input full width above the action buttons', () => {
+    const html = renderToStaticMarkup(createElement(GeneralSettingsSection, { ctx: baseCtx() }))
+
+    expect(html).toContain('grid w-full min-w-0 gap-2 md:max-w-xl')
+    expect(html).toContain('w-full min-w-0 rounded-xl border border-ds-border')
+    expect(html).toContain('flex flex-wrap justify-end gap-2')
+    expect(html.indexOf('~/data/code/python/Kook-Voices')).toBeLessThan(html.indexOf('Restore default'))
+  })
+})
diff --git a/src/renderer/src/components/settings-section-general.tsx b/src/renderer/src/components/settings-section-general.tsx
index 759f5bbda..c48bb8017 100644
--- a/src/renderer/src/components/settings-section-general.tsx
+++ b/src/renderer/src/components/settings-section-general.tsx
@@ -1,14 +1,19 @@
 import { useEffect, useMemo, useState, type ReactElement } from 'react'
 import type { ApprovalPolicy, AppSettingsV1, SandboxMode, WindowCloseAction } from '@shared/app-settings'
 import {
+  CHECKPOINT_CLEANUP_INTERVAL_DAYS,
   DEFAULT_CURSOR_SPOTLIGHT_COLOR,
   DEFAULT_WRITE_INLINE_COMPLETION_BASE_URL,
   DEFAULT_WRITE_INLINE_COMPLETION_MAX_TOKENS,
   DEFAULT_WRITE_INLINE_COMPLETION_MODEL,
   DEFAULT_WRITE_INLINE_LONG_COMPLETION_MAX_TOKENS,
   DEFAULT_KUN_DATA_DIR,
+  LEGACY_UI_FONT_SCALE_FACTORS,
+  UI_FONT_SCALE_MAX,
+  UI_FONT_SCALE_MIN,
   WRITE_INLINE_COMPLETION_MODEL_IDS,
-  isKunRuntimeInsecure
+  isKunRuntimeInsecure,
+  normalizeUiFontScale
 } from '@shared/app-settings'
 import type { SkillRootId } from '../lib/skill-root-preference'
 import { FolderOpen, Loader2, PencilLine, RefreshCw, Settings } from 'lucide-react'
@@ -233,15 +238,22 @@ export function GeneralSettingsSection({ ctx }: { ctx: Record<string, any> }): R
   const desktopBehavior = form.appBehavior
   const closeAction = desktopBehavior.closeAction ?? (desktopBehavior.closeToTray ? 'tray' : 'ask')
   const closeActionOptions: WindowCloseAction[] = ['ask', 'tray', 'quit']
-  const fontScaleOptions: AppSettingsV1['uiFontScale'][] = ['small', 'medium', 'large']
-  const selectedFontScaleIndex = fontScaleOptions.indexOf(form.uiFontScale)
-  const fontScaleIndex = selectedFontScaleIndex >= 0 ? selectedFontScaleIndex : 0
-  const currentFontScale = fontScaleOptions[fontScaleIndex]
-  const fontScaleLabel = (scale: AppSettingsV1['uiFontScale']): string => {
-    if (scale === 'large') return t('fontScaleLarge')
-    if (scale === 'medium') return t('fontScaleMedium')
-    return t('fontScaleSmall')
-  }
+  const checkpointCleanupIntervalOptions = Array.from(CHECKPOINT_CLEANUP_INTERVAL_DAYS)
+  const fontScale = normalizeUiFontScale(form.uiFontScale)
+  const fontScalePercent = Math.round(fontScale * 100)
+  const setFontScale = (value: number): void => update({ uiFontScale: normalizeUiFontScale(value) })
+  const fontScalePresets: { value: number; label: string }[] = [
+    { value: LEGACY_UI_FONT_SCALE_FACTORS.small, label: t('fontScaleSmall') },
+    { value: LEGACY_UI_FONT_SCALE_FACTORS.medium, label: t('fontScaleMedium') },
+    { value: LEGACY_UI_FONT_SCALE_FACTORS.large, label: t('fontScaleLarge') }
+  ]
+  const fontScaleChipClass = (active: boolean): string =>
+    [
+      'inline-flex h-7 items-center rounded-full border px-3 text-[12px] font-medium transition',
+      active
+        ? 'border-accent/60 bg-accent/8 text-accent ring-1 ring-accent/30'
+        : 'border-ds-border bg-ds-card text-ds-muted hover:bg-ds-hover hover:text-ds-ink'
+    ].join(' ')
   const cursorSpotlightColor = normalizeHexColor(form.cursorSpotlightColor)
 
   return (
@@ -280,27 +292,68 @@ export function GeneralSettingsSection({ ctx }: { ctx: Record<string, any> }): R
                   title={t('fontScale')}
                   description={t('fontScaleDesc')}
                   control={
-                    <div className="w-full min-w-0 md:max-w-md">
-                      <div className="flex items-center justify-between text-[12px] font-medium text-ds-faint">
-                        {fontScaleOptions.map((scale) => (
-                          <span key={scale}>{fontScaleLabel(scale)}</span>
+                    <div className="w-full min-w-0 space-y-2.5 md:max-w-md">
+                      <div className="flex flex-wrap items-center gap-1.5">
+                        {fontScalePresets.map((preset) => (
+                          <button
+                            key={preset.label}
+                            type="button"
+                            aria-pressed={fontScalePercent === Math.round(preset.value * 100)}
+                            className={fontScaleChipClass(fontScalePercent === Math.round(preset.value * 100))}
+                            onClick={() => setFontScale(preset.value)}
+                          >
+                            {preset.label}
+                          </button>
                         ))}
                       </div>
-                      <input
-                        type="range"
-                        min={0}
-                        max={fontScaleOptions.length - 1}
-                        step={1}
-                        value={fontScaleIndex}
-                        aria-label={t('fontScale')}
-                        className="mt-2 w-full accent-accent"
-                        onChange={(e) => {
-                          const nextScale = fontScaleOptions[Number(e.target.value)] ?? 'medium'
-                          update({ uiFontScale: nextScale })
-                        }}
-                      />
-                      <div className="mt-1.5 text-[13px] font-medium text-ds-muted">
-                        {t('fontScaleCurrent', { value: fontScaleLabel(currentFontScale) })}
+                      <div className="flex items-center gap-3">
+                        <span className="shrink-0 text-[12px] leading-none text-ds-faint" aria-hidden="true">
+                          A
+                        </span>
+                        <input
+                          type="range"
+                          min={UI_FONT_SCALE_MIN}
+                          max={UI_FONT_SCALE_MAX}
+                          step={0.01}
+                          value={fontScale}
+                          aria-label={t('fontScale')}
+                          className="w-full accent-accent"
+                          onChange={(e) => setFontScale(Number(e.target.value))}
+                        />
+                        <span className="shrink-0 text-[18px] leading-none text-ds-faint" aria-hidden="true">
+                          A
+                        </span>
+                        <div className="inline-flex shrink-0 items-center rounded-lg border border-ds-border bg-ds-card">
+                          <button
+                            type="button"
+                            aria-label={t('fontScaleSmall')}
+                            className="flex h-7 w-7 items-center justify-center rounded-l-lg text-ds-muted transition hover:bg-ds-hover hover:text-ds-ink"
+                            onClick={() => setFontScale(fontScale - 0.05)}
+                          >
+                            −
+                          </button>
+                          <div className="flex items-center border-x border-ds-border">
+                            <input
+                              type="number"
+                              min={Math.round(UI_FONT_SCALE_MIN * 100)}
+                              max={Math.round(UI_FONT_SCALE_MAX * 100)}
+                              step={1}
+                              value={fontScalePercent}
+                              aria-label={t('fontScale')}
+                              className="w-10 border-0 bg-transparent py-1 text-center text-[13px] font-medium tabular-nums text-ds-ink outline-none"
+                              onChange={(e) => setFontScale(Number(e.target.value) / 100)}
+                            />
+                            <span className="pr-1.5 text-[11px] text-ds-faint">%</span>
+                          </div>
+                          <button
+                            type="button"
+                            aria-label={t('fontScaleLarge')}
+                            className="flex h-7 w-7 items-center justify-center rounded-r-lg text-ds-muted transition hover:bg-ds-hover hover:text-ds-ink"
+                            onClick={() => setFontScale(fontScale + 0.05)}
+                          >
+                            +
+                          </button>
+                        </div>
                       </div>
                     </div>
                   }
@@ -309,14 +362,16 @@ export function GeneralSettingsSection({ ctx }: { ctx: Record<string, any> }): R
                   title={t('workspaceRoot')}
                   description={t('workspaceRootDesc')}
                   control={
-                    <div className="w-full min-w-[200px] md:max-w-xl">
-                      <div className="flex items-center gap-2">
+                    <div className="grid w-full min-w-0 gap-2 md:max-w-xl">
+                      <div className="min-w-0">
                         <input
-                          className="w-full rounded-xl border border-ds-border bg-ds-card px-3 py-2 text-[14px] text-ds-ink shadow-sm focus:border-accent/40 focus:outline-none focus:ring-1 focus:ring-accent/30"
+                          className="w-full min-w-0 rounded-xl border border-ds-border bg-ds-card px-3 py-2 text-[14px] text-ds-ink shadow-sm focus:border-accent/40 focus:outline-none focus:ring-1 focus:ring-accent/30"
                           value={compactHomePath(form.workspaceRoot)}
                           onChange={(e) => update({ workspaceRoot: expandHomePath(e.target.value) })}
                           placeholder={t('workspaceRootPlaceholder')}
                         />
+                      </div>
+                      <div className="flex flex-wrap justify-end gap-2">
                         <button
                           type="button"
                           onClick={resetWorkspaceToDefault}
@@ -447,6 +502,43 @@ export function GeneralSettingsSection({ ctx }: { ctx: Record<string, any> }): R
 
               <LegacySessionImportCard t={t} tCommon={tCommon} />
 
+              <SettingsCard title={t('gitCheckpointTitle')} className="mt-6">
+                <SettingRow
+                  title={t('checkpointCleanupEnabled')}
+                  description={t('checkpointCleanupEnabledDesc')}
+                  control={
+                    <Toggle
+                      checked={form.checkpointCleanup.enabled}
+                      onChange={(v) => update({ checkpointCleanup: { enabled: v } })}
+                    />
+                  }
+                />
+                <SettingRow
+                  title={t('checkpointCleanupInterval')}
+                  description={t('checkpointCleanupIntervalDesc')}
+                  control={
+                    <select
+                      className={selectControlClass}
+                      value={form.checkpointCleanup.intervalDays}
+                      disabled={!form.checkpointCleanup.enabled}
+                      onChange={(e) =>
+                        update({
+                          checkpointCleanup: {
+                            intervalDays: Number(e.target.value) as AppSettingsV1['checkpointCleanup']['intervalDays']
+                          }
+                        })
+                      }
+                    >
+                      {checkpointCleanupIntervalOptions.map((days) => (
+                        <option key={days} value={days}>
+                          {t(`checkpointCleanupInterval${days}`)}
+                        </option>
+                      ))}
+                    </select>
+                  }
+                />
+              </SettingsCard>
+
               <SettingsCard title={t('logTitle')} className="mt-6">
                 <SettingRow
                   title={t('logEnabled')}
diff --git a/src/renderer/src/components/settings-utils.ts b/src/renderer/src/components/settings-utils.ts
index fb11e7aad..9767982fc 100644
--- a/src/renderer/src/components/settings-utils.ts
+++ b/src/renderer/src/components/settings-utils.ts
@@ -1,4 +1,5 @@
 import {
+  DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS,
   DEFAULT_LOG_RETENTION_DAYS,
   DEFAULT_GUI_UPDATE_CHANNEL,
   MIN_KUN_LOCAL_PORT,
@@ -16,6 +17,7 @@ import {
   mergeTerminalSettings,
   normalizeAppBehaviorSettings,
   normalizeClawSettings,
+  normalizeCheckpointCleanupSettings,
   normalizeCursorSpotlightColor,
   normalizeGuiUpdateChannel,
   normalizeKeyboardShortcuts,
@@ -24,6 +26,7 @@ import {
   normalizeWorkflowSettings,
   normalizeWriteSettings,
   normalizeTerminalSettings,
+  normalizeUiFontScale,
   type AppSettingsPatch,
   type AppSettingsV1
 } from '@shared/app-settings'
@@ -61,6 +64,10 @@ export function mergeSettings(current: AppSettingsV1, patch: SettingsPatch): App
       ...safeCurrent.log,
       ...(patch.log ?? {})
     },
+    checkpointCleanup: normalizeCheckpointCleanupSettings({
+      ...safeCurrent.checkpointCleanup,
+      ...(patch.checkpointCleanup ?? {})
+    }),
     notifications: {
       ...safeCurrent.notifications,
       ...(patch.notifications ?? {})
@@ -90,10 +97,7 @@ export function coerceRendererSettings(settings: AppSettingsV1): AppSettingsV1 {
     raw.theme === 'system' || raw.theme === 'light' || raw.theme === 'dark'
       ? raw.theme
       : 'system'
-  const uiFontScale =
-    raw.uiFontScale === 'small' || raw.uiFontScale === 'medium' || raw.uiFontScale === 'large'
-      ? raw.uiFontScale
-      : 'medium'
+  const uiFontScale = normalizeUiFontScale(raw.uiFontScale)
   return {
     version: 1,
     locale: raw.locale === 'zh' ? 'zh' : 'en',
@@ -110,6 +114,9 @@ export function coerceRendererSettings(settings: AppSettingsV1): AppSettingsV1 {
         ? raw.log.retentionDays
         : DEFAULT_LOG_RETENTION_DAYS
     },
+    checkpointCleanup: normalizeCheckpointCleanupSettings(
+      raw.checkpointCleanup ?? { intervalDays: DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS }
+    ),
     notifications: {
       turnComplete: raw.notifications?.turnComplete !== false
     },
diff --git a/src/renderer/src/components/sidebar/SidebarPrimitives.tsx b/src/renderer/src/components/sidebar/SidebarPrimitives.tsx
index ddcfe8d4a..af0db8862 100644
--- a/src/renderer/src/components/sidebar/SidebarPrimitives.tsx
+++ b/src/renderer/src/components/sidebar/SidebarPrimitives.tsx
@@ -275,6 +275,9 @@ type SidebarTreeRowProps = {
   title?: string
   ariaLabel?: string
   onContextMenu?: (event: ReactMouseEvent<HTMLDivElement>) => void
+  onMouseEnter?: (event: ReactMouseEvent<HTMLDivElement>) => void
+  onMouseMove?: (event: ReactMouseEvent<HTMLDivElement>) => void
+  onMouseLeave?: (event: ReactMouseEvent<HTMLDivElement>) => void
   disabled?: boolean
   active?: boolean
   activeVariant?: 'rail' | 'outline'
@@ -293,6 +296,9 @@ export function SidebarTreeRow({
   title,
   ariaLabel,
   onContextMenu,
+  onMouseEnter,
+  onMouseMove,
+  onMouseLeave,
   disabled,
   active = false,
   activeVariant = 'rail',
@@ -335,6 +341,9 @@ export function SidebarTreeRow({
       )}
       title={title}
       onContextMenu={onContextMenu}
+      onMouseEnter={onMouseEnter}
+      onMouseMove={onMouseMove}
+      onMouseLeave={onMouseLeave}
     >
       {rail ? (
         <span
diff --git a/src/renderer/src/components/subagents/AgentKun.tsx b/src/renderer/src/components/subagents/AgentKun.tsx
new file mode 100644
index 000000000..3cfe78ed7
--- /dev/null
+++ b/src/renderer/src/components/subagents/AgentKun.tsx
@@ -0,0 +1,97 @@
+import type { ReactElement } from 'react'
+import kunClip from '../../../../asset/img/kun_clip.png'
+import kunSearch from '../../../../asset/img/kun_search.png'
+import kunLaptop from '../../../../asset/img/kun_laptop.png'
+import kunMagic from '../../../../asset/img/kun_magic.png'
+import kunCheer from '../../../../asset/img/kun_cheer.png'
+import kunHeadset from '../../../../asset/img/kun_headset.png'
+import kunWrench from '../../../../asset/img/kun_wrench.png'
+import kunRest from '../../../../asset/img/kun_rest.png'
+
+/**
+ * Animated kun mascot avatar. Each role id maps to a distinct real kun PNG pose
+ * with a per-role CSS animation (float / sway / breathe / bob). Disabled rows
+ * render the resting kun in grayscale.
+ *
+ * Pose map:
+ *   design-reviewer            → kun_clip    (写字板·审查,  bob)
+ *   over-engineering-reviewer  → kun_search  (放大镜·审视,  float)
+ *   code-review                → kun_laptop  (笔记本·看代码, breathe)
+ *   compaction                 → kun_magic   (魔法棒·压缩,  sway)
+ *   title                      → kun_cheer   (庆祝·命名,    bob)
+ *   summary                    → kun_headset (耳麦·复述,    float)
+ *   custom / fallback          → kun_wrench  (工具·自定义,  breathe)
+ *   disabled                   → kun_rest    (抱枕睡, grayscale, no motion)
+ */
+
+type Anim = 'float' | 'sway' | 'breathe' | 'bob'
+
+const STYLE_ID = 'ds-agent-kun-style'
+const STYLE = `
+@keyframes dsKunFloat{0%,100%{transform:translateY(0)}50%{transform:translateY(-3px)}}
+@keyframes dsKunSway{0%,100%{transform:rotate(-5deg)}50%{transform:rotate(5deg)}}
+@keyframes dsKunBreathe{0%,100%{transform:scale(1)}50%{transform:scale(1.07)}}
+@keyframes dsKunBob{0%,100%{transform:translateY(0) rotate(-3deg)}50%{transform:translateY(-2.5px) rotate(3deg)}}
+.ds-agent-kun{display:inline-flex;align-items:center;justify-content:center}
+.ds-agent-kun img{width:100%;height:100%;object-fit:contain;filter:drop-shadow(0 2px 3px rgba(31,45,64,.14))}
+.ds-agent-kun.is-disabled img{filter:grayscale(1) opacity(.7)}
+.ds-agent-kun-float img{animation:dsKunFloat 2.4s ease-in-out infinite}
+.ds-agent-kun-sway img{animation:dsKunSway 2.1s ease-in-out infinite;transform-origin:50% 90%}
+.ds-agent-kun-breathe img{animation:dsKunBreathe 3s ease-in-out infinite}
+.ds-agent-kun-bob img{animation:dsKunBob 2.7s ease-in-out infinite}
+@media (prefers-reduced-motion:reduce){.ds-agent-kun img{animation:none!important}}
+`
+
+function ensureStyle(): void {
+  if (typeof document === 'undefined') return
+  if (document.getElementById(STYLE_ID)) return
+  const el = document.createElement('style')
+  el.id = STYLE_ID
+  el.textContent = STYLE
+  document.head.appendChild(el)
+}
+
+const POSE: Record<string, { src: string; anim: Anim }> = {
+  general: { src: kunLaptop, anim: 'breathe' },
+  explore: { src: kunSearch, anim: 'float' },
+  'design-reviewer': { src: kunClip, anim: 'bob' },
+  'over-engineering-reviewer': { src: kunWrench, anim: 'sway' },
+  'code-review': { src: kunClip, anim: 'breathe' },
+  compaction: { src: kunMagic, anim: 'sway' },
+  title: { src: kunCheer, anim: 'bob' },
+  summary: { src: kunHeadset, anim: 'float' }
+}
+
+const FALLBACK: { src: string; anim: Anim } = { src: kunWrench, anim: 'breathe' }
+
+/**
+ * @param id      role id (drives the pose); unknown ids → fallback (custom kun)
+ * @param disabled when true, renders resting kun in grayscale with no motion
+ * @param className sizing wrapper class (e.g. "h-10 w-10")
+ */
+export function AgentKun({
+  id,
+  disabled = false,
+  className
+}: {
+  id: string
+  /** Retained for API compatibility with old callers; unused (PNGs are fixed). */
+  color?: string
+  disabled?: boolean
+  className?: string
+}): ReactElement {
+  ensureStyle()
+  if (disabled) {
+    return (
+      <span className={`ds-agent-kun is-disabled ${className ?? ''}`}>
+        <img src={kunRest} alt="" aria-hidden="true" />
+      </span>
+    )
+  }
+  const pose = POSE[id] ?? FALLBACK
+  return (
+    <span className={`ds-agent-kun ds-agent-kun-${pose.anim} ${className ?? ''}`}>
+      <img src={pose.src} alt="" aria-hidden="true" />
+    </span>
+  )
+}
diff --git a/src/renderer/src/components/subagents/SubagentDetailPanel.tsx b/src/renderer/src/components/subagents/SubagentDetailPanel.tsx
new file mode 100644
index 000000000..9ba4e580c
--- /dev/null
+++ b/src/renderer/src/components/subagents/SubagentDetailPanel.tsx
@@ -0,0 +1,1133 @@
+import type { Dispatch, ReactElement, ReactNode, SetStateAction } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { TFunction } from 'i18next'
+import { useTranslation } from 'react-i18next'
+import { Bot, Check, ChevronDown, ChevronLeft, ChevronRight, Pencil, Plug, Plus, Power, Search, Sparkles, Trash2, Wrench, X } from 'lucide-react'
+import type { KunSubagentProfileV1, KunSubagentsSettingsV1, ModelReasoningEffort, ModelProviderModelProfileV1 } from '@shared/app-settings'
+import type { ModelProviderModelGroup } from '@shared/kun-gui-api'
+import { KUN_RUNTIME_TOOLS_PATH } from '@shared/kun-endpoints'
+import type { CoreRuntimeToolDiagnosticsJson } from '../../agent/kun-contract'
+import { rendererRuntimeClient } from '../../agent/runtime-client'
+import { confirmDialog } from '../../lib/confirm-dialog'
+import { useChatStore } from '../../store/chat-store'
+import { AgentKun } from './AgentKun'
+
+type Props = { className?: string; onCollapse: () => void }
+
+const EMPTY_SUBAGENTS: KunSubagentsSettingsV1 = { enabled: true, profiles: [] }
+const PRESET_COLORS = ['#3b82d8', '#1d9e75', '#e8943a', '#7f77dd', '#d4537e', '#d85a30']
+
+/** kun's built-in tool names (mirror kun/src/adapters/tool/builtin-tool-types.ts). Small,
+ *  stable set — a static catalog gives nicer labels than parsing the loose diagnostics shape. */
+const BUILTIN_TOOL_NAMES = ['read', 'grep', 'find', 'ls', 'edit', 'write', 'bash', 'lsp'] as const
+
+type CapabilityCatalog = {
+  mcpServers: Array<{ id: string; toolCount: number; status?: string }>
+  skills: Array<{ id: string; name: string; description?: string }>
+}
+
+/** Fetch the live MCP-server + skill catalog from kun for the permission picker.
+ *  Built-in tools come from the static list above; this only needs the dynamic bits.
+ *  Returns empty lists on any failure so the dialog still renders. */
+async function loadCapabilityCatalog(): Promise<CapabilityCatalog> {
+  const empty: CapabilityCatalog = { mcpServers: [], skills: [] }
+  try {
+    const res = await rendererRuntimeClient.runtimeRequest(KUN_RUNTIME_TOOLS_PATH, 'GET')
+    if (!res.ok) return empty
+    const data = JSON.parse(res.body) as CoreRuntimeToolDiagnosticsJson
+    const str = (v: unknown): string => (typeof v === 'string' ? v : '')
+    const mcpServers = (data.mcpServers ?? [])
+      .map((raw) => {
+        const rec = raw as Record<string, unknown>
+        return { id: str(rec.id), toolCount: Number(rec.toolCount ?? 0) || 0, status: str(rec.status) || undefined }
+      })
+      .filter((server) => server.id)
+    const skills = (data.skills?.skills ?? [])
+      .map((raw) => {
+        const rec = raw as Record<string, unknown>
+        const id = str(rec.id)
+        return { id, name: str(rec.name) || id, description: str(rec.description) || undefined }
+      })
+      .filter((skill) => skill.id)
+    return { mcpServers, skills }
+  } catch {
+    return empty
+  }
+}
+
+/** kun's REAL built-in delegatable subagents (mirror kun/src/delegation/builtin-profiles.ts). */
+const BUILTIN_IDS = new Set(['general', 'explore', 'design-reviewer', 'over-engineering-reviewer'])
+const BUILTIN_AGENTS: KunSubagentProfileV1[] = [
+  { id: 'general', enabled: true, name: '', mode: 'subagent', toolPolicy: 'inherit', color: '#3b82d8' },
+  { id: 'explore', enabled: true, name: '', mode: 'subagent', toolPolicy: 'readOnly', color: '#1d9e75' },
+  { id: 'design-reviewer', enabled: true, name: '', mode: 'subagent', toolPolicy: 'readOnly', color: '#7f77dd' },
+  { id: 'over-engineering-reviewer', enabled: true, name: '', mode: 'subagent', toolPolicy: 'readOnly', color: '#e8943a' }
+]
+
+function newProfile(): KunSubagentProfileV1 {
+  return { id: crypto.randomUUID(), enabled: true, name: '', mode: 'subagent', toolPolicy: 'readOnly' }
+}
+
+// Reasoning-effort segment (mirrors the composer's reasoning picker). Labels
+// reuse the composer i18n keys (composerReasoning*). 'off' is always offered;
+// the remaining levels are gated by the selected model's reasoning capability.
+const REASONING_OPTIONS: Array<{ id: ModelReasoningEffort; labelKey: string }> = [
+  { id: 'auto', labelKey: 'composerReasoningAuto' },
+  { id: 'off', labelKey: 'composerReasoningOff' },
+  { id: 'low', labelKey: 'composerReasoningLow' },
+  { id: 'medium', labelKey: 'composerReasoningMedium' },
+  { id: 'high', labelKey: 'composerReasoningHigh' },
+  { id: 'max', labelKey: 'composerReasoningMax' }
+]
+
+function normalizeModelCapabilityKey(modelId: string): string {
+  return modelId.trim().toLowerCase()
+}
+
+/** Resolve the model profile for (group, model), matching by id or alias. */
+function modelProfileForModel(
+  group: ModelProviderModelGroup | undefined,
+  modelId: string
+): ModelProviderModelProfileV1 | undefined {
+  if (!group || !modelId) return undefined
+  const key = normalizeModelCapabilityKey(modelId)
+  if (!key) return undefined
+  const profiles = group.modelProfiles ?? {}
+  const direct = profiles[key] ?? profiles[modelId.trim()]
+  if (direct) return direct
+  return Object.values(profiles).find((p) =>
+    p.aliases?.some((alias) => normalizeModelCapabilityKey(alias) === key)
+  )
+}
+
+/**
+ * Supported reasoning options for a concrete model. Returns [] when the model
+ * has no reasoning capability — the segment is then hidden entirely.
+ */
+function reasoningOptionsForModel(
+  profile: ModelProviderModelProfileV1 | undefined
+): Array<{ id: ModelReasoningEffort; labelKey: string }> {
+  const supported = profile?.reasoning?.supportedEfforts
+  if (!supported || supported.length === 0) return []
+  return supported
+    .map((effort) => REASONING_OPTIONS.find((o) => o.id === effort))
+    .filter((o): o is { id: ModelReasoningEffort; labelKey: string } => Boolean(o))
+}
+
+type RoleSlot = {
+  model: string
+  providerId: string
+}
+
+export function SubagentDetailPanel({ className, onCollapse }: Props): ReactElement {
+  const { t } = useTranslation('common')
+  const composerModelGroups = useChatStore((s) => s.composerModelGroups)
+  const loadComposerModels = useChatStore((s) => s.loadComposerModels)
+  const [subagents, setSubagents] = useState<KunSubagentsSettingsV1>(EMPTY_SUBAGENTS)
+  // Compaction always runs in model mode (the heuristic fold is only a silent
+  // fallback when the model call fails), so there is no user-facing mode toggle.
+  // The model lives under contextCompaction.summaryModel (distinct from the
+  // top-level kun.summaryModel, which drives the session-summary role).
+  const [compactionSlot, setCompactionSlot] = useState<RoleSlot>({ model: '', providerId: '' })
+  const [smallModel, setSmallModel] = useState<RoleSlot>({ model: '', providerId: '' })
+  const [titleSlot, setTitleSlot] = useState<RoleSlot>({ model: '', providerId: '' })
+  const [summarySlot, setSummarySlot] = useState<RoleSlot>({ model: '', providerId: '' })
+  const [codeReviewSlot, setCodeReviewSlot] = useState<RoleSlot>({ model: '', providerId: '' })
+  // Per-role reasoning effort. Default 'off' = omitted server-side.
+  const [titleReasoning, setTitleReasoning] = useState<ModelReasoningEffort>('off')
+  const [summaryReasoning, setSummaryReasoning] = useState<ModelReasoningEffort>('off')
+  const [codeReviewReasoning, setCodeReviewReasoning] = useState<ModelReasoningEffort>('off')
+  const [loading, setLoading] = useState(true)
+  const [dialog, setDialog] = useState<{ profile: KunSubagentProfileV1; isNew: boolean } | null>(null)
+
+  const load = useCallback(async (): Promise<void> => {
+    try {
+      const settings = await rendererRuntimeClient.getSettings({ forceRefresh: true })
+      const kun = settings.agents?.kun
+      setSubagents(kun?.subagents ?? EMPTY_SUBAGENTS)
+      setCompactionSlot({
+        model: kun?.contextCompaction?.summaryModel ?? '',
+        providerId: kun?.contextCompaction?.summaryProviderId ?? ''
+      })
+      setSmallModel({ model: kun?.smallModel ?? '', providerId: kun?.smallModelProviderId ?? '' })
+      setTitleSlot({ model: kun?.titleModel ?? '', providerId: kun?.titleProviderId ?? '' })
+      setSummarySlot({ model: kun?.summaryModel ?? '', providerId: kun?.summaryProviderId ?? '' })
+      setCodeReviewSlot({ model: kun?.codeReviewModel ?? '', providerId: kun?.codeReviewProviderId ?? '' })
+      setTitleReasoning(kun?.titleReasoningEffort ?? 'off')
+      setSummaryReasoning(kun?.summaryReasoningEffort ?? 'off')
+      setCodeReviewReasoning(kun?.codeReviewReasoningEffort ?? 'off')
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  useEffect(() => { void load() }, [load])
+  useEffect(() => { void loadComposerModels() }, [loadComposerModels])
+
+  const persistProfiles = useCallback(async (profiles: KunSubagentProfileV1[]): Promise<void> => {
+    const next = { ...subagents, profiles }
+    setSubagents(next)
+    const saved = await rendererRuntimeClient.setSettings({ agents: { kun: { subagents: next } } })
+    if (saved.agents?.kun?.subagents) setSubagents(saved.agents.kun.subagents)
+  }, [subagents])
+
+  // Built-ins may not be in settings yet — upsert so configuring one persists it for the first time.
+  const upsertProfile = useCallback((id: string, patch: Partial<KunSubagentProfileV1>): void => {
+    const baseline = subagents.profiles.find((p) => p.id === id) ?? BUILTIN_AGENTS.find((p) => p.id === id)
+    if (!baseline) return
+    const next = { ...baseline, ...patch }
+    const exists = subagents.profiles.some((p) => p.id === id)
+    void persistProfiles(exists ? subagents.profiles.map((p) => (p.id === id ? next : p)) : [...subagents.profiles, next])
+  }, [subagents.profiles, persistProfiles])
+
+  const setProfileModel = useCallback((id: string, model: string, providerId: string): void => {
+    upsertProfile(id, {
+      ...(model ? { model } : { model: undefined }),
+      ...(providerId ? { providerId } : { providerId: undefined })
+    })
+  }, [upsertProfile])
+
+  // Per-profile reasoning depth. 'off' is the default → store undefined so the
+  // round-trip omits it (mergeKunRuntimeSettings strips 'off'/invalid).
+  const setProfileReasoning = useCallback((id: string, effort: ModelReasoningEffort): void => {
+    upsertProfile(id, { reasoningEffort: effort === 'off' ? undefined : effort })
+  }, [upsertProfile])
+
+  const toggleEnabled = useCallback((id: string): void => {
+    const cur = subagents.profiles.find((p) => p.id === id) ?? BUILTIN_AGENTS.find((p) => p.id === id)
+    upsertProfile(id, { enabled: !(cur?.enabled ?? true) })
+  }, [subagents.profiles, upsertProfile])
+
+  const removeProfile = useCallback(async (id: string): Promise<void> => {
+    const p = subagents.profiles.find((x) => x.id === id)
+    if (!(await confirmDialog(t('agentsView.deleteConfirm', 'Delete this agent?'), p?.name ?? id))) return
+    void persistProfiles(subagents.profiles.filter((x) => x.id !== id))
+  }, [subagents.profiles, persistProfiles, t])
+
+  const saveDialog = useCallback((profile: KunSubagentProfileV1): void => {
+    const exists = subagents.profiles.some((p) => p.id === profile.id)
+    void persistProfiles(exists
+      ? subagents.profiles.map((p) => (p.id === profile.id ? profile : p))
+      : [...subagents.profiles, profile])
+    setDialog(null)
+  }, [subagents.profiles, persistProfiles])
+
+  // Compaction model override is nested under contextCompaction (not a flat
+  // kun.* key), so it needs its own patch. Empty string clears it → compaction
+  // falls back to the main conversation model.
+  const persistCompactionSlot = useCallback(async (model: string, providerId: string): Promise<void> => {
+    setCompactionSlot({ model, providerId })
+    await rendererRuntimeClient.setSettings({
+      agents: { kun: { contextCompaction: { summaryModel: model, summaryProviderId: providerId } } }
+    })
+  }, [])
+
+  // Each role slot patches its own agents.kun.* override fields. The model/
+  // provider keys are typed pairs on KunRuntimeSettingsV1; empty string clears
+  // them server-side (mergeKunRuntimeSettings omits blank slots).
+  const persistRoleSlot = useCallback(
+    async (
+      apply: (s: RoleSlot) => void,
+      modelKey: 'smallModel' | 'titleModel' | 'summaryModel' | 'codeReviewModel',
+      providerKey: 'smallModelProviderId' | 'titleProviderId' | 'summaryProviderId' | 'codeReviewProviderId',
+      model: string,
+      providerId: string
+    ): Promise<void> => {
+      apply({ model, providerId })
+      await rendererRuntimeClient.setSettings({
+        agents: { kun: { [modelKey]: model, [providerKey]: providerId } }
+      })
+    },
+    []
+  )
+
+  // Persist a role-level reasoning slot to agents.kun.*. 'off' is the default;
+  // mergeKunRuntimeSettings strips 'off'/invalid, so the field round-trips clean.
+  const persistRoleReasoning = useCallback(
+    async (
+      apply: (effort: ModelReasoningEffort) => void,
+      key: 'titleReasoningEffort' | 'summaryReasoningEffort' | 'codeReviewReasoningEffort',
+      effort: ModelReasoningEffort
+    ): Promise<void> => {
+      apply(effort)
+      await rendererRuntimeClient.setSettings({ agents: { kun: { [key]: effort } } })
+    },
+    []
+  )
+
+  const isBuiltin = (id: string): boolean => BUILTIN_IDS.has(id)
+  const delegatable = useMemo(() => {
+    const builtins = BUILTIN_AGENTS.map((b) => subagents.profiles.find((p) => p.id === b.id) ?? b)
+    const custom = subagents.profiles.filter((p) => !BUILTIN_IDS.has(p.id))
+    return [...builtins, ...custom]
+  }, [subagents.profiles])
+
+  if (loading) {
+    return (
+      <div className={`flex flex-col bg-ds-sidebar ${className ?? ''}`}>
+        <PanelHeader t={t} onCollapse={onCollapse} />
+        <div className="flex flex-1 items-center justify-center text-sm text-ds-muted">{t('loading', 'Loading')}</div>
+      </div>
+    )
+  }
+
+  return (
+    <div className={`flex flex-col bg-ds-sidebar ${className ?? ''}`}>
+      <PanelHeader t={t} onCollapse={onCollapse} />
+
+      <div className="min-h-0 flex-1 overflow-y-auto py-1.5">
+        <GroupLabel>{t('subagentsPanel.delegatable', 'Delegatable · usable in chat')}</GroupLabel>
+        {delegatable.map((p) => {
+          const builtin = isBuiltin(p.id)
+          const name = builtin ? t(`subagentsPanel.role.${p.id}.name`, p.name || p.id) : p.name || p.id
+          const desc = builtin
+            ? t(`subagentsPanel.role.${p.id}.desc`, p.description ?? '')
+            : (p.description ?? '')
+          return (
+            <Row key={p.id} roleId={p.id} disabled={!p.enabled} builtin={builtin} name={name} desc={desc}>
+              <ModelSelect
+                value={p.model ?? ''}
+                providerId={p.providerId ?? ''}
+                groups={composerModelGroups}
+                onChange={(m, pid) => setProfileModel(p.id, m, pid)}
+                reasoning={p.reasoningEffort ?? 'off'}
+                onReasoningChange={(effort) => setProfileReasoning(p.id, effort)}
+              />
+              <RowActions
+                enabled={p.enabled}
+                builtin={builtin}
+                t={t}
+                onToggle={() => toggleEnabled(p.id)}
+                onEdit={() => setDialog({ profile: { ...p }, isNew: false })}
+                onDelete={() => void removeProfile(p.id)}
+              />
+            </Row>
+          )
+        })}
+
+        <GroupLabel>{t('subagentsPanel.system', 'System · internal')}</GroupLabel>
+
+        {/* Compaction: configurable model, defaults to the main conversation
+            model when left on "follow default". No mode toggle — compaction
+            always runs the model (heuristic fold is a silent fallback). */}
+        <Row
+          roleId="compaction"
+          name={t('subagentsPanel.role.compaction.name', 'Compaction')}
+          desc={t('subagentsPanel.role.compaction.desc', 'Configurable · defaults to main model')}
+        >
+          <ModelSelect
+            value={compactionSlot.model}
+            providerId={compactionSlot.providerId}
+            groups={composerModelGroups}
+            small
+            onChange={(m, pid) => void persistCompactionSlot(m, pid)}
+          />
+        </Row>
+
+        {/* Code review: configurable model. */}
+        <Row
+          roleId="code-review"
+          name={t('subagentsPanel.role.codeReview.name', 'Code review')}
+          desc={t('subagentsPanel.role.codeReview.desc', 'Isolated read-only run · configurable')}
+        >
+          <ModelSelect
+            value={codeReviewSlot.model}
+            providerId={codeReviewSlot.providerId}
+            groups={composerModelGroups}
+            onChange={(m, pid) => void persistRoleSlot(setCodeReviewSlot, 'codeReviewModel', 'codeReviewProviderId', m, pid)}
+            reasoning={codeReviewReasoning}
+            onReasoningChange={(effort) => void persistRoleReasoning(setCodeReviewReasoning, 'codeReviewReasoningEffort', effort)}
+          />
+        </Row>
+
+        {/* Title: configurable model, defaults to small model. */}
+        <Row
+          roleId="title"
+          name={t('subagentsPanel.role.title.name', 'Title')}
+          desc={t('subagentsPanel.role.title.desc', 'LLM · defaults to small model')}
+        >
+          <ModelSelect
+            value={titleSlot.model}
+            providerId={titleSlot.providerId}
+            groups={composerModelGroups}
+            small
+            onChange={(m, pid) => void persistRoleSlot(setTitleSlot, 'titleModel', 'titleProviderId', m, pid)}
+            reasoning={titleReasoning}
+            onReasoningChange={(effort) => void persistRoleReasoning(setTitleReasoning, 'titleReasoningEffort', effort)}
+          />
+        </Row>
+
+        {/* Summary: configurable model, defaults to small model. */}
+        <Row
+          roleId="summary"
+          name={t('subagentsPanel.role.summary.name', 'Summary')}
+          desc={t('subagentsPanel.role.summary.desc', 'LLM · defaults to small model')}
+        >
+          <ModelSelect
+            value={summarySlot.model}
+            providerId={summarySlot.providerId}
+            groups={composerModelGroups}
+            small
+            onChange={(m, pid) => void persistRoleSlot(setSummarySlot, 'summaryModel', 'summaryProviderId', m, pid)}
+            reasoning={summaryReasoning}
+            onReasoningChange={(effort) => void persistRoleReasoning(setSummaryReasoning, 'summaryReasoningEffort', effort)}
+          />
+        </Row>
+
+        <GroupLabel>{t('subagentsPanel.global', 'Global · shared')}</GroupLabel>
+
+        {/* Small model slot: Title & Summary default to this. */}
+        <Row
+          roleId="small-model"
+          name={t('subagentsPanel.smallModel.name', 'Small model')}
+          desc={t('subagentsPanel.smallModel.desc', 'Default for Title & Summary')}
+        >
+          <ModelSelect
+            value={smallModel.model}
+            providerId={smallModel.providerId}
+            groups={composerModelGroups}
+            small
+            onChange={(m, pid) => void persistRoleSlot(setSmallModel, 'smallModel', 'smallModelProviderId', m, pid)}
+          />
+        </Row>
+      </div>
+
+      <div className="shrink-0 border-t border-ds-border px-3 py-3">
+        <button
+          type="button"
+          onClick={() => setDialog({ profile: newProfile(), isNew: true })}
+          className="flex w-full items-center justify-center gap-2 rounded-[10px] bg-accent px-3 py-2.5 text-[12.5px] font-semibold text-white transition hover:bg-accent/90"
+        >
+          <Plus className="h-3.5 w-3.5" strokeWidth={2.4} />
+          {t('subagentsPanel.newSubagent', 'New subagent')}
+        </button>
+      </div>
+
+      {dialog ? (
+        <ProfileDialog
+          profile={dialog.profile}
+          isNew={dialog.isNew}
+          builtin={isBuiltin(dialog.profile.id)}
+          groups={composerModelGroups}
+          onSave={saveDialog}
+          onCancel={() => setDialog(null)}
+        />
+      ) : null}
+    </div>
+  )
+}
+
+function PanelHeader({ t, onCollapse }: { t: TFunction<'common'>; onCollapse: () => void }): ReactElement {
+  return (
+    <div className="flex shrink-0 items-center gap-2 border-b border-ds-border px-4 py-3.5">
+      <Bot className="h-[17px] w-[17px] text-accent" strokeWidth={2} />
+      <b className="text-[14px] font-semibold text-ds-heading">{t('subagents', 'Subagents')}</b>
+      <span className="text-[11px] text-ds-faint">· {t('subagentsPanel.configModel', 'configure model')}</span>
+      <button
+        type="button"
+        onClick={onCollapse}
+        title={t('agentsView.cancel', 'Close')}
+        aria-label={t('agentsView.cancel', 'Close')}
+        className="ml-auto rounded-md p-1 text-ds-faint transition hover:bg-ds-subtle hover:text-ds-heading"
+      >
+        <X className="h-4 w-4" strokeWidth={2} />
+      </button>
+    </div>
+  )
+}
+
+function GroupLabel({ children }: { children: ReactNode }): ReactElement {
+  return (
+    <div className="px-[18px] pb-1.5 pt-3 text-[10.5px] font-semibold uppercase tracking-wide text-ds-faint">
+      {children}
+    </div>
+  )
+}
+
+function Row({
+  roleId,
+  disabled = false,
+  builtin = false,
+  name,
+  desc,
+  children
+}: {
+  roleId: string
+  disabled?: boolean
+  builtin?: boolean
+  name: string
+  desc: string
+  children: ReactNode
+}): ReactElement {
+  const { t } = useTranslation('common')
+  return (
+    <div className={`mx-2 flex items-center gap-3 rounded-xl px-2.5 py-2.5 transition hover:bg-ds-hover/60 ${disabled ? 'opacity-60' : ''}`}>
+      <span
+        className="flex h-[42px] w-[42px] shrink-0 items-center justify-center rounded-full"
+        style={{ background: 'radial-gradient(circle at 50% 36%, #fff 0%, rgba(238,244,251,0.9) 78%)', boxShadow: 'inset 0 0 0 1px rgba(188,214,245,0.7)' }}
+      >
+        <AgentKun id={roleId} disabled={disabled} className="h-9 w-9" />
+      </span>
+      <div className="flex min-w-0 flex-1 flex-col gap-0.5">
+        <div className="flex min-w-0 items-center gap-1.5">
+          <span className="truncate text-[13.5px] font-semibold text-ds-heading">{name}</span>
+          {builtin ? (
+            <span
+              className="shrink-0 rounded-full px-1.5 py-px text-[9.5px] font-semibold"
+              style={{ backgroundColor: 'rgba(59,130,216,0.14)', color: '#3b82d8' }}
+            >
+              {t('subagentsPanel.builtin', '内置')}
+            </span>
+          ) : null}
+        </div>
+        {desc ? <div className="truncate text-[11px] text-ds-muted">{desc}</div> : null}
+      </div>
+      <div className="flex shrink-0 items-center gap-1">{children}</div>
+    </div>
+  )
+}
+
+function RowActions({
+  enabled,
+  builtin,
+  t,
+  onToggle,
+  onEdit,
+  onDelete
+}: {
+  enabled: boolean
+  builtin: boolean
+  t: TFunction<'common'>
+  onToggle: () => void
+  onEdit: () => void
+  onDelete: () => void
+}): ReactElement {
+  return (
+    <div className="flex shrink-0 items-center gap-0.5">
+      <button
+        type="button"
+        onClick={onToggle}
+        title={enabled ? t('disable', 'Disable') : t('enable', 'Enable')}
+        className={`rounded p-1.5 hover:bg-ds-subtle ${enabled ? 'text-accent' : 'text-ds-faint'}`}
+      >
+        <Power className="h-3.5 w-3.5" />
+      </button>
+      <button
+        type="button"
+        onClick={onEdit}
+        title={t('agentsView.edit', 'Edit')}
+        className="rounded p-1.5 text-ds-muted hover:bg-ds-subtle hover:text-ds-heading"
+      >
+        <Pencil className="h-3.5 w-3.5" />
+      </button>
+      {builtin ? null : (
+        <button
+          type="button"
+          onClick={onDelete}
+          title={t('agentsView.delete', 'Delete')}
+          className="rounded p-1.5 text-ds-muted hover:bg-ds-subtle hover:text-red-500"
+        >
+          <Trash2 className="h-3.5 w-3.5" />
+        </button>
+      )}
+    </div>
+  )
+}
+
+/**
+ * Two-step model picker (mirrors the composer): trigger → pick provider → pick
+ * model, with a "follow default" option. `stretch` = full-width dialog variant.
+ */
+function ModelSelect({
+  value,
+  providerId,
+  groups,
+  onChange,
+  reasoning,
+  onReasoningChange,
+  disabled,
+  small,
+  stretch
+}: {
+  value: string
+  providerId: string
+  groups: ModelProviderModelGroup[]
+  onChange: (model: string, providerId: string) => void
+  reasoning?: string
+  onReasoningChange?: (effort: ModelReasoningEffort) => void
+  disabled?: boolean
+  small?: boolean
+  stretch?: boolean
+}): ReactElement {
+  const { t } = useTranslation('common')
+  const [open, setOpen] = useState(false)
+  const [picked, setPicked] = useState<string | null>(null)
+  const ref = useRef<HTMLDivElement>(null)
+  useEffect(() => {
+    if (!open) return
+    const onDoc = (e: MouseEvent): void => {
+      if (ref.current && !ref.current.contains(e.target as Node)) setOpen(false)
+    }
+    document.addEventListener('mousedown', onDoc)
+    return () => document.removeEventListener('mousedown', onDoc)
+  }, [open])
+  useEffect(() => {
+    if (open) setPicked(providerId || null)
+  }, [open, providerId])
+
+  const label = value || t('agentsView.followDefault', '跟随默认')
+  const activeGroup = groups.find((g) => g.providerId === picked)
+
+  // Reasoning is offered only when a concrete model is selected AND that model
+  // declares a reasoning capability. Resolve the profile from the persisted
+  // (value, providerId) pair — falling back to any group that lists the model.
+  const reasoningEnabled = Boolean(onReasoningChange) && Boolean(value)
+  const selectedGroup = providerId ? groups.find((g) => g.providerId === providerId) : undefined
+  const selectedProfile = reasoningEnabled
+    ? (modelProfileForModel(selectedGroup, value) ??
+        groups.map((g) => modelProfileForModel(g, value)).find(Boolean))
+    : undefined
+  const reasoningOptions = reasoningEnabled ? reasoningOptionsForModel(selectedProfile) : []
+  const currentReasoning: ModelReasoningEffort =
+    reasoning && REASONING_OPTIONS.some((o) => o.id === reasoning)
+      ? (reasoning as ModelReasoningEffort)
+      : 'off'
+
+  const triggerCls = stretch
+    ? 'flex h-9 w-full items-center justify-between rounded-md border border-ds-border bg-[var(--ds-surface-elevated)] pl-3 pr-2.5 text-sm text-ds-heading disabled:opacity-50'
+    : `flex h-8 w-[132px] items-center justify-between gap-1 rounded-[9px] border bg-[var(--ds-surface-elevated)] pl-3 pr-2 text-[12px] font-semibold disabled:opacity-50 ${
+        small ? 'border-emerald-200 text-emerald-700 dark:border-emerald-900/60 dark:text-emerald-300' : 'border-ds-border text-accent'
+      }`
+
+  return (
+    <div className={`relative ${stretch ? '' : 'shrink-0'}`} ref={ref}>
+      <button
+        type="button"
+        disabled={disabled}
+        onClick={() => setOpen((o) => !o)}
+        className={triggerCls}
+        style={{ backgroundColor: 'var(--ds-surface-elevated)' }}
+      >
+        <span className="truncate">{label}</span>
+        <ChevronDown className="h-3.5 w-3.5 shrink-0 text-ds-faint" />
+      </button>
+      {open ? (
+        <div
+          style={{ backgroundColor: 'var(--ds-surface-elevated)' }}
+          className={`absolute z-50 mt-1 max-h-[300px] overflow-auto rounded-xl border border-ds-border p-1 shadow-[0_12px_32px_rgba(31,45,64,0.16)] ${
+            stretch ? 'left-0 w-full' : 'right-0 w-[230px]'
+          }`}
+        >
+          {picked === null ? (
+            <>
+              <PickerItem active={!value} onClick={() => { onChange('', ''); setOpen(false) }}>
+                {t('agentsView.followDefault', '跟随默认')}
+              </PickerItem>
+              {groups.map((g) => (
+                <button
+                  key={g.providerId}
+                  type="button"
+                  onClick={() => setPicked(g.providerId)}
+                  className="flex w-full items-center justify-between rounded-lg px-3 py-2 text-left text-[13px] text-ds-ink hover:bg-accent-soft"
+                >
+                  <span className="truncate">{g.label}</span>
+                  <ChevronRight className="h-3.5 w-3.5 shrink-0 text-ds-faint" />
+                </button>
+              ))}
+            </>
+          ) : (
+            <>
+              <button
+                type="button"
+                onClick={() => setPicked(null)}
+                className="mb-0.5 flex w-full items-center gap-1.5 rounded-lg px-2.5 py-1.5 text-left text-[12px] font-medium text-ds-muted hover:bg-ds-card-muted"
+              >
+                <ChevronLeft className="h-3.5 w-3.5 shrink-0" />
+                <span className="truncate">{activeGroup?.label ?? picked}</span>
+              </button>
+              {(activeGroup?.modelIds ?? []).map((id) => (
+                <PickerItem
+                  key={id}
+                  active={value === id && providerId === picked}
+                  onClick={() => { onChange(id, picked); setOpen(false) }}
+                >
+                  {id}
+                </PickerItem>
+              ))}
+            </>
+          )}
+          {reasoningEnabled && reasoningOptions.length > 0 ? (
+            <div className="mt-1 border-t border-ds-border px-2 pb-1 pt-2">
+              <div className="mb-1.5 px-1 text-[10.5px] font-semibold uppercase tracking-wide text-ds-faint">
+                {t('composerReasoning', 'Reasoning')}
+              </div>
+              <div className="flex flex-wrap gap-1">
+                {reasoningOptions.map((opt) => {
+                  const on = opt.id === currentReasoning
+                  return (
+                    <button
+                      key={opt.id}
+                      type="button"
+                      onClick={() => onReasoningChange?.(opt.id)}
+                      className={`rounded-md px-2 py-1 text-[11px] font-semibold transition ${
+                        on
+                          ? 'bg-accent-soft text-accent shadow-[inset_0_0_0_1px_var(--ds-accent)]'
+                          : 'text-ds-muted hover:bg-ds-card-muted'
+                      }`}
+                    >
+                      {t(opt.labelKey, opt.id)}
+                    </button>
+                  )
+                })}
+              </div>
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  )
+}
+
+function PickerItem({ active, onClick, children }: { active: boolean; onClick: () => void; children: ReactNode }): ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className={`flex w-full items-center gap-2 rounded-lg px-3 py-2 text-left text-[13px] hover:bg-accent-soft ${
+        active ? 'font-semibold text-accent' : 'text-ds-ink'
+      }`}
+    >
+      <Check className={`h-3.5 w-3.5 shrink-0 ${active ? 'text-accent opacity-100' : 'opacity-0'}`} />
+      <span className="truncate">{children}</span>
+    </button>
+  )
+}
+
+function ProfileDialog({
+  profile: initial,
+  isNew,
+  builtin,
+  groups,
+  onSave,
+  onCancel
+}: {
+  profile: KunSubagentProfileV1
+  isNew: boolean
+  builtin: boolean
+  groups: ModelProviderModelGroup[]
+  onSave: (p: KunSubagentProfileV1) => void
+  onCancel: () => void
+}): ReactElement {
+  const { t } = useTranslation('common')
+  const [d, setD] = useState<KunSubagentProfileV1>(initial)
+  const [tab, setTab] = useState<'basic' | 'permissions'>('basic')
+  const [catalog, setCatalog] = useState<CapabilityCatalog | null>(null)
+  const [catalogLoading, setCatalogLoading] = useState(false)
+  const set = <K extends keyof KunSubagentProfileV1>(k: K, v: KunSubagentProfileV1[K]): void =>
+    setD((p) => ({ ...p, [k]: v }))
+
+  // Lazily fetch the MCP/skill catalog the first time the Permissions tab opens —
+  // avoids a runtime round-trip for users who only edit the basic fields.
+  useEffect(() => {
+    if (tab !== 'permissions' || catalog || catalogLoading) return
+    setCatalogLoading(true)
+    void loadCapabilityCatalog().then(setCatalog).finally(() => setCatalogLoading(false))
+  }, [tab, catalog, catalogLoading])
+
+  // Drives the "Custom" chip on the Permissions tab: readOnly, or any deny-list set.
+  const customized = d.toolPolicy === 'readOnly'
+    || Boolean(d.blockedTools?.length || d.blockedMcpServers?.length || d.blockedSkills?.length)
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40 backdrop-blur-sm">
+      <div className="flex max-h-[90vh] w-full max-w-lg flex-col rounded-xl border border-ds-border bg-ds-main shadow-2xl">
+        <div className="flex items-center gap-2 border-b border-ds-border px-4 py-3">
+          <Bot className="h-4 w-4 text-ds-muted" />
+          <span className="text-sm font-semibold text-ds-heading">
+            {isNew ? t('subagentsPanel.newSubagent', 'New subagent') : t('agentsView.editAgent', 'Edit agent')}
+          </span>
+        </div>
+        <div className="flex shrink-0 gap-1 border-b border-ds-border px-3 pt-2">
+          <TabButton active={tab === 'basic'} onClick={() => setTab('basic')}>
+            {t('agentsView.tabBasic', 'Basic')}
+          </TabButton>
+          <TabButton
+            active={tab === 'permissions'}
+            onClick={() => setTab('permissions')}
+            badge={customized ? t('agentsView.permScopeCustom', 'Custom') : undefined}
+          >
+            {t('agentsView.tabPermissions', 'Permissions')}
+          </TabButton>
+        </div>
+        <div className="flex-1 space-y-3 overflow-y-auto px-4 py-4">
+          {tab === 'basic' ? (
+            <>
+          <Field label={t('agentsView.fName', 'Name')}>
+            <input
+              autoFocus
+              value={d.name}
+              disabled={builtin}
+              onChange={(e) => set('name', e.target.value)}
+              className="w-full rounded-md border border-ds-border bg-[var(--ds-surface-elevated)] px-3 py-1.5 text-sm"
+            />
+          </Field>
+          <Field label={t('agentsView.fDesc', 'Description')}>
+            <input
+              value={d.description ?? ''}
+              onChange={(e) => set('description', e.target.value || undefined)}
+              className="w-full rounded-md border border-ds-border bg-[var(--ds-surface-elevated)] px-3 py-1.5 text-sm"
+            />
+          </Field>
+          <Field label={t('agentsView.fColor', 'Color')}>
+            <div className="flex gap-2.5">
+              {PRESET_COLORS.map((c) => {
+                const selected = d.color === c
+                return (
+                  <button
+                    key={c}
+                    type="button"
+                    onClick={() => set('color', c)}
+                    aria-pressed={selected}
+                    className="relative h-8 w-8 rounded-full transition-transform hover:scale-110"
+                    style={{
+                      backgroundColor: c,
+                      boxShadow: selected
+                        ? `0 0 0 2px var(--ds-surface-card), 0 0 0 4px ${c}, 0 2px 6px ${c}66`
+                        : `inset 0 0 0 1px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.15)`
+                    }}
+                  >
+                    {selected && (
+                      <span className="absolute inset-0 flex items-center justify-center text-white text-sm font-semibold drop-shadow">
+                        ✓
+                      </span>
+                    )}
+                  </button>
+                )
+              })}
+            </div>
+          </Field>
+          <Field label={t('agentsView.fMode', 'Mode')}>
+            <select
+              value={d.mode}
+              onChange={(e) => set('mode', e.target.value as KunSubagentProfileV1['mode'])}
+              className="w-full rounded-md border border-ds-border bg-[var(--ds-surface-elevated)] px-3 py-1.5 text-sm"
+            >
+              <option value="subagent">{t('agentsView.modeDelegate', 'delegate')}</option>
+              <option value="primary">{t('agentsView.modePersona', 'persona')}</option>
+              <option value="all">{t('agentsView.modeBoth', 'both')}</option>
+            </select>
+          </Field>
+          <Field label={t('agentsView.fModel', 'Model')}>
+            <ModelSelectFull
+              value={d.model ?? ''}
+              providerId={d.providerId ?? ''}
+              groups={groups}
+              onChange={(m, pid) => setD((p) => ({ ...p, model: m || undefined, providerId: pid || undefined }))}
+              reasoning={d.reasoningEffort ?? 'off'}
+              onReasoningChange={(effort) =>
+                setD((p) => ({ ...p, reasoningEffort: effort === 'off' ? undefined : effort }))
+              }
+            />
+          </Field>
+          <Field label={t('agentsView.fSystemPrompt', 'System prompt')}>
+            <textarea
+              value={d.systemPrompt ?? ''}
+              rows={3}
+              onChange={(e) => set('systemPrompt', e.target.value || undefined)}
+              className="w-full resize-none rounded-md border border-ds-border bg-[var(--ds-surface-elevated)] px-3 py-1.5 text-sm"
+            />
+          </Field>
+            </>
+          ) : (
+            <PermissionsTab d={d} setD={setD} catalog={catalog} loading={catalogLoading} t={t} />
+          )}
+        </div>
+        <div className="flex justify-end gap-2 border-t border-ds-border px-4 py-3">
+          <button type="button" onClick={onCancel} className="rounded-md px-3 py-1.5 text-sm text-ds-muted hover:text-ds-heading">
+            {t('agentsView.cancel', 'Cancel')}
+          </button>
+          <button
+            type="button"
+            onClick={() => onSave({ ...d, name: d.name.trim() || d.id })}
+            className="rounded-md bg-accent px-4 py-1.5 text-sm font-medium text-white hover:bg-accent/90"
+          >
+            {isNew ? t('agentsView.create', 'Create') : t('agentsView.save', 'Save')}
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function TabButton({ active, onClick, badge, children }: {
+  active: boolean
+  onClick: () => void
+  badge?: string
+  children: ReactNode
+}): ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className={`flex items-center gap-1.5 border-b-2 px-3 py-2 text-[13px] transition ${
+        active ? 'border-accent text-ds-heading' : 'border-transparent text-ds-muted hover:text-ds-heading'
+      }`}
+    >
+      {children}
+      {badge ? (
+        <span
+          className="rounded-full px-1.5 py-px text-[9.5px] font-semibold"
+          style={{ backgroundColor: 'rgba(59,130,216,0.14)', color: '#3b82d8' }}
+        >
+          {badge}
+        </span>
+      ) : null}
+    </button>
+  )
+}
+
+/**
+ * Permission scope editor. The preset segmented control maps to the profile's
+ * deny-list fields: readOnly → toolPolicy:'readOnly'; All → inherit + cleared
+ * deny-lists; Custom → inherit + per-section block-lists. Everything here only
+ * REMOVES capabilities, so the child can never exceed the main agent.
+ */
+function PermissionsTab({ d, setD, catalog, loading, t }: {
+  d: KunSubagentProfileV1
+  setD: Dispatch<SetStateAction<KunSubagentProfileV1>>
+  catalog: CapabilityCatalog | null
+  loading: boolean
+  t: TFunction<'common'>
+}): ReactElement {
+  const [query, setQuery] = useState('')
+  const readOnly = d.toolPolicy === 'readOnly'
+  const hasDeny = Boolean(d.blockedTools?.length || d.blockedMcpServers?.length || d.blockedSkills?.length)
+  const scope: 'readOnly' | 'all' | 'custom' = readOnly ? 'readOnly' : hasDeny ? 'custom' : 'all'
+
+  const setScope = (next: 'readOnly' | 'all' | 'custom'): void => {
+    if (next === 'readOnly') { setD((p) => ({ ...p, toolPolicy: 'readOnly' })); return }
+    if (next === 'all') {
+      setD((p) => ({ ...p, toolPolicy: 'inherit', blockedTools: undefined, blockedMcpServers: undefined, blockedSkills: undefined }))
+      return
+    }
+    setD((p) => ({ ...p, toolPolicy: 'inherit' }))
+  }
+
+  const toggle = (key: 'blockedTools' | 'blockedMcpServers' | 'blockedSkills', id: string): void => {
+    setD((p) => {
+      const cur = new Set(p[key] ?? [])
+      if (cur.has(id)) cur.delete(id)
+      else cur.add(id)
+      const next = [...cur]
+      return { ...p, [key]: next.length ? next : undefined }
+    })
+  }
+
+  const q = query.trim().toLowerCase()
+  const tools = BUILTIN_TOOL_NAMES.filter((name) => !q || name.includes(q))
+  const servers = (catalog?.mcpServers ?? []).filter((s) => !q || s.id.toLowerCase().includes(q))
+  const skills = (catalog?.skills ?? []).filter((s) => !q || s.id.toLowerCase().includes(q) || s.name.toLowerCase().includes(q))
+
+  const toolsOn = BUILTIN_TOOL_NAMES.length - (d.blockedTools?.length ?? 0)
+  const serversTotal = catalog?.mcpServers.length ?? 0
+  const serversOn = serversTotal - (d.blockedMcpServers?.length ?? 0)
+  const skillsTotal = catalog?.skills.length ?? 0
+  const skillsBlocked = d.blockedSkills?.length ?? 0
+
+  const SEG: Array<{ id: 'readOnly' | 'all' | 'custom'; label: string }> = [
+    { id: 'readOnly', label: t('agentsView.permScopeReadOnly', 'Read-only') },
+    { id: 'all', label: t('agentsView.permScopeAll', 'All') },
+    { id: 'custom', label: t('agentsView.permScopeCustom', 'Custom') }
+  ]
+
+  return (
+    <div className="space-y-3">
+      <div>
+        <label className="mb-1 block text-xs font-medium text-ds-muted">{t('agentsView.permScope', 'Capability scope')}</label>
+        <div className="flex gap-1 rounded-lg bg-ds-subtle p-1">
+          {SEG.map((s) => (
+            <button
+              key={s.id}
+              type="button"
+              onClick={() => setScope(s.id)}
+              className={`flex-1 rounded-md px-2 py-1.5 text-[12.5px] font-medium transition ${
+                scope === s.id
+                  ? 'bg-[var(--ds-surface-elevated)] text-ds-heading shadow-[inset_0_0_0_1px_var(--ds-border)]'
+                  : 'text-ds-muted hover:text-ds-heading'
+              }`}
+            >
+              {s.label}
+            </button>
+          ))}
+        </div>
+        <p className="mt-1.5 text-[11px] text-ds-faint">
+          {scope === 'readOnly'
+            ? t('agentsView.permScopeReadOnlyNote', 'Investigation only: read / grep / find / ls. No MCP or skills.')
+            : scope === 'all'
+              ? t('agentsView.permScopeAllNote', 'Inherits every capability the main agent has.')
+              : t('agentsView.permScopeHint', 'Pick the capabilities this agent may use — never exceeds the main agent.')}
+        </p>
+      </div>
+
+      {readOnly ? null : (
+        <>
+          <div className="flex items-center gap-2 rounded-md border border-ds-border bg-[var(--ds-surface-elevated)] px-2.5 py-1.5">
+            <Search className="h-3.5 w-3.5 shrink-0 text-ds-faint" />
+            <input
+              value={query}
+              onChange={(e) => setQuery(e.target.value)}
+              placeholder={t('agentsView.permSearch', 'Search tools / MCP / skills…')}
+              className="w-full bg-transparent text-[12.5px] text-ds-heading outline-none placeholder:text-ds-faint"
+            />
+          </div>
+
+          <Section
+            icon={<Wrench className="h-3.5 w-3.5" />}
+            title={t('agentsView.permSecTools', 'Built-in tools')}
+            badge={`${toolsOn} / ${BUILTIN_TOOL_NAMES.length}`}
+          >
+            <div className="flex flex-wrap gap-1.5">
+              {tools.map((name) => {
+                const on = !d.blockedTools?.includes(name)
+                return (
+                  <button
+                    key={name}
+                    type="button"
+                    onClick={() => toggle('blockedTools', name)}
+                    className={`rounded-md px-2 py-1 text-[11.5px] font-medium transition ${
+                      on
+                        ? 'bg-accent-soft text-accent shadow-[inset_0_0_0_1px_var(--ds-accent)]'
+                        : 'text-ds-faint line-through hover:text-ds-muted'
+                    }`}
+                  >
+                    {name}
+                  </button>
+                )
+              })}
+            </div>
+          </Section>
+
+          <Section
+            icon={<Plug className="h-3.5 w-3.5" />}
+            title={t('agentsView.permSecMcp', 'MCP servers')}
+            badge={serversTotal ? `${serversOn} / ${serversTotal}` : undefined}
+          >
+            {loading ? (
+              <Hint>{t('agentsView.permLoading', 'Loading capabilities…')}</Hint>
+            ) : serversTotal === 0 ? (
+              <Hint>{t('agentsView.permNoMcp', 'No MCP servers configured.')}</Hint>
+            ) : (
+              <div className="space-y-0.5">
+                {servers.map((s) => (
+                  <CapRow
+                    key={s.id}
+                    on={!d.blockedMcpServers?.includes(s.id)}
+                    onToggle={() => toggle('blockedMcpServers', s.id)}
+                    label={s.id}
+                    meta={`${s.toolCount} ${t('agentsView.permToolsWord', 'tools')}`}
+                  />
+                ))}
+              </div>
+            )}
+          </Section>
+
+          <Section
+            icon={<Sparkles className="h-3.5 w-3.5" />}
+            title={t('agentsView.permSecSkills', 'Skills')}
+            badge={skillsTotal
+              ? (skillsBlocked
+                  ? `${t('agentsView.permScopeAll', 'All')} · ${skillsBlocked} ${t('agentsView.permBlocked', 'blocked')}`
+                  : t('agentsView.permScopeAll', 'All'))
+              : undefined}
+          >
+            {loading ? (
+              <Hint>{t('agentsView.permLoading', 'Loading capabilities…')}</Hint>
+            ) : skillsTotal === 0 ? (
+              <Hint>{t('agentsView.permNoSkills', 'No skills discovered.')}</Hint>
+            ) : (
+              <>
+                <p className="mb-1.5 text-[11px] text-ds-faint">{t('agentsView.permSkillsInheritNote', 'Inherits all available skills by default; block individually.')}</p>
+                <div className="max-h-44 space-y-0.5 overflow-y-auto">
+                  {skills.map((s) => (
+                    <CapRow
+                      key={s.id}
+                      on={!d.blockedSkills?.includes(s.id)}
+                      onToggle={() => toggle('blockedSkills', s.id)}
+                      label={s.name || s.id}
+                      meta={s.description}
+                    />
+                  ))}
+                </div>
+              </>
+            )}
+          </Section>
+        </>
+      )}
+    </div>
+  )
+}
+
+function Section({ icon, title, badge, children }: {
+  icon: ReactNode
+  title: string
+  badge?: string
+  children: ReactNode
+}): ReactElement {
+  return (
+    <div className="rounded-lg border border-ds-border">
+      <div className="flex items-center gap-2 border-b border-ds-border px-3 py-2">
+        <span className="text-ds-muted">{icon}</span>
+        <span className="text-[12.5px] font-medium text-ds-heading">{title}</span>
+        {badge ? <span className="ml-auto rounded-full bg-ds-subtle px-2 py-px text-[10.5px] text-ds-muted">{badge}</span> : null}
+      </div>
+      <div className="px-3 py-2.5">{children}</div>
+    </div>
+  )
+}
+
+function CapRow({ on, onToggle, label, meta }: {
+  on: boolean
+  onToggle: () => void
+  label: string
+  meta?: string
+}): ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={onToggle}
+      className="flex w-full items-center gap-2.5 rounded-md px-1.5 py-1.5 text-left hover:bg-ds-hover/60"
+    >
+      <span className={`flex h-4 w-7 shrink-0 items-center rounded-full p-0.5 transition ${on ? 'justify-end bg-accent' : 'justify-start bg-ds-border'}`}>
+        <span className="h-3 w-3 rounded-full bg-white" />
+      </span>
+      <span className={`min-w-0 flex-1 truncate text-[12.5px] ${on ? 'text-ds-heading' : 'text-ds-faint'}`}>{label}</span>
+      {meta ? <span className="max-w-[45%] shrink-0 truncate pl-2 text-[10.5px] text-ds-faint">{meta}</span> : null}
+    </button>
+  )
+}
+
+function Hint({ children }: { children: ReactNode }): ReactElement {
+  return <p className="text-[11.5px] text-ds-faint">{children}</p>
+}
+
+/** Full-width model picker for the dialog (reuses ModelSelect, stretched). */
+function ModelSelectFull(props: {
+  value: string
+  providerId: string
+  groups: ModelProviderModelGroup[]
+  onChange: (model: string, providerId: string) => void
+  reasoning?: string
+  onReasoningChange?: (effort: ModelReasoningEffort) => void
+}): ReactElement {
+  return <ModelSelect {...props} stretch />
+}
+
+function Field({ label, hint, children }: { label: string; hint?: string; children: ReactElement }): ReactElement {
+  return (
+    <div>
+      <label className="mb-1 block text-xs font-medium text-ds-muted">{label}</label>
+      {children}
+      {hint ? <p className="mt-1 text-xs text-ds-faint">{hint}</p> : null}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/terminal/TerminalPanel.tsx b/src/renderer/src/components/terminal/TerminalPanel.tsx
index bc66061d6..c71170760 100644
--- a/src/renderer/src/components/terminal/TerminalPanel.tsx
+++ b/src/renderer/src/components/terminal/TerminalPanel.tsx
@@ -590,7 +590,7 @@ export function TerminalPanel({ className = '', workspaceRoot, onCollapse, heigh
                         cancelRenameTab()
                       }
                     }}
-                    className="mx-2 min-w-0 flex-1 rounded-md border border-ds-border-muted bg-ds-card px-2 py-1 text-[12px] text-ds-ink outline-none focus:border-ds-accent"
+                    className="mx-2 min-w-0 flex-1 rounded-md border border-ds-border-muted bg-ds-card px-2 py-1 text-[12px] text-ds-ink outline-none focus:border-accent"
                     aria-label={t('terminalRenameTab')}
                   />
                 ) : (
diff --git a/src/renderer/src/components/workbench-layout.ts b/src/renderer/src/components/workbench-layout.ts
index 7c71826a4..f32969100 100644
--- a/src/renderer/src/components/workbench-layout.ts
+++ b/src/renderer/src/components/workbench-layout.ts
@@ -61,11 +61,11 @@ function persistBoolean(key: string, value: boolean): void {
 
 function readStoredRightPanelMode(): RightPanelMode {
   const raw = readBrowserStorageItem(RIGHT_PANEL_MODE_KEY)
-  return raw === 'todo' || raw === 'changes' || raw === 'browser' ? raw : null
+  return raw === 'todo' || raw === 'changes' || raw === 'browser' || raw === 'subagents' ? raw : null
 }
 
 function persistRightPanelMode(mode: RightPanelMode): void {
-  if (mode === 'todo' || mode === 'changes' || mode === 'browser') {
+  if (mode === 'todo' || mode === 'changes' || mode === 'browser' || mode === 'subagents') {
     writeBrowserStorageItem(RIGHT_PANEL_MODE_KEY, mode)
   } else {
     removeBrowserStorageItem(RIGHT_PANEL_MODE_KEY)
diff --git a/src/renderer/src/components/workflow/WorkflowEditorView.tsx b/src/renderer/src/components/workflow/WorkflowEditorView.tsx
index 24fca1514..37a01c585 100644
--- a/src/renderer/src/components/workflow/WorkflowEditorView.tsx
+++ b/src/renderer/src/components/workflow/WorkflowEditorView.tsx
@@ -437,7 +437,7 @@ function WorkflowEditorInner({
   )
 
   return (
-    <div className="ds-no-drag fixed inset-0 z-[60] flex bg-ds-main">
+    <div className="ds-no-drag ds-titlebar-fixed-overlay fixed inset-x-0 bottom-0 top-0 z-[60] flex bg-ds-main">
       {!leftPanelCollapsed ? (
         <aside className={WORKFLOW_EDITOR_SIDEBAR_CLASS}>
           <div className="shrink-0 px-2 pb-2 pt-3">
diff --git a/src/renderer/src/lib/apply-theme.ts b/src/renderer/src/lib/apply-theme.ts
index 849d21a4c..0ab3ff89a 100644
--- a/src/renderer/src/lib/apply-theme.ts
+++ b/src/renderer/src/lib/apply-theme.ts
@@ -1,11 +1,13 @@
 import {
   DEFAULT_CURSOR_SPOTLIGHT_COLOR,
+  normalizeUiFontScale,
   writeFontStackFor,
+  type UiFontScale,
   type WriteTypographySettingsV1
 } from '@shared/app-settings'
 
 export type ThemePreference = 'system' | 'light' | 'dark'
-export type UiFontScale = 'small' | 'medium' | 'large'
+export type { UiFontScale }
 
 let removeSystemListener: (() => void) | null = null
 
@@ -44,13 +46,7 @@ export function applyTheme(pref: ThemePreference): void {
 
 export function applyUiFontScale(scale: UiFontScale): void {
   const root = document.documentElement
-  const factor =
-    scale === 'small'
-      ? '0.82'
-      : scale === 'large'
-        ? '1'
-        : '0.88'
-  root.style.setProperty('--ds-ui-scale', factor)
+  root.style.setProperty('--ds-ui-scale', String(normalizeUiFontScale(scale)))
 }
 
 export function applyCursorSpotlight(enabled: boolean): void {
diff --git a/src/renderer/src/lib/attachment-upload-availability.test.ts b/src/renderer/src/lib/attachment-upload-availability.test.ts
index cc615dce8..46595ab8a 100644
--- a/src/renderer/src/lib/attachment-upload-availability.test.ts
+++ b/src/renderer/src/lib/attachment-upload-availability.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 import { isChatAttachmentUploadEnabled } from './attachment-upload-availability'
 
 describe('isChatAttachmentUploadEnabled', () => {
-  it('enables composer attachments in chat when the Kun attachment store is ready', () => {
+  it('enables composer attachments in chat when the runtime is ready', () => {
     expect(isChatAttachmentUploadEnabled({
       runtimeConnection: 'ready',
       route: 'chat',
@@ -19,7 +19,7 @@ describe('isChatAttachmentUploadEnabled', () => {
     })).toBe(true)
   })
 
-  it('enables composer attachments in Write mode assistants when the selected model can read images', () => {
+  it('enables composer attachments in Write mode assistants', () => {
     expect(isChatAttachmentUploadEnabled({
       runtimeConnection: 'ready',
       route: 'write',
@@ -44,12 +44,15 @@ describe('isChatAttachmentUploadEnabled', () => {
       attachmentStoreAvailable: true,
       modelSupportsImageInput: true
     })).toBe(false)
+  })
+
+  it('keeps the attachment picker reachable for non-image documents', () => {
     expect(isChatAttachmentUploadEnabled({
       runtimeConnection: 'ready',
       route: 'chat',
       mode: 'agent',
-      attachmentStoreAvailable: true,
+      attachmentStoreAvailable: false,
       modelSupportsImageInput: false
-    })).toBe(false)
+    })).toBe(true)
   })
 })
diff --git a/src/renderer/src/lib/attachment-upload-availability.ts b/src/renderer/src/lib/attachment-upload-availability.ts
index b59c3f184..2fcc9f1e0 100644
--- a/src/renderer/src/lib/attachment-upload-availability.ts
+++ b/src/renderer/src/lib/attachment-upload-availability.ts
@@ -10,8 +10,6 @@ export function isChatAttachmentUploadEnabled(input: AttachmentUploadAvailabilit
   return (
     input.runtimeConnection === 'ready' &&
     (input.route === 'chat' || input.route === 'write') &&
-    (input.mode === 'agent' || input.mode === 'plan') &&
-    input.attachmentStoreAvailable === true &&
-    input.modelSupportsImageInput === true
+    (input.mode === 'agent' || input.mode === 'plan')
   )
 }
diff --git a/src/renderer/src/lib/claw-model-options.test.ts b/src/renderer/src/lib/claw-model-options.test.ts
index f845c21db..becfcd870 100644
--- a/src/renderer/src/lib/claw-model-options.test.ts
+++ b/src/renderer/src/lib/claw-model-options.test.ts
@@ -25,11 +25,12 @@ function buildSettings(models: string[]): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'medium',
+    uiFontScale: 0.88,
     provider,
     agents: { kun: defaultKunRuntimeSettings() },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: true, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/renderer/src/lib/context-capacity.test.ts b/src/renderer/src/lib/context-capacity.test.ts
index 985cafe5d..593487374 100644
--- a/src/renderer/src/lib/context-capacity.test.ts
+++ b/src/renderer/src/lib/context-capacity.test.ts
@@ -43,6 +43,19 @@ describe('buildContextCapacity', () => {
     expect(cap.usedRatio).toBeCloseTo(138_389 / 200_000, 5)
   })
 
+  it('lets live message estimates raise a stale measured total while streaming', () => {
+    const cap = buildContextCapacity({
+      windowTokens: 200_000,
+      lastTurnInputTokens: 20_000,
+      messageTokens: 40_000,
+      toolCount: 20,
+      skillCount: 4
+    })
+    expect(cap.hasMeasuredTotal).toBe(true)
+    expect(cap.usedTokens).toBeGreaterThan(20_000)
+    expect(cap.usedTokens).toBeGreaterThan(cap.categories.find((c) => c.key === 'messages')?.tokens ?? 0)
+  })
+
   it('clamps a measured total that exceeds the window', () => {
     const cap = buildContextCapacity({
       windowTokens: 100_000,
diff --git a/src/renderer/src/lib/context-capacity.ts b/src/renderer/src/lib/context-capacity.ts
index d3781217c..9e0e455e3 100644
--- a/src/renderer/src/lib/context-capacity.ts
+++ b/src/renderer/src/lib/context-capacity.ts
@@ -196,9 +196,12 @@ export function buildContextCapacity(input: ContextCapacityInput): ContextCapaci
   let usedTokens: number
 
   if (hasMeasuredTotal) {
-    // Real total; estimate the breakdown but scale the prefix so the parts add
-    // up to the measured occupancy exactly.
-    usedTokens = clamp(Math.round(measuredTotal), 0, windowTokens)
+    // Real total from the latest provider count, with a live local floor. While
+    // an assistant reply is streaming, the provider count can still describe
+    // the request that started the turn, but the partial reply is already
+    // visible future context. Let the estimate raise the total until the next
+    // provider usage event calibrates it again.
+    usedTokens = clamp(Math.round(Math.max(measuredTotal, localEstimate)), 0, windowTokens)
     messages = clamp(messageEstimate, 0, usedTokens)
     const prefixActual = Math.max(0, usedTokens - messages)
     const scale = prefixEstimate > 0 ? prefixActual / prefixEstimate : 0
diff --git a/src/renderer/src/lib/format-runtime-error.test.ts b/src/renderer/src/lib/format-runtime-error.test.ts
index cedddf3bf..b74fe3cb1 100644
--- a/src/renderer/src/lib/format-runtime-error.test.ts
+++ b/src/renderer/src/lib/format-runtime-error.test.ts
@@ -36,6 +36,17 @@ describe('format runtime error', () => {
     expect(formatRuntimeError(error)).toBe(i18n.t('common:runtimeFetchFailed'))
   })
 
+  it('classifies upstream model request failures separately from local runtime fetch failures', () => {
+    const error = new Error(JSON.stringify({
+      message: 'model request failed: fetch failed',
+      severity: 'error'
+    }))
+
+    expect(getRuntimeErrorCode(error)).toBe('model_request_failed')
+    expect(formatRuntimeError(error)).toBe(i18n.t('common:runtimeModelRequestFailed'))
+    expect(formatRuntimeError(error)).not.toBe(i18n.t('common:runtimeFetchFailed'))
+  })
+
   it('keeps raw provider messages visible in details even when the summary is the same text', () => {
     const message = `model request failed with status 400: ${JSON.stringify({
       error: {
diff --git a/src/renderer/src/lib/format-runtime-error.ts b/src/renderer/src/lib/format-runtime-error.ts
index b71abeab7..1e190ce64 100644
--- a/src/renderer/src/lib/format-runtime-error.ts
+++ b/src/renderer/src/lib/format-runtime-error.ts
@@ -43,6 +43,7 @@ function runtimeErrorCode(payload: RuntimeErrorPayload | null, raw: string): str
   const fromError = typeof payload?.error === 'string' ? payload.error.trim() : ''
   if (fromError) return fromError.toLowerCase()
   const lowered = stripIpcPrefix(payloadMessage(payload) || raw).toLowerCase()
+  if (lowered.includes('model request failed:')) return 'model_request_failed'
   if (lowered.includes('fetch failed')) return 'fetch_failed'
   if (lowered.includes('runtime unhealthy')) return 'runtime_unhealthy'
   if (lowered.includes('active turn')) return 'turn_in_progress'
@@ -80,6 +81,10 @@ function detailString(value: unknown): string {
 function localizedRuntimeSummary(code: string | null, text: string): string | null {
   const lowered = text.toLowerCase()
 
+  if (code === 'model_request_failed' || lowered.includes('model request failed:')) {
+    return i18n.t('common:runtimeModelRequestFailed')
+  }
+
   if (code === 'fetch_failed' || lowered.includes('fetch failed')) {
     return i18n.t('common:runtimeFetchFailed')
   }
diff --git a/src/renderer/src/lib/middle-ellipsize.test.ts b/src/renderer/src/lib/middle-ellipsize.test.ts
new file mode 100644
index 000000000..a298c7098
--- /dev/null
+++ b/src/renderer/src/lib/middle-ellipsize.test.ts
@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { middleEllipsize } from './middle-ellipsize'
+
+describe('middleEllipsize', () => {
+  it('keeps short text unchanged', () => {
+    expect(middleEllipsize('main', 12)).toBe('main')
+  })
+
+  it('cuts long text from the middle with three dots', () => {
+    expect(middleEllipsize('this-is-a-very-long-branch-name-that-definitely-overflows', 30))
+      .toBe('this-is-a-very...ely-overflows')
+  })
+
+  it('handles very small limits without exceeding the requested length', () => {
+    expect(middleEllipsize('branch', 2)).toBe('..')
+  })
+})
diff --git a/src/renderer/src/lib/middle-ellipsize.ts b/src/renderer/src/lib/middle-ellipsize.ts
new file mode 100644
index 000000000..4a6d30ae1
--- /dev/null
+++ b/src/renderer/src/lib/middle-ellipsize.ts
@@ -0,0 +1,12 @@
+export function middleEllipsize(value: string, maxLength: number): string {
+  if (maxLength <= 0) return ''
+  if (value.length <= maxLength) return value
+  if (maxLength <= 3) return '.'.repeat(maxLength)
+
+  const marker = '...'
+  const visibleLength = maxLength - marker.length
+  const startLength = Math.ceil(visibleLength / 2)
+  const endLength = Math.floor(visibleLength / 2)
+
+  return `${value.slice(0, startLength)}${marker}${value.slice(value.length - endLength)}`
+}
diff --git a/src/renderer/src/lib/settings-home-paths.test.ts b/src/renderer/src/lib/settings-home-paths.test.ts
index 4fc87e15b..41b0efb9a 100644
--- a/src/renderer/src/lib/settings-home-paths.test.ts
+++ b/src/renderer/src/lib/settings-home-paths.test.ts
@@ -92,7 +92,7 @@ function settings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     cursorSpotlight: true,
     provider: defaultModelProviderSettings(),
     agents: {
@@ -108,6 +108,7 @@ function settings(): AppSettingsV1 {
     },
     workspaceRoot: '~/.kun/default_workspace',
     log: { enabled: true, retentionDays: 2 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/renderer/src/lib/workspace-file-index.ts b/src/renderer/src/lib/workspace-file-index.ts
index ac41882e5..8937857be 100644
--- a/src/renderer/src/lib/workspace-file-index.ts
+++ b/src/renderer/src/lib/workspace-file-index.ts
@@ -76,9 +76,9 @@ const FILE_MENTION_IGNORED_DIRS = new Set([
   'node_modules',
   'out'
 ])
-const FILE_MENTION_MAX_DEPTH = 6
-const FILE_MENTION_MAX_DIRECTORIES = 140
-const FILE_MENTION_MAX_FILES = 1200
+const FILE_MENTION_MAX_DEPTH = 10  /* #340: increased from 6 for deep paths */
+const FILE_MENTION_MAX_DIRECTORIES = 200
+const FILE_MENTION_MAX_FILES = 1600
 const FILE_MENTION_MAX_DIRECTORY_SUGGESTIONS = 400
 const FILE_MENTION_CACHE_TTL_MS = 30_000
 
diff --git a/src/renderer/src/locales/en/common.json b/src/renderer/src/locales/en/common.json
index b27e27295..99344c5ae 100644
--- a/src/renderer/src/locales/en/common.json
+++ b/src/renderer/src/locales/en/common.json
@@ -1021,6 +1021,9 @@
   "composerImageUnavailable": "Image input is unavailable for this runtime.",
   "composerAttachmentUnavailable": "Attachment upload is unavailable.",
   "composerAttachmentModelUnsupported": "The selected model cannot read images. Switch to a vision model or remove the attachment.",
+  "composerPdfAttachmentUnavailable": "PDF text extraction is unavailable for this file.",
+  "composerPdfAttachmentNoText": "This PDF does not contain extractable text. Try an OCR version or paste the relevant pages.",
+  "composerAttachmentUnsupportedType": "Only PNG, JPEG, WebP, and PDF files can be attached here.",
   "composerRemoveAttachment": "Remove attachment",
   "composerFileMentionMenuTitle": "Files & folders",
   "composerFileMentionLoading": "Loading files…",
@@ -1328,6 +1331,7 @@
   "approvalDeny": "Deny",
   "approvalAllowed": "Allowed",
   "approvalDenied": "Denied",
+  "approvalSubmitting": "Submitting decision…",
   "approvalFailed": "Request failed",
   "userInputTitle": "Input required",
   "userInputPending": "Waiting for your answer…",
@@ -1340,6 +1344,11 @@
   "userInputCustomPlaceholder": "Type your answer…",
   "userInputSubmit": "Submit",
   "userInputCancel": "Cancel",
+  "userInputPanelTitle": "Quick question",
+  "userInputComposerPlaceholder": "Choose above, or type your answer…",
+  "userInputPanelFreeformHint": "Type your answer below, then press Enter",
+  "userInputPanelCustomHint": "Or type your own answer below",
+  "userInputAnswerBelowHint": "Answer below the input box",
   "approvalAutoShort": "Auto",
   "approvalOnRequestShort": "Ask first",
   "approvalUntrustedShort": "Risky only",
@@ -1418,6 +1427,7 @@
   "busyTimeout": "No response from the runtime after waiting {{minutes}} minutes. Deep-thinking tasks may take longer. If it stays stuck, you can cancel and retry.",
   "runtimeActionNeedsConnection": "Connect to the runtime before using AI actions.",
   "runtimeFetchFailed": "Could not reach Kun. Make sure `kun serve` is running, or enable auto-start in Settings.",
+  "runtimeModelRequestFailed": "Kun could not reach the model provider. Check your network, proxy settings, and provider configuration (Base URL, Endpoint format).",
   "runtimeBinaryNotInstalled": "The Kun CLI was not found. Run `npm install` in the project folder to fetch it, or set the binary path in Settings.",
   "runtimeMissingApiKey": "DeepSeek API Key is missing. Open Settings and add it before the GUI can start the local runtime.",
   "runtimeAutoStartDisabled": "Kun is offline. Enable automatic startup in Settings, or start `kun serve` manually.",
@@ -1541,8 +1551,13 @@
   "sidebarWorkspaceNewThread": "New thread",
   "sidebarWorkspaceShowMore": "Show more ({{count}} more)",
   "sidebarWorkspaceShowLess": "Show less",
-  "sidebarWorkspaceRemove": "Delete workspace",
-  "sidebarWorkspaceRemoveConfirm": "Delete workspace \"{{path}}\" and all its threads? This cannot be undone.",
+  "sidebarWorkspaceRemove": "Remove workspace",
+  "sidebarWorkspaceRemoveConfirm": "Remove workspace \"{{path}}\" and all its threads? This cannot be undone.",
+  "sidebarWorkspaceOpenInSystem": "Open in file explorer",
+  "sidebarWorkspaceRemoveDialogTitle": "Remove {{name}}?",
+  "sidebarWorkspaceRemoveDialogDescription": "This removes the project from Kun. Files on disk will not be deleted.",
+  "sidebarWorkspaceRemoveDialogDetail": "You can add this project again later from the workspace picker.",
+  "sidebarWorkspaceRemoveConfirmButton": "Remove",
   "sidebarSearchThreads": "Search threads and requirements",
   "sidebarShowArchivedThreads": "Show archived threads",
   "sidebarShowActiveThreads": "Show active threads",
@@ -1550,11 +1565,24 @@
   "sidebarArchiveEmpty": "No archived threads",
   "sidebarThreadArchive": "Archive thread",
   "sidebarThreadArchiveConfirm": "Archive thread \"{{title}}\"?",
+  "sidebarThreadArchiveDialogTitle": "Archive this thread?",
+  "sidebarThreadArchiveDialogDescription": "It moves out of the active list and can be restored from archived threads.",
+  "sidebarThreadArchiveDialogDetail": "The conversation history stays available; it is only hidden from the active project list.",
+  "sidebarThreadArchiveConfirmButton": "Archive",
   "sidebarThreadRestore": "Restore thread",
   "sidebarThreadRename": "Rename thread",
   "sidebarThreadRenamePrompt": "Enter a new thread name",
+  "sidebarThreadPin": "Pin thread",
+  "sidebarThreadUnpin": "Unpin thread",
+  "sidebarThreadPinned": "Pinned thread",
   "sidebarThreadDelete": "Delete thread",
   "sidebarThreadDeleteConfirm": "Delete thread \"{{title}}\"? This cannot be undone.",
+  "sidebarThreadDeleteDialogTitle": "Delete this thread?",
+  "sidebarThreadDeleteDialogDescription": "This permanently deletes the conversation from Kun.",
+  "sidebarThreadDeleteDialogDetail": "This action cannot be undone. Archive the thread instead if you may need it later.",
+  "sidebarThreadDeleteConfirmButton": "Delete",
+  "sidebarThreadPreviewUpdated": "Updated {{time}}",
+  "sidebarThreadPreviewEmpty": "No preview text yet.",
   "sidebarThreadRunning": "Running",
   "sidebarThreadUnread": "New reply",
   "sidebarThreadForkBadge": "Fork",
@@ -1658,6 +1686,9 @@
   "sddDraftHistoryOpenFailed": "Could not open the requirement draft.",
   "sddDraftHistoryDelete": "Delete requirement draft",
   "sddDraftHistoryDeleteConfirm": "Delete requirement draft \"{{title}}\"? This cannot be undone.",
+  "sddDraftHistoryDeleteDialogTitle": "Delete {{title}}?",
+  "sddDraftHistoryDeleteDialogDescription": "This removes the local requirement draft from the sidebar.",
+  "sddDraftHistoryDeleteDialogDetail": "The associated draft files are deleted from the workspace draft folder.",
   "sddDraftHistoryDeleteFailed": "Delete failed: {{message}}",
   "sddDraftHistoryShowMore": "Show more ({{count}} more)",
   "sddDraftHistoryRemembered": "Recent",
@@ -2012,6 +2043,23 @@
   "toolBuiltinFind": "Find",
   "toolBuiltinLs": "List",
   "toolBuiltinBash": "Bash",
+  "toolBuiltinDelegate": "Delegate task",
+  "subagentDefaultName": "Subagent",
+  "subagentStatusQueued": "Queued",
+  "subagentStatusRunning": "Running",
+  "subagentStatusDone": "Done",
+  "subagentStatusFailed": "Failed",
+  "subagentStatusAwaiting": "Awaiting approval",
+  "subagentSteps": "{{count}} steps",
+  "subagentQueuedHint": "Queued",
+  "subagentTokensChip": "{{count}} tokens",
+  "subagentPolicyReadOnly": "Read-only",
+  "subagentPolicyFull": "Full access",
+  "subagentOpenSession": "Open sub-session",
+  "subagentSwarmTitle": "{{count}} subagents",
+  "subagentSwarmRunning": "{{count}} running",
+  "subagentSwarmQueued": "{{count}} queued",
+  "subagentSwarmDone": "{{count}} done",
   "sidebarFooterHint": "Connect the local runtime to create threads and chat with the agent.",
   "appErrorTitle": "Something went wrong",
   "appErrorReload": "Reload",
@@ -2063,5 +2111,123 @@
   "planVerify": "Verify",
   "planVerifyRunning": "Verifying…",
   "sddChangedBanner": "Requirements {{ids}} changed after planning; the plan may be stale",
-  "sddReplanButton": "Replan affected steps"
+  "sddReplanButton": "Replan affected steps",
+  "agentsView": {
+    "configureModel": "configure model",
+    "delegatable": "Delegatable · usable in chat",
+    "system": "System · runs automatically",
+    "compaction": "Compaction",
+    "compactionDesc": "Compress long context",
+    "title": "Title",
+    "titleDesc": "Generate chat title",
+    "summary": "Summary",
+    "summaryDesc": "Conversation summary",
+    "ruleBased": "Rule-based",
+    "deleteConfirm": "Delete this agent?",
+    "followDefault": "Follow default",
+    "builtinTag": "built-in",
+    "edit": "Edit",
+    "delete": "Delete",
+    "editAgent": "Edit agent",
+    "fName": "Name",
+    "fDesc": "Description",
+    "fColor": "Color",
+    "fMode": "Mode",
+    "modeDelegate": "delegate",
+    "modePersona": "persona",
+    "modeBoth": "both",
+    "fTools": "Tool access",
+    "toolReadOnly": "read-only",
+    "toolInherit": "all tools",
+    "tabBasic": "Basic",
+    "tabPermissions": "Permissions",
+    "permScope": "Capability scope",
+    "permScopeReadOnly": "Read-only",
+    "permScopeAll": "All",
+    "permScopeCustom": "Custom",
+    "permScopeHint": "Pick the capabilities this agent may use — never exceeds the main agent.",
+    "permScopeReadOnlyNote": "Investigation only: read / grep / find / ls. No MCP or skills.",
+    "permScopeAllNote": "Inherits every capability the main agent has.",
+    "permSearch": "Search tools / MCP / skills…",
+    "permSecTools": "Built-in tools",
+    "permSecMcp": "MCP servers",
+    "permSecSkills": "Skills",
+    "permToolsWord": "tools",
+    "permBlocked": "blocked",
+    "permSkillsInheritNote": "Inherits all available skills by default; block individually.",
+    "permNoMcp": "No MCP servers configured.",
+    "permNoSkills": "No skills discovered.",
+    "permLoading": "Loading capabilities…",
+    "fModel": "Model",
+    "modelHint": "Pick on the list row, or set provider:model here",
+    "providerId": "provider id",
+    "fSystemPrompt": "System prompt",
+    "cancel": "Cancel",
+    "create": "Create",
+    "save": "Save",
+    "builtin": {
+      "general": "General-purpose agent: research and multi-step tasks, full tools, can edit files, runs in parallel.",
+      "explore": "Read-only code explorer: find files, search keywords, answer questions; never edits."
+    }
+  },
+  "subagents": "Subagents",
+  "disable": "Disable",
+  "enable": "Enable",
+  "expandSidebar": "Expand sidebar",
+  "rightPanelSubagents": "Subagents",
+  "subagentsPanel": {
+    "configModel": "configure model",
+    "delegatable": "Delegatable · usable in chat",
+    "system": "System · internal",
+    "global": "Global · shared",
+    "newSubagent": "New subagent",
+    "smallModel": {
+      "name": "Small model",
+      "desc": "Default for Title & Summary"
+    },
+    "role": {
+      "design-reviewer": {
+        "name": "Design review",
+        "desc": "design-reviewer · read-only"
+      },
+      "over-engineering-reviewer": {
+        "name": "Over-engineering review",
+        "desc": "over-engineering-reviewer · read-only"
+      },
+      "compaction": {
+        "name": "Compaction",
+        "desc": "Configurable · defaults to main model"
+      },
+      "codeReview": {
+        "name": "Code review",
+        "desc": "Isolated read-only run · configurable"
+      },
+      "title": {
+        "name": "Title",
+        "desc": "LLM · defaults to small model"
+      },
+      "summary": {
+        "name": "Summary",
+        "desc": "LLM · defaults to small model"
+      },
+      "general": {
+        "name": "General",
+        "desc": "Full tools · multi-step work"
+      },
+      "explore": {
+        "name": "Explore",
+        "desc": "Read-only · find & search code"
+      }
+    },
+    "builtin": "Built-in"
+  },
+  "summarizeSession": "Summarize",
+  "summarizing": "Summarizing…",
+  "summarizeFailed": "Could not summarize this conversation",
+  "name": "Name",
+  "description": "Description",
+  "color": "Color",
+  "mode": "Mode",
+  "systemPrompt": "System prompt",
+  "toolPolicy": "Tool access"
 }
diff --git a/src/renderer/src/locales/en/settings.json b/src/renderer/src/locales/en/settings.json
index a5f6c7c2a..666cd1f43 100644
--- a/src/renderer/src/locales/en/settings.json
+++ b/src/renderer/src/locales/en/settings.json
@@ -275,9 +275,9 @@
   "modelProviderApiKeyPlaceholder": "Enter this provider's API key",
   "modelProviderBaseUrl": "Base URL",
   "modelProviderEndpointFormat": "Endpoint format",
-  "modelEndpointChatCompletions": "/v1/chat/completions",
-  "modelEndpointResponses": "/v1/responses",
-  "modelEndpointMessages": "/v1/messages",
+  "modelEndpointChatCompletions": "/v1/chat/completions (openai)",
+  "modelEndpointResponses": "/v1/responses (openai)",
+  "modelEndpointMessages": "/v1/messages (anthropic)",
   "modelEndpointCustomEndpoint": "Custom full endpoint",
   "modelEndpointCustomEndpointDesc": "Uses this URL as the final endpoint. Only paths ending in /chat/completions, /completions, /responses, or /messages can be recognized; other endings are not supported.",
   "modelProviderModels": "Models",
@@ -797,6 +797,9 @@
   "mcpFormEnabled": "Enabled",
   "mcpFormRemoveServer": "Remove server",
   "mcpFormCommand": "Command",
+  "mcpFormCwd": "Working directory",
+  "mcpFormCwdPlaceholder": "/Users/me/project",
+  "mcpFormCwdHint": "Optional. If blank, workspace-scoped stdio servers start in the first trusted workspace path.",
   "mcpFormArgs": "Arguments (one per line)",
   "mcpFormArgsPlaceholder": "-y\nsome-mcp-package",
   "mcpFormEnv": "Environment variables",
@@ -855,6 +858,8 @@
   "firstRunModeLabel": "Access mode",
   "firstRunModeApi": "Pay-as-you-go API",
   "firstRunModeTokenPlan": "Token Plan",
+  "firstRunPermissionLabel": "Default Agent permissions",
+  "firstRunPermissionFullAccessRisk": "\"Full access\" lets the Agent run tools without asking and gives it full local access. Choose it only when you fully trust the current task and input.",
   "firstRunRegionLabel": "Plan region",
   "firstRunRegion_cn": "China",
   "firstRunRegion_global": "Global",
@@ -1086,6 +1091,16 @@
   "logRetentionThree": "3 days",
   "logRetentionFive": "5 days",
   "logRetentionSeven": "7 days",
+  "gitCheckpointTitle": "Git checkpoint management",
+  "checkpointCleanupEnabled": "Automatically clean up unused checkpoints",
+  "checkpointCleanupEnabledDesc": "When enabled, periodically delete Git checkpoint directories no longer referenced by any chat. Off by default.",
+  "checkpointCleanupInterval": "Unused Git checkpoint cleanup",
+  "checkpointCleanupIntervalDesc": "Delete Git checkpoint directories that are no longer referenced by any chat on this schedule.",
+  "checkpointCleanupInterval1": "Every 1 day",
+  "checkpointCleanupInterval2": "Every 2 days",
+  "checkpointCleanupInterval3": "Every 3 days",
+  "checkpointCleanupInterval5": "Every 5 days",
+  "checkpointCleanupInterval10": "Every 10 days",
   "loading": "Loading…",
   "loadFailed": "Could not load settings: {{message}}",
   "preloadBridgeError": "The app bridge is not available. Restart the application or check the preload path.",
diff --git a/src/renderer/src/locales/zh/common.json b/src/renderer/src/locales/zh/common.json
index 659c7f5dc..a03a0f158 100644
--- a/src/renderer/src/locales/zh/common.json
+++ b/src/renderer/src/locales/zh/common.json
@@ -1021,6 +1021,9 @@
   "composerImageUnavailable": "当前运行时暂不可用图片输入。",
   "composerAttachmentUnavailable": "当前暂不可上传附件。",
   "composerAttachmentModelUnsupported": "当前选择的模型不能读取图片，请切换到识图模型或移除图片附件。",
+  "composerPdfAttachmentUnavailable": "当前无法读取这个 PDF。",
+  "composerPdfAttachmentNoText": "这个 PDF 没有可提取的文本，请尝试 OCR 版本或粘贴相关页面。",
+  "composerAttachmentUnsupportedType": "这里只支持 PNG、JPEG、WebP 和 PDF 文件。",
   "composerRemoveAttachment": "移除附件",
   "composerFileMentionMenuTitle": "文件与目录",
   "composerFileMentionLoading": "正在加载文件…",
@@ -1328,6 +1331,7 @@
   "approvalDeny": "拒绝",
   "approvalAllowed": "已允许",
   "approvalDenied": "已拒绝",
+  "approvalSubmitting": "正在提交选择…",
   "approvalFailed": "请求失败",
   "userInputTitle": "需要你的输入",
   "userInputPending": "等待你选择…",
@@ -1340,6 +1344,11 @@
   "userInputCustomPlaceholder": "输入你的回答…",
   "userInputSubmit": "提交",
   "userInputCancel": "取消",
+  "userInputPanelTitle": "快速提问",
+  "userInputComposerPlaceholder": "在上方选择,或直接输入你的回答…",
+  "userInputPanelFreeformHint": "在下方输入回答后按回车",
+  "userInputPanelCustomHint": "也可以在下方输入自定义回答",
+  "userInputAnswerBelowHint": "在下方输入框回答",
   "approvalAutoShort": "自动执行",
   "approvalOnRequestShort": "需要确认",
   "approvalUntrustedShort": "敏感确认",
@@ -1418,6 +1427,7 @@
   "busyTimeout": "已等待 {{minutes}} 分钟仍未收到运行时完成事件。深度思考任务可能需要更长时间,如果仍然卡住可中断后重试。",
   "runtimeActionNeedsConnection": "请先连接运行时后再使用 AI。",
   "runtimeFetchFailed": "无法连接到 Kun。请确认 `kun serve` 已启动，或在设置中开启自动启动。",
+  "runtimeModelRequestFailed": "Kun 无法连接到模型供应商。请检查网络、代理设置以及供应商配置（Base URL、Endpoint format）。",
   "runtimeBinaryNotInstalled": "未找到 Kun 可执行文件。请在项目目录运行 npm install 以下载 CLI，或在设置中填写 Kun 二进制路径。",
   "runtimeMissingApiKey": "尚未配置 DeepSeek API Key。请先打开设置填写，然后 GUI 才能自动启动本地运行时。",
   "runtimeAutoStartDisabled": "Kun 当前未启动。请在设置中开启自动启动，或手动执行 `kun serve`。",
@@ -1541,8 +1551,13 @@
   "sidebarWorkspaceNewThread": "新建会话",
   "sidebarWorkspaceShowMore": "展开显示（还有 {{count}} 条）",
   "sidebarWorkspaceShowLess": "收起",
-  "sidebarWorkspaceRemove": "删除工作区",
-  "sidebarWorkspaceRemoveConfirm": "确定删除工作区「{{path}}」及其中所有会话吗？此操作无法撤销。",
+  "sidebarWorkspaceRemove": "移除工作区",
+  "sidebarWorkspaceRemoveConfirm": "确定移除工作区「{{path}}」及其中所有会话吗？此操作无法撤销。",
+  "sidebarWorkspaceOpenInSystem": "在资源管理器中打开",
+  "sidebarWorkspaceRemoveDialogTitle": "移除 {{name}}？",
+  "sidebarWorkspaceRemoveDialogDescription": "这会从 Kun 中移除该项目。磁盘上的文件不会被删除。",
+  "sidebarWorkspaceRemoveDialogDetail": "之后仍可通过工作区选择器重新添加这个项目。",
+  "sidebarWorkspaceRemoveConfirmButton": "移除",
   "sidebarSearchThreads": "搜索会话和需求",
   "sidebarShowArchivedThreads": "查看归档会话",
   "sidebarShowActiveThreads": "查看活跃会话",
@@ -1550,11 +1565,24 @@
   "sidebarArchiveEmpty": "没有归档会话",
   "sidebarThreadArchive": "归档会话",
   "sidebarThreadArchiveConfirm": "确定归档会话「{{title}}」吗？",
+  "sidebarThreadArchiveDialogTitle": "归档这个会话？",
+  "sidebarThreadArchiveDialogDescription": "它会移出活跃列表，之后可以从归档会话里恢复。",
+  "sidebarThreadArchiveDialogDetail": "会话历史仍会保留；它只是从当前项目列表中隐藏。",
+  "sidebarThreadArchiveConfirmButton": "归档",
   "sidebarThreadRestore": "恢复会话",
   "sidebarThreadRename": "重命名会话",
   "sidebarThreadRenamePrompt": "输入新的会话名称",
+  "sidebarThreadPin": "置顶会话",
+  "sidebarThreadUnpin": "取消置顶",
+  "sidebarThreadPinned": "已置顶会话",
   "sidebarThreadDelete": "删除会话",
   "sidebarThreadDeleteConfirm": "确定删除会话「{{title}}」吗？此操作无法撤销。",
+  "sidebarThreadDeleteDialogTitle": "删除这个会话？",
+  "sidebarThreadDeleteDialogDescription": "这会从 Kun 中永久删除该会话。",
+  "sidebarThreadDeleteDialogDetail": "此操作无法撤销。如果之后可能还需要，请改用归档。",
+  "sidebarThreadDeleteConfirmButton": "删除",
+  "sidebarThreadPreviewUpdated": "{{time}} 更新",
+  "sidebarThreadPreviewEmpty": "暂无预览内容。",
   "sidebarThreadRunning": "运行中",
   "sidebarThreadUnread": "有新回复",
   "sidebarThreadForkBadge": "分叉",
@@ -1658,6 +1686,9 @@
   "sddDraftHistoryOpenFailed": "无法打开这个需求草稿。",
   "sddDraftHistoryDelete": "删除需求草稿",
   "sddDraftHistoryDeleteConfirm": "确定删除需求草稿「{{title}}」吗？此操作无法撤销。",
+  "sddDraftHistoryDeleteDialogTitle": "删除「{{title}}」？",
+  "sddDraftHistoryDeleteDialogDescription": "这会从侧边栏移除该本地需求草稿。",
+  "sddDraftHistoryDeleteDialogDetail": "关联的草稿文件会从工作区草稿目录中删除。",
   "sddDraftHistoryDeleteFailed": "删除失败：{{message}}",
   "sddDraftHistoryShowMore": "展开显示（还有 {{count}} 条）",
   "sddDraftHistoryRemembered": "最近",
@@ -2012,6 +2043,23 @@
   "toolBuiltinFind": "查找",
   "toolBuiltinLs": "列出",
   "toolBuiltinBash": "命令",
+  "toolBuiltinDelegate": "委派任务",
+  "subagentDefaultName": "子代理",
+  "subagentStatusQueued": "排队中",
+  "subagentStatusRunning": "运行中",
+  "subagentStatusDone": "完成",
+  "subagentStatusFailed": "失败",
+  "subagentStatusAwaiting": "待批准",
+  "subagentSteps": "{{count}} 步",
+  "subagentQueuedHint": "排队中",
+  "subagentTokensChip": "{{count}} tokens",
+  "subagentPolicyReadOnly": "只读",
+  "subagentPolicyFull": "完整权限",
+  "subagentOpenSession": "打开子会话",
+  "subagentSwarmTitle": "{{count}} 子代理",
+  "subagentSwarmRunning": "{{count}} 运行",
+  "subagentSwarmQueued": "{{count}} 排队",
+  "subagentSwarmDone": "{{count}} 完成",
   "sidebarFooterHint": "连接本地运行后即可创建会话并与代理对话。",
   "appErrorTitle": "应用出了点问题",
   "appErrorReload": "重新加载",
@@ -2063,5 +2111,123 @@
   "planVerify": "验收",
   "planVerifyRunning": "验收中…",
   "sddChangedBanner": "需求 {{ids}} 在规划后发生变更，计划可能已过时",
-  "sddReplanButton": "增量重规划"
+  "sddReplanButton": "增量重规划",
+  "agentsView": {
+    "configureModel": "配置模型",
+    "delegatable": "可委派 · 可在对话中使用",
+    "system": "系统 · 自动运行",
+    "compaction": "上下文压缩",
+    "compactionDesc": "压缩长上下文",
+    "title": "标题生成",
+    "titleDesc": "生成会话标题",
+    "summary": "摘要",
+    "summaryDesc": "会话摘要",
+    "ruleBased": "规则生成",
+    "deleteConfirm": "删除这个 agent?",
+    "followDefault": "跟随默认",
+    "builtinTag": "内置",
+    "edit": "编辑",
+    "delete": "删除",
+    "editAgent": "编辑 agent",
+    "fName": "名称",
+    "fDesc": "描述",
+    "fColor": "颜色",
+    "fMode": "模式",
+    "modeDelegate": "委派",
+    "modePersona": "主代理",
+    "modeBoth": "两者",
+    "fTools": "工具权限",
+    "toolReadOnly": "只读",
+    "toolInherit": "全部工具",
+    "tabBasic": "基本",
+    "tabPermissions": "权限",
+    "permScope": "能力范围",
+    "permScopeReadOnly": "只读",
+    "permScopeAll": "全部",
+    "permScopeCustom": "自定义",
+    "permScopeHint": "选择该 agent 可调用的能力，上限不超过主代理。",
+    "permScopeReadOnlyNote": "仅调查类工具:read / grep / find / ls，无 MCP 与技能。",
+    "permScopeAllNote": "继承主代理的全部能力。",
+    "permSearch": "搜索工具 / MCP / 技能…",
+    "permSecTools": "内置工具",
+    "permSecMcp": "MCP 服务",
+    "permSecSkills": "技能",
+    "permToolsWord": "工具",
+    "permBlocked": "已屏蔽",
+    "permSkillsInheritNote": "默认继承全部可用技能，可单独屏蔽。",
+    "permNoMcp": "暂无 MCP 服务。",
+    "permNoSkills": "暂无可用技能。",
+    "permLoading": "加载能力中…",
+    "fModel": "模型",
+    "modelHint": "在列表行选择,或在此填 provider:model",
+    "providerId": "供应商 id",
+    "fSystemPrompt": "系统提示词",
+    "cancel": "取消",
+    "create": "创建",
+    "save": "保存",
+    "builtin": {
+      "general": "通用代理:研究复杂问题与多步任务,完整工具权限,可改文件,可并行运行。",
+      "explore": "只读代码探索:查找文件、搜关键字、答疑;从不改文件。"
+    }
+  },
+  "subagents": "子代理",
+  "disable": "禁用",
+  "enable": "启用",
+  "expandSidebar": "展开侧边栏",
+  "rightPanelSubagents": "子代理",
+  "subagentsPanel": {
+    "configModel": "配置模型",
+    "delegatable": "可委派 · 可在对话里用",
+    "system": "系统 · 内部用途",
+    "global": "全局 · 共享",
+    "newSubagent": "新建子代理",
+    "smallModel": {
+      "name": "小模型",
+      "desc": "标题与摘要默认使用"
+    },
+    "role": {
+      "design-reviewer": {
+        "name": "设计审查",
+        "desc": "design-reviewer · 只读"
+      },
+      "over-engineering-reviewer": {
+        "name": "过度设计审查",
+        "desc": "over-engineering-reviewer · 只读"
+      },
+      "compaction": {
+        "name": "上下文压缩",
+        "desc": "可配置 · 默认跟随主模型"
+      },
+      "codeReview": {
+        "name": "代码审查",
+        "desc": "隔离只读跑 · 可配模型"
+      },
+      "title": {
+        "name": "标题生成",
+        "desc": "LLM · 默认小模型"
+      },
+      "summary": {
+        "name": "摘要",
+        "desc": "LLM · 默认小模型"
+      },
+      "general": {
+        "name": "通用代理",
+        "desc": "全工具 · 多步骤任务,可改文件"
+      },
+      "explore": {
+        "name": "探索代理",
+        "desc": "只读 · 查找文件、搜索代码"
+      }
+    },
+    "builtin": "内置"
+  },
+  "summarizeSession": "总结此会话",
+  "summarizing": "总结中…",
+  "summarizeFailed": "无法总结此会话",
+  "name": "名称",
+  "description": "描述",
+  "color": "颜色",
+  "mode": "模式",
+  "systemPrompt": "系统提示词",
+  "toolPolicy": "工具权限"
 }
diff --git a/src/renderer/src/locales/zh/settings.json b/src/renderer/src/locales/zh/settings.json
index be317bdc3..6df7772f6 100644
--- a/src/renderer/src/locales/zh/settings.json
+++ b/src/renderer/src/locales/zh/settings.json
@@ -275,9 +275,9 @@
   "modelProviderApiKeyPlaceholder": "填写此供应商的 API Key",
   "modelProviderBaseUrl": "Base URL",
   "modelProviderEndpointFormat": "端点格式",
-  "modelEndpointChatCompletions": "/v1/chat/completions",
-  "modelEndpointResponses": "/v1/responses",
-  "modelEndpointMessages": "/v1/messages",
+  "modelEndpointChatCompletions": "/v1/chat/completions (openai)",
+  "modelEndpointResponses": "/v1/responses (openai)",
+  "modelEndpointMessages": "/v1/messages (anthropic)",
   "modelEndpointCustomEndpoint": "自定义完整路径",
   "modelEndpointCustomEndpointDesc": "自定义完整路径会把当前 URL 当作最终请求端点。只识别以 /chat/completions、/completions、/responses 或 /messages 结尾的路径；其他结尾暂不支持。",
   "modelProviderModels": "模型列表",
@@ -797,6 +797,9 @@
   "mcpFormEnabled": "启用",
   "mcpFormRemoveServer": "删除服务器",
   "mcpFormCommand": "命令",
+  "mcpFormCwd": "工作目录",
+  "mcpFormCwdPlaceholder": "/Users/me/project",
+  "mcpFormCwdHint": "可选。留空时，工作区范围的 stdio 服务器会在第一个受信任工作区路径中启动。",
   "mcpFormArgs": "参数（每行一个）",
   "mcpFormArgsPlaceholder": "-y\nsome-mcp-package",
   "mcpFormEnv": "环境变量",
@@ -855,6 +858,8 @@
   "firstRunModeLabel": "接入方式",
   "firstRunModeApi": "按量 API",
   "firstRunModeTokenPlan": "Token Plan 套餐",
+  "firstRunPermissionLabel": "默认 Agent 权限",
+  "firstRunPermissionFullAccessRisk": "“完全访问”会让 Agent 在不询问的情况下执行工具，并拥有完整本地访问权限。只有在你充分信任当前任务和输入内容时才应选择。",
   "firstRunRegionLabel": "套餐区域",
   "firstRunRegion_cn": "国内",
   "firstRunRegion_global": "海外",
@@ -1086,6 +1091,16 @@
   "logRetentionThree": "3 天",
   "logRetentionFive": "5 天",
   "logRetentionSeven": "7 天",
+  "gitCheckpointTitle": "Git checkpoint 管理",
+  "checkpointCleanupEnabled": "自动清理未使用的 checkpoint",
+  "checkpointCleanupEnabledDesc": "开启后，定期删除不再被任何会话引用的 Git checkpoint 目录。默认关闭。",
+  "checkpointCleanupInterval": "未使用 Git checkpoint 清理",
+  "checkpointCleanupIntervalDesc": "按所选周期删除不再被任何会话引用的 Git checkpoint 目录。",
+  "checkpointCleanupInterval1": "每 1 天",
+  "checkpointCleanupInterval2": "每 2 天",
+  "checkpointCleanupInterval3": "每 3 天",
+  "checkpointCleanupInterval5": "每 5 天",
+  "checkpointCleanupInterval10": "每 10 天",
   "loading": "加载中…",
   "loadFailed": "无法加载设置：{{message}}",
   "preloadBridgeError": "应用桥接不可用。请重启应用或检查预加载脚本路径。",
diff --git a/src/renderer/src/store/chat-store-app-actions.test.ts b/src/renderer/src/store/chat-store-app-actions.test.ts
index c86516fcb..a4a21aadb 100644
--- a/src/renderer/src/store/chat-store-app-actions.test.ts
+++ b/src/renderer/src/store/chat-store-app-actions.test.ts
@@ -282,7 +282,7 @@ describe('chat-store app actions composer model loading', () => {
     expect(state.composerProviderId).toBe('')
   })
 
-  it('blocks switching an active chat with user messages from vision to text-only', () => {
+  it('blocks switching a chat with image attachments from vision to text-only', () => {
     const { actions, state } = buildHarness({
       ok: true,
       modelIds: ['vision-model', 'text-model'],
@@ -290,7 +290,12 @@ describe('chat-store app actions composer model loading', () => {
       modelGroups: []
     })
     state.route = 'chat'
-    state.blocks = [{ kind: 'user', id: 'user-1', text: 'hello' }] as ChatState['blocks']
+    state.blocks = [{
+      kind: 'user',
+      id: 'user-1',
+      text: 'describe this',
+      meta: { attachments: [{ id: 'att-1', kind: 'image' }] }
+    }] as ChatState['blocks']
     state.activeThreadId = 'thread-a'
     state.threads = [{
       id: 'thread-a',
@@ -331,6 +336,89 @@ describe('chat-store app actions composer model loading', () => {
     expect(window.kunGui.saveSettingsSilent).not.toHaveBeenCalled()
   })
 
+  it('allows switching a text-only chat from vision to text-only (issue #579)', () => {
+    const { actions, state } = buildHarness({
+      ok: true,
+      modelIds: ['vision-model', 'text-model'],
+      defaultModelId: 'vision-model',
+      modelGroups: []
+    })
+    state.route = 'chat'
+    // A plain text conversation must not pin the picker to vision models.
+    state.blocks = [
+      { kind: 'user', id: 'user-1', text: 'hello' },
+      { kind: 'assistant', id: 'assistant-1', text: 'hi there' }
+    ] as ChatState['blocks']
+    state.composerModel = 'vision-model'
+    state.composerProviderId = 'test-provider'
+    state.composerModelGroups = [{
+      providerId: 'test-provider',
+      label: 'Test',
+      modelIds: ['vision-model', 'text-model'],
+      modelProfiles: {
+        'vision-model': {
+          inputModalities: ['text', 'image'],
+          outputModalities: ['text'],
+          supportsToolCalling: true,
+          messageParts: ['text', 'image_url']
+        },
+        'text-model': {
+          inputModalities: ['text'],
+          outputModalities: ['text'],
+          supportsToolCalling: true,
+          messageParts: ['text']
+        }
+      }
+    }]
+
+    actions.setComposerModel('text-model', 'test-provider')
+
+    expect(state.composerModel).toBe('text-model')
+    expect(state.composerProviderId).toBe('test-provider')
+  })
+
+  it('allows switching a document-only chat from vision to text-only', () => {
+    const { actions, state } = buildHarness({
+      ok: true,
+      modelIds: ['vision-model', 'text-model'],
+      defaultModelId: 'vision-model',
+      modelGroups: []
+    })
+    state.route = 'chat'
+    // Documents are text-extracted, so they don't require a vision model.
+    state.blocks = [{
+      kind: 'user',
+      id: 'user-1',
+      text: 'summarize',
+      meta: { attachments: [{ id: 'doc-1', kind: 'document' }] }
+    }] as ChatState['blocks']
+    state.composerModel = 'vision-model'
+    state.composerProviderId = 'test-provider'
+    state.composerModelGroups = [{
+      providerId: 'test-provider',
+      label: 'Test',
+      modelIds: ['vision-model', 'text-model'],
+      modelProfiles: {
+        'vision-model': {
+          inputModalities: ['text', 'image'],
+          outputModalities: ['text'],
+          supportsToolCalling: true,
+          messageParts: ['text', 'image_url']
+        },
+        'text-model': {
+          inputModalities: ['text'],
+          outputModalities: ['text'],
+          supportsToolCalling: true,
+          messageParts: ['text']
+        }
+      }
+    }]
+
+    actions.setComposerModel('text-model', 'test-provider')
+
+    expect(state.composerModel).toBe('text-model')
+  })
+
   it('allows switching an empty chat from vision to text-only', () => {
     const { actions, state } = buildHarness({
       ok: true,
diff --git a/src/renderer/src/store/chat-store-app-actions.ts b/src/renderer/src/store/chat-store-app-actions.ts
index 4519784d2..8e8e9868b 100644
--- a/src/renderer/src/store/chat-store-app-actions.ts
+++ b/src/renderer/src/store/chat-store-app-actions.ts
@@ -5,6 +5,7 @@ import type { ChatState, ChatStoreGet, ChatStoreSet, InitialSetupMode, PluginHos
 import type { ComposerPlanMode } from './chat-store-helpers'
 import {
   canSwitchComposerModel,
+  conversationHasVisionAttachments,
   composerModelSelectable,
   composerModeForThread,
   persistComposerMode,
@@ -45,6 +46,7 @@ export function createAppActions(options: CreateAppActionsOptions): Pick<
   | 'setError'
   | 'setComposerMode'
   | 'setComposerModel'
+  | 'setComposerAgentId'
   | 'loadComposerModels'
   | 'setRoute'
   | 'openWrite'
@@ -100,7 +102,7 @@ export function createAppActions(options: CreateAppActionsOptions): Pick<
       const lockVisionToTextSwitch =
         state.route === 'chat' &&
         Array.isArray(state.blocks) &&
-        state.blocks.some((block) => block.kind === 'user')
+        conversationHasVisionAttachments(state.blocks)
       if (!canSwitchComposerModel(
         lockVisionToTextSwitch,
         state.composerModelGroups,
@@ -125,6 +127,10 @@ export function createAppActions(options: CreateAppActionsOptions): Pick<
       }
     },
 
+    setComposerAgentId: (agentId) => {
+      set({ composerAgentId: agentId.trim() })
+    },
+
     loadComposerModels: async () => {
       if (getComposerModelLoadPromise()) return getComposerModelLoadPromise()!
       if (typeof window.kunGui === 'undefined') return
diff --git a/src/renderer/src/store/chat-store-helpers.test.ts b/src/renderer/src/store/chat-store-helpers.test.ts
index 63dffc598..78fe366bf 100644
--- a/src/renderer/src/store/chat-store-helpers.test.ts
+++ b/src/renderer/src/store/chat-store-helpers.test.ts
@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { ClawImChannelV1 } from '@shared/app-settings'
+import type { ChatBlock } from '../agent/types'
 import type { ModelProviderModelGroup } from '@shared/kun-gui-api'
 import { CLAW_MANAGED_INSTRUCTIONS_HEADING } from '@shared/app-settings'
 import {
@@ -10,6 +11,7 @@ import {
   clawThreadIdsFromChannels,
   clawThreadTitleLooksManaged,
   compactCodeWorkspaceRoots,
+  conversationHasVisionAttachments,
   fallbackComposerModel,
   hydrateBlockModelLabels,
   isClawThread,
@@ -377,3 +379,34 @@ describe('chat-store Claw helpers', () => {
     })
   })
 })
+
+describe('conversationHasVisionAttachments', () => {
+  it('returns false for text-only conversations (issue #579)', () => {
+    const blocks: ChatBlock[] = [
+      { kind: 'user', id: 'u1', text: 'hello' },
+      { kind: 'assistant', id: 'a1', text: 'hi' }
+    ]
+    expect(conversationHasVisionAttachments(blocks)).toBe(false)
+  })
+
+  it('returns true when a user message carries an image attachment', () => {
+    const blocks: ChatBlock[] = [
+      { kind: 'user', id: 'u1', text: 'look', meta: { attachments: [{ id: 'img-1', kind: 'image' }] } }
+    ]
+    expect(conversationHasVisionAttachments(blocks)).toBe(true)
+  })
+
+  it('returns false when attachments are documents only', () => {
+    const blocks: ChatBlock[] = [
+      { kind: 'user', id: 'u1', text: 'read', meta: { attachments: [{ id: 'doc-1', kind: 'document' }] } }
+    ]
+    expect(conversationHasVisionAttachments(blocks)).toBe(false)
+  })
+
+  it('treats unresolved attachmentIds (restored sessions) as vision content', () => {
+    const blocks: ChatBlock[] = [
+      { kind: 'user', id: 'u1', text: 'check', meta: { attachmentIds: ['att-1'] } }
+    ]
+    expect(conversationHasVisionAttachments(blocks)).toBe(true)
+  })
+})
diff --git a/src/renderer/src/store/chat-store-helpers.ts b/src/renderer/src/store/chat-store-helpers.ts
index a2c2c5e6e..31cba204b 100644
--- a/src/renderer/src/store/chat-store-helpers.ts
+++ b/src/renderer/src/store/chat-store-helpers.ts
@@ -203,6 +203,31 @@ export function canSwitchComposerModel(
   return modelSupportsImageInput(nextProfile)
 }
 
+// The vision→text downgrade guard must only engage when the conversation
+// actually carries image content that a text-only model could not consume.
+// Locking on the mere presence of a user message (regardless of attachments)
+// made every text model unselectable whenever a vision model was active — see
+// https://github.com/KunAgent/Kun/issues/579. Document attachments are
+// text-extractable and therefore safe to downgrade with; only image (or
+// unknown-kind, e.g. restored-session) attachments keep the lock engaged.
+export function conversationHasVisionAttachments(blocks: readonly ChatBlock[]): boolean {
+  return blocks.some((block) => {
+    if (block.kind !== 'user') return false
+    const meta = block.meta
+    if (!meta) return false
+    const refsById = new Map((meta.attachments ?? []).map((ref) => [ref.id, ref]))
+    const attachmentIds = new Set([
+      ...(meta.attachmentIds ?? []),
+      ...(meta.attachments ?? []).map((ref) => ref.id)
+    ])
+    for (const id of attachmentIds) {
+      // 'image' or unspecified kind keeps the lock; 'document' is safe to drop.
+      if (refsById.get(id)?.kind !== 'document') return true
+    }
+    return false
+  })
+}
+
 function modelProfileForComposerSelection(
   modelGroups: readonly ModelProviderModelGroup[],
   modelId: string,
diff --git a/src/renderer/src/store/chat-store-maintenance-actions.ts b/src/renderer/src/store/chat-store-maintenance-actions.ts
index 216939bf2..e7d585885 100644
--- a/src/renderer/src/store/chat-store-maintenance-actions.ts
+++ b/src/renderer/src/store/chat-store-maintenance-actions.ts
@@ -182,7 +182,7 @@ function settleInterruptedTurn(set: ChatStoreSet, get: ChatStoreGet): void {
 
 export function createMaintenanceActions(
   { set, get, sseAbortRef }: StoreActionContext
-): Pick<ChatState, 'renameActiveThread' | 'renameThread' | 'archiveThread' | 'compactActiveThread' | 'forkActiveThread' | 'forkThreadFromTurn' | 'setActiveThreadGoal' | 'setActiveThreadGoalStatus' | 'clearActiveThreadGoal' | 'setActiveThreadTodoStatus' | 'clearActiveThreadTodos' | 'syncPlanTodosFromMarkdown' | 'resumeSessionIntoThread' | 'deleteThread' | 'rewindAndResend' | 'rollbackWorkspaceToCheckpoint' | 'resolveApproval' | 'resolveUserInput' | 'interrupt'> {
+): Pick<ChatState, 'renameActiveThread' | 'renameThread' | 'pinThread' | 'archiveThread' | 'compactActiveThread' | 'forkActiveThread' | 'forkThreadFromTurn' | 'setActiveThreadGoal' | 'setActiveThreadGoalStatus' | 'clearActiveThreadGoal' | 'setActiveThreadTodoStatus' | 'clearActiveThreadTodos' | 'syncPlanTodosFromMarkdown' | 'resumeSessionIntoThread' | 'deleteThread' | 'rewindAndResend' | 'rollbackWorkspaceToCheckpoint' | 'resolveApproval' | 'resolveUserInput' | 'interrupt'> {
   const forkActiveThreadWithOptions = async (options: { turnId?: string } = {}): Promise<void> => {
     const { activeThreadId, busy, blocks } = get()
     if (!activeThreadId) return
@@ -248,10 +248,42 @@ export function createMaintenanceActions(
     }
     const p = getProvider()
     try {
-      await p.renameThread(targetId, nextTitle)
+      // Manual rename → lock the title so the backend LLM titler won't overwrite it.
+      await p.renameThread(targetId, nextTitle, false)
       set((s) => ({
         threads: s.threads.map((thread) =>
-          thread.id === targetId ? { ...thread, title: nextTitle } : thread
+          thread.id === targetId ? { ...thread, title: nextTitle, titleAuto: false } : thread
+        ),
+        error: null
+      }))
+      await get().refreshThreads()
+    } catch (e) {
+      set({
+        error: formatRuntimeError(e),
+        ...(shouldOpenSettingsForError(e)
+          ? { route: 'settings' as const, settingsSection: 'agents' as const }
+          : {})
+      })
+    }
+  },
+
+  pinThread: async (threadId, pinned) => {
+    const targetId = threadId.trim()
+    if (!targetId) return
+    if (get().runtimeConnection !== 'ready') {
+      set({ error: i18n.t('common:runtimeActionNeedsConnection') })
+      return
+    }
+    const p = getProvider()
+    if (typeof p.updateThreadPinned !== 'function') {
+      set({ error: i18n.t('common:runtimeFeatureUnsupported') })
+      return
+    }
+    try {
+      await p.updateThreadPinned(targetId, pinned)
+      set((s) => ({
+        threads: s.threads.map((thread) =>
+          thread.id === targetId ? { ...thread, pinned } : thread
         ),
         error: null
       }))
@@ -801,6 +833,13 @@ export function createMaintenanceActions(
       set({ error: i18n.t('common:runtimeFeatureUnsupported') })
       return
     }
+    set((s) => ({
+      blocks: s.blocks.map((b) =>
+        b.id === blockId && b.kind === 'approval' && b.status === 'pending'
+          ? { ...b, status: 'submitting' as const, errorMessage: undefined }
+          : b
+      )
+    }))
     try {
       await p.submitApprovalDecision(
         block.approvalId,
@@ -914,7 +953,15 @@ export function createMaintenanceActions(
           : {}),
         blocks: s.blocks.map((b) =>
           b.id === blockId && b.kind === 'user_input'
-            ? { ...b, status: 'error' as const, errorMessage: msg }
+            ? {
+                ...b,
+                status: 'error' as const,
+                errorMessage: msg,
+                // Keep the chosen answers on the record so the read-only bubble
+                // still echoes what the user picked when a submit RPC fails,
+                // mirroring the success / interrupt-fallback paths above.
+                ...(action.kind === 'submit' ? { answers: action.answers } : {})
+              }
             : b
         )
       }))
diff --git a/src/renderer/src/store/chat-store-runtime.ts b/src/renderer/src/store/chat-store-runtime.ts
index 81be1bbcb..6ea958f0d 100644
--- a/src/renderer/src/store/chat-store-runtime.ts
+++ b/src/renderer/src/store/chat-store-runtime.ts
@@ -1082,6 +1082,24 @@ export function buildThreadEventSink(
           : { threads: nextThreads }
       })
     },
+    onThreadUpdated: (ev) => {
+      if (!isCurrentStream()) return
+      if (!ev.threadId) return
+      const nextTitle = ev.title?.trim()
+      // Only the title-upgrade path carries a title; ignore status-only updates.
+      if (!nextTitle) return
+      set((s) => ({
+        threads: s.threads.map((thread) =>
+          thread.id === ev.threadId
+            ? {
+                ...thread,
+                title: nextTitle,
+                ...(ev.titleAuto !== undefined ? { titleAuto: ev.titleAuto } : {})
+              }
+            : thread
+        )
+      }))
+    },
     onTurnComplete: () => {
       if (!isCurrentStream()) return
       resetBusyRecoveryAttempts()
diff --git a/src/renderer/src/store/chat-store-thread-actions.ts b/src/renderer/src/store/chat-store-thread-actions.ts
index c644145e7..ec5a1b13a 100644
--- a/src/renderer/src/store/chat-store-thread-actions.ts
+++ b/src/renderer/src/store/chat-store-thread-actions.ts
@@ -111,6 +111,7 @@ type StoreActionContext = {
 }
 
 let drainingQueuedMessages = false
+const checkpointGitUnavailableWorkspaces = new Set<string>()
 
 function fallbackComposerProviderIdForSend(state: ChatState): string {
   return state.route === 'claw' ? '' : state.composerProviderId.trim()
@@ -259,10 +260,27 @@ export function createThreadActions(
           return
         }
       }
+      // Primary-agent persona snapshot: bind this thread to the picked
+      // subagent profile and freeze its providerId / model / systemPrompt
+      // at create time so later agent edits don't drift the thread.
+      const pickedAgentId = options.agentId?.trim() || get().composerAgentId?.trim() || ''
+      const personaProfile = pickedAgentId
+        ? settings.agents?.kun?.subagents?.profiles?.find(
+            (profile) => profile.id === pickedAgentId &&
+              profile.enabled &&
+              (profile.mode === 'primary' || profile.mode === 'all')
+          )
+        : undefined
       const t = await p.createThread({
         workspace: workspaceRoot,
         title: getDefaultThreadTitle(),
-        mode: 'agent'
+        mode: 'agent',
+        ...(personaProfile ? {
+          agentId: personaProfile.id,
+          ...(personaProfile.providerId ? { providerId: personaProfile.providerId } : {}),
+          ...(personaProfile.model ? { model: personaProfile.model } : {}),
+          ...(personaProfile.systemPrompt ? { systemPrompt: personaProfile.systemPrompt } : {})
+        } : {})
       })
       // Register + activate optimistically before refreshing. A freshly created
       // Kun thread may not be listed until the first message is written.
@@ -761,6 +779,8 @@ export function createThreadActions(
             ? await p.createThread({
                 workspace: workspaceRoot,
                 title: generatedTitle,
+                // Provisional first-message title; let the backend LLM titler upgrade it.
+                titleAuto: true,
                 mode: mode ?? 'agent'
               })
             : null
@@ -826,7 +846,12 @@ export function createThreadActions(
       let workspaceCheckpointId: string | undefined
       const checkpointThread = get().threads.find((thread) => thread.id === activeThreadId)
       const checkpointWorkspaceRoot = normalizeWorkspaceRoot(checkpointThread?.workspace) || normalizeWorkspaceRoot(settings.workspaceRoot)
-      if (checkpointWorkspaceRoot && typeof window.kunGui.createGitCheckpoint === 'function') {
+      const checkpointWorkspaceKey = checkpointWorkspaceRoot.replaceAll('\\', '/').toLowerCase()
+      if (
+        checkpointWorkspaceRoot &&
+        !checkpointGitUnavailableWorkspaces.has(checkpointWorkspaceKey) &&
+        typeof window.kunGui.createGitCheckpoint === 'function'
+      ) {
         const checkpoint = await window.kunGui.createGitCheckpoint({
           workspaceRoot: checkpointWorkspaceRoot,
           threadId: activeThreadId
@@ -838,11 +863,20 @@ export function createThreadActions(
         if (checkpoint.ok) {
           workspaceCheckpointId = checkpoint.checkpointId
         } else if (checkpoint.reason !== 'not_git_repo' && checkpoint.reason !== 'no_workspace') {
-          void window.kunGui.logError('git-checkpoint', 'Failed to create Git checkpoint', {
-            message: checkpoint.message,
-            reason: checkpoint.reason,
-            workspaceRoot: checkpointWorkspaceRoot
-          }).catch(() => undefined)
+          if (checkpoint.reason === 'git_unavailable') {
+            checkpointGitUnavailableWorkspaces.add(checkpointWorkspaceKey)
+          }
+          void window.kunGui.logError(
+            'git-checkpoint',
+            checkpoint.reason === 'git_unavailable'
+              ? 'Git checkpoint disabled for this workspace because Git was not found'
+              : 'Failed to create Git checkpoint',
+            {
+              message: checkpoint.message,
+              reason: checkpoint.reason,
+              workspaceRoot: checkpointWorkspaceRoot
+            }
+          ).catch(() => undefined)
         }
       }
       let runtimeText: string
@@ -936,14 +970,15 @@ export function createThreadActions(
         }
       }
       if (shouldRenameThreadAfterSend) {
-        const renamed = await p.renameThread(activeThreadId, generatedTitle).then(() => true).catch(() => {
+        // Provisional first-message title; let the backend LLM titler upgrade it.
+        const renamed = await p.renameThread(activeThreadId, generatedTitle, true).then(() => true).catch(() => {
           /* keep message delivery successful even if auto-title update fails */
           return false
         })
         if (renamed) {
           set((s) => ({
             threads: s.threads.map((thread) =>
-              thread.id === activeThreadId ? { ...thread, title: generatedTitle } : thread
+              thread.id === activeThreadId ? { ...thread, title: generatedTitle, titleAuto: true } : thread
             )
           }))
         }
diff --git a/src/renderer/src/store/chat-store-types.ts b/src/renderer/src/store/chat-store-types.ts
index 96d888bb7..23ecba433 100644
--- a/src/renderer/src/store/chat-store-types.ts
+++ b/src/renderer/src/store/chat-store-types.ts
@@ -177,6 +177,11 @@ export type ChatState = {
   composerProviderId: string
   composerPickList: string[]
   composerModelGroups: ModelProviderModelGroup[]
+  /**
+   * Optional subagent profile id selected as the persona for the next new
+   * thread / next-turn override. Empty = use the runtime default.
+   */
+  composerAgentId: string
   disabledSkillIds: string[]
   queuedMessages: QueuedUserMessage[]
   watchTurnCompletion: Record<string, boolean>
@@ -193,6 +198,7 @@ export type ChatState = {
   setError: (message: string | null) => void
   setComposerMode: (mode: 'plan' | 'agent') => void
   setComposerModel: (modelId: string, providerId?: string) => void
+  setComposerAgentId: (agentId: string) => void
   loadComposerModels: () => Promise<void>
   setRoute: (r: AppRoute) => void
   openWrite: () => Promise<void>
@@ -241,6 +247,12 @@ export type ChatState = {
     /** When true, checkout the selected branch into an isolated worktree. */
     useWorktreePool?: boolean
     worktreeBranch?: string
+    /**
+     * Optional subagent profile id to bind the new thread to. When set
+     * and the profile mode is 'primary' or 'all', the agent's
+     * providerId / model / systemPrompt are snapshotted onto the thread.
+     */
+    agentId?: string
   }) => Promise<void>
   selectThread: (id: string) => Promise<void>
   /**
@@ -260,6 +272,7 @@ export type ChatState = {
   interrupt: (options?: { discard?: boolean }) => Promise<void>
   renameActiveThread: (title: string) => Promise<void>
   renameThread: (threadId: string, title: string) => Promise<void>
+  pinThread: (threadId: string, pinned: boolean) => Promise<void>
   archiveThread: (threadId: string, archived: boolean) => Promise<void>
   compactActiveThread: (reason?: string) => Promise<void>
   forkActiveThread: () => Promise<void>
diff --git a/src/renderer/src/store/chat-store.ts b/src/renderer/src/store/chat-store.ts
index 8239928dd..8828a74f2 100644
--- a/src/renderer/src/store/chat-store.ts
+++ b/src/renderer/src/store/chat-store.ts
@@ -164,6 +164,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
   composerMode: readStoredComposerMode(),
   composerModel: '',
   composerProviderId: '',
+  composerAgentId: '',
   composerPickList: mergeComposerPickList(false, []),
   composerModelGroups: [],
   disabledSkillIds: [],
diff --git a/src/renderer/src/styles/base-shell.css b/src/renderer/src/styles/base-shell.css
index b8d98095b..37e00fd91 100644
--- a/src/renderer/src/styles/base-shell.css
+++ b/src/renderer/src/styles/base-shell.css
@@ -547,6 +547,16 @@ html {
   background: var(--ds-bg-main);
 }
 
+/*
+ * Full-window `fixed inset-0` overlays (e.g. the workflow/Loop editor) must not
+ * cover the real DOM titlebar that AppShell draws on Windows/Linux. The titlebar
+ * height var is only set on those platforms, so this collapses to `top: 0` on
+ * macOS (native traffic-light overlay) — issue #570.
+ */
+.ds-titlebar-fixed-overlay {
+  top: var(--ds-windows-titlebar-height, 0px);
+}
+
 .ds-windows-titlebar {
   position: relative;
   z-index: 80;
@@ -2082,6 +2092,58 @@ pre {
   }
 }
 
+/* ---------- Kun Crew · subagent call card ---------- */
+.ds-subagent-mount {
+  animation: ds-subagent-mount 0.3s cubic-bezier(0.2, 0.7, 0.2, 1);
+}
+@keyframes ds-subagent-mount {
+  from {
+    opacity: 0;
+    transform: translateY(6px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+.ds-subagent-dot-pulse {
+  animation: ds-subagent-pulse 1.4s ease-in-out infinite;
+  animation-delay: var(--ds-subagent-stagger, 0s);
+}
+@keyframes ds-subagent-pulse {
+  0%,
+  100% {
+    box-shadow: 0 0 0 0 rgba(59, 130, 216, 0.5);
+  }
+  50% {
+    box-shadow: 0 0 0 4px rgba(59, 130, 216, 0);
+  }
+}
+.ds-subagent-lane-sweep {
+  background: linear-gradient(90deg, transparent, var(--ds-accent, #3b82d8), transparent);
+  animation: ds-subagent-sweep 1.5s ease-in-out infinite;
+  animation-delay: var(--ds-subagent-stagger, 0s);
+}
+@keyframes ds-subagent-sweep {
+  0% {
+    left: -40%;
+  }
+  100% {
+    left: 100%;
+  }
+}
+/* Freeze the AgentKun pose motion inside a frozen disc (done/failed/off-screen). */
+.ds-subagent-frozen .ds-agent-kun img {
+  animation: none !important;
+}
+@media (prefers-reduced-motion: reduce) {
+  .ds-subagent-mount,
+  .ds-subagent-dot-pulse,
+  .ds-subagent-lane-sweep {
+    animation: none !important;
+  }
+}
+
 @keyframes sdd-soft-enter {
   from {
     opacity: 0;
@@ -2795,25 +2857,27 @@ pre {
 }
 
 .timeline-jump-rail {
-  position: sticky;
-  top: 0.75rem;
-  z-index: 30;
+  position: fixed;
+  top: 7.6rem;
+  right: 1.55rem;
+  z-index: 45;
   display: flex;
-  width: max-content;
-  min-width: 2.25rem;
+  box-sizing: border-box;
+  width: 2.4rem;
+  min-width: 2.4rem;
   max-height: min(48vh, 22rem);
   flex-direction: column;
   align-items: center;
-  gap: 0.25rem;
-  align-self: flex-end;
+  gap: 0.3rem;
   overflow-y: auto;
-  margin: 0.65rem 0.65rem -0.65rem 0;
-  border: 1px solid var(--ds-border-muted);
+  border: 1px solid color-mix(in srgb, var(--ds-border) 82%, transparent);
   border-radius: 999px;
-  background: color-mix(in srgb, var(--ds-surface-card) 88%, transparent);
-  padding: 0.3rem;
-  box-shadow: 0 12px 34px rgba(15, 23, 42, 0.12);
-  backdrop-filter: blur(18px);
+  background: color-mix(in srgb, var(--ds-surface-card) 96%, transparent);
+  padding: 0.34rem;
+  box-shadow:
+    0 12px 34px rgba(15, 23, 42, 0.16),
+    inset 0 1px 0 rgba(255, 255, 255, 0.12);
+  backdrop-filter: blur(20px);
   scrollbar-width: none;
 }
 
@@ -2823,20 +2887,23 @@ pre {
 
 .timeline-jump-rail-button {
   display: inline-flex;
-  min-width: 1.65rem;
-  height: 1.55rem;
+  box-sizing: border-box;
+  width: 1.7rem;
+  min-width: 1.7rem;
+  height: 1.7rem;
   align-items: center;
   justify-content: center;
-  padding-inline: 0.35rem;
+  padding: 0;
   border: 0;
   border-radius: 999px;
-  background: transparent;
-  color: var(--ds-text-faint);
-  font-size: 0.72rem;
+  background: color-mix(in srgb, var(--ds-text) 7%, transparent);
+  color: var(--ds-text-muted);
+  font-size: 0.76rem;
   font-weight: 700;
   font-variant-numeric: tabular-nums;
   line-height: 1;
   white-space: nowrap;
+  text-align: center;
   transition:
     background 140ms ease,
     color 140ms ease,
diff --git a/src/shared/app-settings-kun.ts b/src/shared/app-settings-kun.ts
index 0641275ae..5a337c86f 100644
--- a/src/shared/app-settings-kun.ts
+++ b/src/shared/app-settings-kun.ts
@@ -41,6 +41,7 @@ import {
   type ModelProviderModelProfilePatchV1,
   type ModelProviderModelProfileV1,
   type ModelProviderReasoningCapabilityV1,
+  type ModelReasoningEffort,
   type ModelProviderSettingsV1,
   type SpeechToTextProtocol,
   type TextToSpeechProtocol,
@@ -432,6 +433,11 @@ export function mergeKunRuntimeSettings(
   })
   const nextModelProfiles = normalizeKunModelProfiles(current.modelProfiles, patch?.modelProfiles)
   const nextPort = normalizeKunLocalPort(patch?.port ?? current.port, DEFAULT_KUN_PORT)
+  // Optional role/small-model slots (agents.kun.*). Patch wins when the key is
+  // present (even as empty string => clear); otherwise inherit current. Empty/
+  // whitespace strings are dropped so the field is omitted entirely.
+  const nextRoleModelSlots = mergeOptionalModelSlot(current, patch)
+  const nextRoleReasoningSlots = mergeOptionalReasoningSlot(current, patch)
   // NOTE: approvalPolicy/sandboxMode are merged through verbatim from the patch.
   // The unified 5-mode UI selector already resolves a mode to its concrete
   // {approvalPolicy, sandboxMode} pair via kunToolPermissionModeSettings before
@@ -440,7 +446,7 @@ export function mergeKunRuntimeSettings(
   // so round-tripping would silently rewrite valid non-UI values — e.g. demote
   // approvalPolicy 'never'/'suggest' to 'on-request', or escalate a 'read-only'/
   // 'external-sandbox' sandbox to 'danger-full-access' — on every settings merge.
-  return {
+  const merged: KunRuntimeSettingsV1 = {
     ...current,
     ...(patch ?? {}),
     port: nextPort,
@@ -458,8 +464,79 @@ export function mergeKunRuntimeSettings(
     modelProfiles: nextModelProfiles,
     memoryEnabled: patch?.memoryEnabled ?? current.memoryEnabled ?? false,
     computerUse: nextComputerUse,
-    quality: nextQuality
+    quality: nextQuality,
+    ...(patch?.subagents !== undefined
+      ? { subagents: patch.subagents }
+      : current.subagents !== undefined
+        ? { subagents: current.subagents }
+        : {})
+  }
+  // Optional model slots are authoritative from mergeOptionalModelSlot: strip any
+  // verbatim copies leaked by the spreads above, then re-apply only the non-empty
+  // ones so a cleared (empty-string) patch value removes the field entirely.
+  for (const key of OPTIONAL_MODEL_SLOT_KEYS) delete merged[key]
+  for (const key of OPTIONAL_REASONING_SLOT_KEYS) delete merged[key]
+  return { ...merged, ...nextRoleModelSlots, ...nextRoleReasoningSlots }
+}
+
+const OPTIONAL_MODEL_SLOT_KEYS = [
+  'smallModel',
+  'smallModelProviderId',
+  'titleModel',
+  'titleProviderId',
+  'summaryModel',
+  'summaryProviderId',
+  'codeReviewModel',
+  'codeReviewProviderId'
+] as const
+
+type OptionalModelSlotKey = (typeof OPTIONAL_MODEL_SLOT_KEYS)[number]
+
+function mergeOptionalModelSlot(
+  current: KunRuntimeSettingsV1,
+  patch: KunRuntimeSettingsPatchV1 | undefined
+): Partial<Record<OptionalModelSlotKey, string>> {
+  const out: Partial<Record<OptionalModelSlotKey, string>> = {}
+  for (const key of OPTIONAL_MODEL_SLOT_KEYS) {
+    const source = patch && key in patch ? patch[key] : current[key]
+    const trimmed = typeof source === 'string' ? source.trim() : ''
+    if (trimmed) out[key] = trimmed
+  }
+  return out
+}
+
+// Per-role reasoning-depth slots (agents.kun.*ReasoningEffort). Validated against
+// the ModelReasoningEffort enum; default 'off' is omitted so the field stays absent
+// unless the user opts into a deeper level. Must be stripped + re-applied exactly
+// like the model slots to avoid settings-sync round-trip drift.
+const OPTIONAL_REASONING_SLOT_KEYS = [
+  'titleReasoningEffort',
+  'summaryReasoningEffort',
+  'codeReviewReasoningEffort'
+] as const
+
+type OptionalReasoningSlotKey = (typeof OPTIONAL_REASONING_SLOT_KEYS)[number]
+
+function mergeOptionalReasoningSlot(
+  current: KunRuntimeSettingsV1,
+  patch: KunRuntimeSettingsPatchV1 | undefined
+): Partial<Record<OptionalReasoningSlotKey, ModelReasoningEffort>> {
+  const out: Partial<Record<OptionalReasoningSlotKey, ModelReasoningEffort>> = {}
+  for (const key of OPTIONAL_REASONING_SLOT_KEYS) {
+    const source = patch && key in patch ? patch[key] : current[key]
+    const normalized = normalizeReasoningEffortOrUndefined(source)
+    // Omit 'off' (the default) and undefined so the field stays absent.
+    if (normalized && normalized !== 'off') out[key] = normalized
   }
+  return out
+}
+
+function normalizeReasoningEffortOrUndefined(
+  value: unknown
+): ModelReasoningEffort | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim() as ModelReasoningEffort
+  return MODEL_REASONING_EFFORTS.includes(trimmed) ? trimmed : undefined
 }
 
 function normalizeKunImageGenerationSettings(
@@ -695,12 +772,16 @@ function normalizeKunContextCompactionSettings(
   return {
     defaultSoftThreshold,
     defaultHardThreshold: Math.max(defaultSoftThreshold, requestedHardThreshold),
-    summaryMode: input?.summaryMode === 'model' || input?.summaryMode === 'heuristic'
-      ? input.summaryMode
-      : defaults.summaryMode,
+    // Compaction is always model-based now (the heuristic fold survives only as
+    // a silent in-loop fallback when the model call fails). 'heuristic' is no
+    // longer a user-selectable mode, so any stored value coerces to 'model' —
+    // this self-heals stale 'heuristic' configs from the removed UI toggle.
+    summaryMode: 'model',
     summaryTimeoutMs: boundedPositiveInt(input?.summaryTimeoutMs, defaults.summaryTimeoutMs, 120_000),
     summaryMaxTokens: boundedPositiveInt(input?.summaryMaxTokens, defaults.summaryMaxTokens, 16_000),
-    summaryInputMaxBytes: boundedPositiveInt(input?.summaryInputMaxBytes, defaults.summaryInputMaxBytes, 8 * 1024 * 1024)
+    summaryInputMaxBytes: boundedPositiveInt(input?.summaryInputMaxBytes, defaults.summaryInputMaxBytes, 8 * 1024 * 1024),
+    ...(typeof input?.summaryModel === 'string' && input.summaryModel.trim() ? { summaryModel: input.summaryModel.trim() } : {}),
+    ...(typeof input?.summaryProviderId === 'string' && input.summaryProviderId.trim() ? { summaryProviderId: input.summaryProviderId.trim() } : {})
   }
 }
 
diff --git a/src/shared/app-settings-normalize.ts b/src/shared/app-settings-normalize.ts
index 63c7e7c58..4e0595a31 100644
--- a/src/shared/app-settings-normalize.ts
+++ b/src/shared/app-settings-normalize.ts
@@ -1,10 +1,16 @@
 import {
   DEFAULT_GUI_UPDATE_CHANNEL,
+  CHECKPOINT_CLEANUP_INTERVAL_DAYS,
+  DEFAULT_CHECKPOINT_CLEANUP_ENABLED,
+  DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS,
   DEFAULT_CURSOR_SPOTLIGHT_COLOR,
   DEFAULT_LOG_RETENTION_DAYS,
   normalizeGuiUpdateChannel,
+  normalizeUiFontScale,
   type AppBehaviorConfigV1,
   type AppSettingsV1,
+  type CheckpointCleanupConfigV1,
+  type CheckpointCleanupIntervalDays,
   type ClawSettingsPatchV1,
   type GuiUpdateConfigV1,
   type NotificationConfigV1,
@@ -42,6 +48,7 @@ export function normalizeAppSettings(settings: AppSettingsV1): AppSettingsV1 {
     keyboardShortcuts?: Partial<KeyboardShortcutsConfigV1>
     notifications?: Partial<NotificationConfigV1>
     provider?: Parameters<typeof normalizeModelProviderSettings>[0]
+    checkpointCleanup?: Partial<CheckpointCleanupConfigV1>
     write?: WriteSettingsPatchV1
     claw?: ClawSettingsPatchV1
     schedule?: ScheduleSettingsPatchV1
@@ -70,12 +77,7 @@ export function normalizeAppSettings(settings: AppSettingsV1): AppSettingsV1 {
       maybeSettings.theme === 'light' || maybeSettings.theme === 'dark' || maybeSettings.theme === 'system'
         ? maybeSettings.theme
         : 'system',
-    uiFontScale:
-      maybeSettings.uiFontScale === 'small' ||
-      maybeSettings.uiFontScale === 'medium' ||
-      maybeSettings.uiFontScale === 'large'
-        ? maybeSettings.uiFontScale
-        : 'small',
+    uiFontScale: normalizeUiFontScale(maybeSettings.uiFontScale),
     cursorSpotlight: maybeSettings.cursorSpotlight !== false,
     cursorSpotlightColor: normalizeCursorSpotlightColor(maybeSettings.cursorSpotlightColor),
     provider: providerSettings,
@@ -91,6 +93,7 @@ export function normalizeAppSettings(settings: AppSettingsV1): AppSettingsV1 {
         ? maybeSettings.log.retentionDays
         : DEFAULT_LOG_RETENTION_DAYS
     },
+    checkpointCleanup: normalizeCheckpointCleanupSettings(maybeSettings.checkpointCleanup),
     notifications: {
       turnComplete: maybeSettings.notifications?.turnComplete !== false
     },
@@ -111,6 +114,28 @@ export function normalizeAppSettings(settings: AppSettingsV1): AppSettingsV1 {
   }
 }
 
+export function normalizeCheckpointCleanupIntervalDays(value: unknown): CheckpointCleanupIntervalDays {
+  const parsed = typeof value === 'number' ? value : Number(value)
+  if (!Number.isFinite(parsed)) return DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS
+  if (parsed <= 1) return 1
+  if (parsed <= 2) return 2
+  if (parsed <= 3) return 3
+  if (parsed <= 5) return 5
+  return 10
+}
+
+export function normalizeCheckpointCleanupSettings(
+  settings?: Partial<CheckpointCleanupConfigV1>
+): CheckpointCleanupConfigV1 {
+  const intervalDays = normalizeCheckpointCleanupIntervalDays(settings?.intervalDays)
+  return {
+    enabled: typeof settings?.enabled === 'boolean' ? settings.enabled : DEFAULT_CHECKPOINT_CLEANUP_ENABLED,
+    intervalDays: CHECKPOINT_CLEANUP_INTERVAL_DAYS.includes(intervalDays)
+      ? intervalDays
+      : DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS
+  }
+}
+
 export function normalizeCursorSpotlightColor(value: unknown): string {
   if (typeof value !== 'string') return DEFAULT_CURSOR_SPOTLIGHT_COLOR
   const color = value.trim()
diff --git a/src/shared/app-settings-provider.test.ts b/src/shared/app-settings-provider.test.ts
index 649d90112..3d02a9b77 100644
--- a/src/shared/app-settings-provider.test.ts
+++ b/src/shared/app-settings-provider.test.ts
@@ -43,7 +43,7 @@ function settings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: {
       ...defaultModelProviderSettings(),
       providers: [
@@ -68,6 +68,7 @@ function settings(): AppSettingsV1 {
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
diff --git a/src/shared/app-settings-types.ts b/src/shared/app-settings-types.ts
index d26f1009f..48416cc6b 100644
--- a/src/shared/app-settings-types.ts
+++ b/src/shared/app-settings-types.ts
@@ -23,7 +23,26 @@ export {
 } from '../../kun/src/contracts/policy.js'
 export const KUN_TOOL_PERMISSION_MODES = ['always-ask', 'read-only', 'sensitive-ask', 'workspace-write', 'bypass'] as const
 export type KunToolPermissionMode = (typeof KUN_TOOL_PERMISSION_MODES)[number]
-export type UiFontScale = 'small' | 'medium' | 'large'
+/**
+ * Overall UI text scale factor (applied as `zoom` on the app shell).
+ * Previously a fixed enum ('small' | 'medium' | 'large'); now a free numeric
+ * factor so the user can pick any size. Legacy enum values are migrated on load.
+ */
+export type UiFontScale = number
+export const UI_FONT_SCALE_MIN = 0.7
+export const UI_FONT_SCALE_MAX = 1.4
+export const DEFAULT_UI_FONT_SCALE = 0.82
+/** Maps the retired small/medium/large presets to their old zoom factors. */
+export const LEGACY_UI_FONT_SCALE_FACTORS = { small: 0.82, medium: 0.88, large: 1 } as const
+/** Coerce any stored/legacy value into a valid numeric scale factor. */
+export function normalizeUiFontScale(value: unknown): UiFontScale {
+  if (typeof value === 'string' && value in LEGACY_UI_FONT_SCALE_FACTORS) {
+    return LEGACY_UI_FONT_SCALE_FACTORS[value as keyof typeof LEGACY_UI_FONT_SCALE_FACTORS]
+  }
+  const num = typeof value === 'number' ? value : Number(value)
+  if (!Number.isFinite(num)) return DEFAULT_UI_FONT_SCALE
+  return Math.min(UI_FONT_SCALE_MAX, Math.max(UI_FONT_SCALE_MIN, Math.round(num * 100) / 100))
+}
 export type ScheduleRunMode = 'agent' | 'plan'
 export type ScheduleKind = 'manual' | 'interval' | 'daily' | 'at'
 export type ScheduleTaskStatus = 'idle' | 'queued' | 'running' | 'success' | 'error'
@@ -80,6 +99,12 @@ export const DEFAULT_WRITE_INLINE_LONG_COMPLETION_MIN_ACCEPT_SCORE = 0.36
 export const DEFAULT_WRITE_INLINE_LONG_COMPLETION_MAX_TOKENS = 256
 export const DEFAULT_KUN_PORT = 18899
 export const DEFAULT_LOG_RETENTION_DAYS = 3
+export const CHECKPOINT_CLEANUP_INTERVAL_DAYS = [1, 2, 3, 5, 10] as const
+export type CheckpointCleanupIntervalDays = (typeof CHECKPOINT_CLEANUP_INTERVAL_DAYS)[number]
+export const DEFAULT_CHECKPOINT_CLEANUP_INTERVAL_DAYS: CheckpointCleanupIntervalDays = 3
+// Checkpoint cleanup deletes data, so it is opt-in: disabled until the user
+// explicitly enables it in settings.
+export const DEFAULT_CHECKPOINT_CLEANUP_ENABLED = false
 export const DEFAULT_CURSOR_SPOTLIGHT_COLOR = '#85c1f1'
 export const DEFAULT_WEIXIN_BRIDGE_RPC_URL = 'http://127.0.0.1:18790/api/v1/admin/rpc'
 export const DEFAULT_MODEL_PROVIDER_ID = 'deepseek'
@@ -188,6 +213,45 @@ export type ModelProviderSettingsPatchV1 = Partial<
   providers?: ModelProviderProfilePatchV1[]
 }
 
+export type KunSubagentProfileV1 = {
+  /** Stable key; becomes the Record key in kun SubagentsCapabilityConfig.profiles. */
+  id: string
+  enabled: boolean
+  name: string
+  description?: string
+  /** Hex color for the GUI avatar chip. */
+  color?: string
+  /** 'subagent' = delegate_task only; 'primary' = session persona only; 'all' = both. */
+  mode: 'subagent' | 'primary' | 'all'
+  model?: string
+  providerId?: string
+  /** Appended to the base system prompt (augment, not replace). */
+  systemPrompt?: string
+  /** Prepended to the user prompt body to steer the child without changing the system fingerprint. */
+  promptPreamble?: string
+  /** 'readOnly' restricts child to read/grep/find/ls; 'inherit' passes all tools. */
+  toolPolicy: 'readOnly' | 'inherit'
+  /** Explicit allow-list; overrides toolPolicy when set. */
+  allowedTools?: string[]
+  /** Built-in tool names switched off for this profile (deny-list, layered on inherit). Empty/undefined = inherit all. */
+  blockedTools?: string[]
+  /** MCP server ids switched off for this profile (deny-list; the whole server toolset is hidden). */
+  blockedMcpServers?: string[]
+  /** Skill ids switched off for this profile (deny-list; default inherits every available skill). */
+  blockedSkills?: string[]
+  /** Reasoning depth applied to this profile's child model requests. Default 'off'. */
+  reasoningEffort?: ModelReasoningEffort
+}
+
+export type KunSubagentsSettingsV1 = {
+  enabled: boolean
+  maxParallel?: number
+  maxChildRuns?: number
+  defaultToolPolicy?: 'readOnly' | 'inherit'
+  defaultProfile?: string
+  profiles: KunSubagentProfileV1[]
+}
+
 export type KunRuntimeSettingsV1 = {
   binaryPath: string
   port: number
@@ -237,6 +301,30 @@ export type KunRuntimeSettingsV1 = {
   computerUse: KunComputerUseSettingsV1
   /** First-party design-quality linter applied to frontend output. */
   quality: KunDesignQualitySettingsV1
+  /** GUI-managed subagent profiles written into kun SubagentsCapabilityConfig. */
+  subagents?: KunSubagentsSettingsV1
+  /** Global small-model slot. Title & Summary default to this. Empty = follow main model. */
+  smallModel?: string
+  /** Provider id paired with smallModel for per-provider routing. */
+  smallModelProviderId?: string
+  /** Optional model override for thread title generation. Empty = smallModel || main model. */
+  titleModel?: string
+  /** Provider id paired with titleModel. */
+  titleProviderId?: string
+  /** Optional model override for whole-session summary generation. Empty = smallModel || main model. */
+  summaryModel?: string
+  /** Provider id paired with summaryModel. */
+  summaryProviderId?: string
+  /** Optional model override for the code-review subagent. Empty = smallModel || main model. */
+  codeReviewModel?: string
+  /** Provider id paired with codeReviewModel. */
+  codeReviewProviderId?: string
+  /** Reasoning depth for thread-title generation. Default 'off'. */
+  titleReasoningEffort?: ModelReasoningEffort
+  /** Reasoning depth for whole-session summary generation. Default 'off'. */
+  summaryReasoningEffort?: ModelReasoningEffort
+  /** Reasoning depth for the code-review subagent model call. Default 'off'. */
+  codeReviewReasoningEffort?: ModelReasoningEffort
 }
 
 export function kunToolPermissionModeSettings(
@@ -426,6 +514,10 @@ export type KunContextCompactionSettingsV1 = {
   summaryTimeoutMs: number
   summaryMaxTokens: number
   summaryInputMaxBytes: number
+  /** Optional model override for context compaction (empty = follow default model). */
+  summaryModel?: string
+  /** Provider id paired with summaryModel for per-provider routing. */
+  summaryProviderId?: string
 }
 
 export type KunToolStormSettingsV1 = {
@@ -503,6 +595,11 @@ export type LogConfigV1 = {
   retentionDays: number
 }
 
+export type CheckpointCleanupConfigV1 = {
+  enabled: boolean
+  intervalDays: CheckpointCleanupIntervalDays
+}
+
 export type NotificationConfigV1 = {
   turnComplete: boolean
 }
@@ -1468,8 +1565,8 @@ export const WRITE_FONT_PRESETS: readonly WriteFontPreset[] = [
   'custom'
 ] as const
 
-export const WRITE_EDITOR_FONT_SIZE_MIN = 12
-export const WRITE_EDITOR_FONT_SIZE_MAX = 28
+export const WRITE_EDITOR_FONT_SIZE_MIN = 10
+export const WRITE_EDITOR_FONT_SIZE_MAX = 48
 export const DEFAULT_WRITE_EDITOR_FONT_SIZE_PX = 16
 export const WRITE_EDITOR_LINE_HEIGHT_MIN = 1.4
 export const WRITE_EDITOR_LINE_HEIGHT_MAX = 2.2
@@ -1646,6 +1743,7 @@ export type AppSettingsV1 = {
   agents: KunSettingsEnvelopeV1
   workspaceRoot: string
   log: LogConfigV1
+  checkpointCleanup: CheckpointCleanupConfigV1
   notifications: NotificationConfigV1
   appBehavior: AppBehaviorConfigV1
   keyboardShortcuts: KeyboardShortcutsConfigV1
@@ -1661,11 +1759,12 @@ export type AppSettingsV1 = {
 }
 
 export type AppSettingsPatch = Partial<
-  Omit<AppSettingsV1, 'provider' | 'agents' | 'log' | 'notifications' | 'appBehavior' | 'keyboardShortcuts' | 'write' | 'claw' | 'schedule' | 'workflow' | 'guiUpdate' | 'terminal'>
+  Omit<AppSettingsV1, 'provider' | 'agents' | 'log' | 'checkpointCleanup' | 'notifications' | 'appBehavior' | 'keyboardShortcuts' | 'write' | 'claw' | 'schedule' | 'workflow' | 'guiUpdate' | 'terminal'>
 > & {
   provider?: ModelProviderSettingsPatchV1
   agents?: KunSettingsEnvelopePatchV1
   log?: Partial<LogConfigV1>
+  checkpointCleanup?: Partial<CheckpointCleanupConfigV1>
   notifications?: Partial<NotificationConfigV1>
   appBehavior?: Partial<AppBehaviorConfigV1>
   keyboardShortcuts?: Partial<KeyboardShortcutsConfigV1>
diff --git a/src/shared/app-settings.test.ts b/src/shared/app-settings.test.ts
index 9f8e947ec..959c2b1f6 100644
--- a/src/shared/app-settings.test.ts
+++ b/src/shared/app-settings.test.ts
@@ -51,13 +51,14 @@ function settings(): AppSettingsV1 {
     version: 1,
     locale: 'en',
     theme: 'system',
-    uiFontScale: 'small',
+    uiFontScale: 0.82,
     provider: defaultModelProviderSettings(),
     agents: {
       kun: defaultKunRuntimeSettings()
     },
     workspaceRoot: '/tmp/workspace',
     log: { enabled: false, retentionDays: 7 },
+    checkpointCleanup: { enabled: false, intervalDays: 3 },
     notifications: { turnComplete: true },
     appBehavior: { openAtLogin: false, startMinimized: false, closeToTray: false },
     keyboardShortcuts: defaultKeyboardShortcuts(),
@@ -811,7 +812,7 @@ describe('legacy Kun defaults migration', () => {
       version: 1,
       locale: 'zh',
       theme: 'dark',
-      uiFontScale: 'small',
+      uiFontScale: 0.82,
       agentProvider: 'deepseek-runtime',
       deepseek: {
         binaryPath: '/usr/local/bin/deepseek',
@@ -852,7 +853,7 @@ describe('legacy Kun defaults migration', () => {
       version: 1,
       locale: 'zh',
       theme: 'dark',
-      uiFontScale: 'small',
+      uiFontScale: 0.82,
       agentProvider: 'deepseek-runtime',
       deepseek: {
         binaryPath: '/usr/local/bin/deepseek',
diff --git a/src/shared/kun-gui-api.ts b/src/shared/kun-gui-api.ts
index d982126c5..c07041f8c 100644
--- a/src/shared/kun-gui-api.ts
+++ b/src/shared/kun-gui-api.ts
@@ -35,6 +35,8 @@ import type {
 } from './gui-update'
 import type {
   ClipboardImageReadResult,
+  LocalPdfTextReadResult,
+  LocalPdfTextTarget,
   WorkspaceClipboardImageSavePayload,
   WorkspaceClipboardImageSaveResult,
   WorkspaceFileReadResult,
@@ -400,6 +402,7 @@ export type KunGuiApi = {
   readWorkspaceFile: (options: WorkspaceFileTarget) => Promise<WorkspaceFileReadResult>
   readWorkspaceImage: (options: WorkspaceFileTarget) => Promise<WorkspaceImageReadResult>
   readWorkspacePdf: (options: WorkspaceFileTarget) => Promise<WorkspacePdfReadResult>
+  readLocalPdfText: (options: LocalPdfTextTarget) => Promise<LocalPdfTextReadResult>
   saveWorkspaceFileAs: (payload: WorkspaceFileSaveAsPayload) => Promise<WorkspaceFileSaveAsResult>
   writeWorkspaceFile: (payload: WorkspaceFileWritePayload) => Promise<WorkspaceFileWriteResult>
   createWorkspaceFile: (payload: WorkspaceFileCreatePayload) => Promise<WorkspaceFileCreateResult>
diff --git a/src/shared/workspace-file.ts b/src/shared/workspace-file.ts
index 032dbe977..6101c88e2 100644
--- a/src/shared/workspace-file.ts
+++ b/src/shared/workspace-file.ts
@@ -121,6 +121,23 @@ export type WorkspacePdfReadResult =
     }
   | { ok: false; message: string }
 
+export type LocalPdfTextTarget = {
+  path: string
+}
+
+export type LocalPdfTextReadResult =
+  | {
+      ok: true
+      path: string
+      size: number
+      mtimeMs: number
+      pageCount: number
+      text: string
+      hasText: boolean
+      truncated: boolean
+    }
+  | { ok: false; message: string }
+
 export type WorkspaceFileResolveResult =
   | {
       ok: true