diff --git a/CHANGELOG.md b/CHANGELOG.md
index ec1880c4..87583a93 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,38 @@ Notable changes to AGBench, the local-first macOS desktop workbench for running
 and reviewing AI coding agents. Entries are user-facing highlights; execution,
 history, and workspace state stay on your machine throughout.
 
+## 1.0.73 — 2026-06-04
+
+### Added
+- **Commit & open PRs from the composer** — the Review changes menu now drives a
+  real Git flow: see your branch and changed files, write a message and Stage all
+  & Commit, then Create PR once the branch is pushed and ready (gated on a live
+  readiness check).
+- **Clearer Ensemble cost & escalation** — each round shows real vs. estimated
+  spend (a latency line + an "API-equivalent" badge on estimates), and the
+  orchestrator's escalation signals surface inline, so a multi-seat panel's value
+  is visible rather than guessed.
+- **Optional "why?" on approvals** — attach a short intent note when you allow or
+  deny an agent action; it's recorded in the approval ledger.
+
+### Changed
+- **Refined native composer** — the AGBench shell is now a cohesive console: the
+  input sits in a framed module (solid black/white outer frame, theme-tone inner
+  panel + provider rim, full-bleed and squared), the Ensemble / Create-PR / Steer
+  rows match the same solid frame, and the permission picker sits up front beside
+  the + button. Onboarding and Settings → Appearance previews reflect the new look.
+- **Deleting a chat tidies up after itself** — removing a chat now also clears
+  that chat's own run-forensic artifacts (and only those).
+
+### Fixed
+- **Kimi tool calls** — repeated calls coalesce into a single inline card that
+  updates in place (instead of stacking) and now show the target filename,
+  matching the other providers.
+- **Bug Report Refinement** — tidied how the in-app reporter shows your workspace
+  (now a friendly `~/…` label).
+- Onboarding, empty states, the welcome dashboard, provider accent colours, and
+  the Diff Studio / File Editor light themes all got polish + readability fixes.
+
 ## 1.0.72 — 2026-06-04
 
 ### Security
diff --git a/package-lock.json b/package-lock.json
index a1d0e806..13b26334 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "agbench",
-  "version": "1.0.7",
+  "version": "1.0.73",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "agbench",
-      "version": "1.0.7",
+      "version": "1.0.73",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
diff --git a/package.json b/package.json
index feb7498a..4fc53511 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "agbench",
-  "version": "1.0.72",
+  "version": "1.0.73",
   "description": "AGBench desktop workspace",
   "main": "./out/main/index.js",
   "author": "Chris Izatt",
diff --git a/src/main/AppStoreDeleteChat.test.ts b/src/main/AppStoreDeleteChat.test.ts
new file mode 100644
index 00000000..8fa3b70b
--- /dev/null
+++ b/src/main/AppStoreDeleteChat.test.ts
@@ -0,0 +1,104 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import fs from 'fs'
+import { join } from 'path'
+import { AppStore } from './store'
+import type { ChatRecord, ChatRun } from './store/types'
+
+const userDataPath = vi.hoisted(() => `/tmp/agentbench-delete-chat-test-${process.pid}`)
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: () => userDataPath
+  }
+}))
+
+const runEventPath = (runId: string): string => join(userDataPath, 'run-events', `${runId}.jsonl`)
+const artifactDir = (runId: string): string => join(userDataPath, 'run-artifacts', runId)
+
+function makeRun(runId: string): ChatRun {
+  return { runId, startedAt: '2026-05-08T00:00:00.000Z' }
+}
+
+function seedRunFiles(runId: string): void {
+  fs.mkdirSync(join(userDataPath, 'run-events'), { recursive: true })
+  fs.writeFileSync(runEventPath(runId), `{"runId":"${runId}"}\n`, 'utf8')
+  fs.mkdirSync(artifactDir(runId), { recursive: true })
+  fs.writeFileSync(join(artifactDir(runId), 'stdout.log'), 'stream\n', 'utf8')
+}
+
+function saveChatWithRuns(appChatId: string, runs: ChatRun[]): ChatRecord {
+  const chat: ChatRecord = {
+    appChatId,
+    scope: 'workspace',
+    chatKind: 'single',
+    provider: 'gemini',
+    title: appChatId,
+    workspaceId: 'workspace-1',
+    workspacePath: '/repo',
+    createdAt: 1,
+    updatedAt: 1,
+    archived: false,
+    messages: [],
+    runs
+  }
+  AppStore.saveChat(chat)
+  return chat
+}
+
+describe('AppStore.deleteChat run cleanup', () => {
+  beforeEach(() => {
+    fs.rmSync(userDataPath, { recursive: true, force: true })
+    fs.mkdirSync(join(userDataPath, 'chats'), { recursive: true })
+  })
+
+  it('removes the deleted chat run-event files and artifacts', () => {
+    saveChatWithRuns('chat-a', [makeRun('run-1'), makeRun('run-2')])
+    seedRunFiles('run-1')
+    seedRunFiles('run-2')
+
+    expect(fs.existsSync(runEventPath('run-1'))).toBe(true)
+    expect(fs.existsSync(artifactDir('run-1'))).toBe(true)
+
+    AppStore.deleteChat('chat-a')
+
+    // Chat JSON gone (behaviour preserved).
+    expect(fs.existsSync(join(userDataPath, 'chats', 'chat-a.json'))).toBe(false)
+    // Both runs' forensic files removed.
+    expect(fs.existsSync(runEventPath('run-1'))).toBe(false)
+    expect(fs.existsSync(artifactDir('run-1'))).toBe(false)
+    expect(fs.existsSync(runEventPath('run-2'))).toBe(false)
+    expect(fs.existsSync(artifactDir('run-2'))).toBe(false)
+  })
+
+  it('leaves a sibling chat with a prefix-similar run id untouched', () => {
+    // chat-a owns `run-1`; sibling chat-b owns `run-1-extra` whose id has
+    // `run-1` as a string prefix. A prefix/readdir-based delete would wrongly
+    // catch the sibling's files; an exact-name delete must not.
+    saveChatWithRuns('chat-a', [makeRun('run-1')])
+    saveChatWithRuns('chat-b', [makeRun('run-1-extra')])
+    seedRunFiles('run-1')
+    seedRunFiles('run-1-extra')
+
+    AppStore.deleteChat('chat-a')
+
+    // Deleted chat's run is gone...
+    expect(fs.existsSync(runEventPath('run-1'))).toBe(false)
+    expect(fs.existsSync(artifactDir('run-1'))).toBe(false)
+    // ...but the sibling's prefix-similar run is fully intact.
+    expect(fs.existsSync(runEventPath('run-1-extra'))).toBe(true)
+    expect(fs.existsSync(artifactDir('run-1-extra'))).toBe(true)
+    expect(fs.existsSync(join(userDataPath, 'chats', 'chat-b.json'))).toBe(true)
+  })
+
+  it('succeeds when a run-event file is already missing', () => {
+    // run-1 has files, run-2 was never persisted (missing on disk).
+    saveChatWithRuns('chat-a', [makeRun('run-1'), makeRun('run-2')])
+    seedRunFiles('run-1')
+    expect(fs.existsSync(runEventPath('run-2'))).toBe(false)
+
+    expect(() => AppStore.deleteChat('chat-a')).not.toThrow()
+
+    expect(fs.existsSync(runEventPath('run-1'))).toBe(false)
+    expect(fs.existsSync(join(userDataPath, 'chats', 'chat-a.json'))).toBe(false)
+  })
+})
diff --git a/src/main/AppStoreSettings.test.ts b/src/main/AppStoreSettings.test.ts
new file mode 100644
index 00000000..81a583c1
--- /dev/null
+++ b/src/main/AppStoreSettings.test.ts
@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import fs from 'fs'
+import { AppStore } from './store'
+
+const userDataPath = vi.hoisted(() => `/tmp/agbench-settings-test-${process.pid}`)
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: () => userDataPath
+  }
+}))
+
+describe('AppStore settings defaults', () => {
+  beforeEach(() => {
+    fs.rmSync(userDataPath, { recursive: true, force: true })
+    fs.mkdirSync(userDataPath, { recursive: true })
+  })
+
+  it('defaults packaged update checks to the stable channel', () => {
+    expect(AppStore.getSettings().updateChannel).toBe('stable')
+  })
+
+  it('normalizes persisted changelog metadata on load', () => {
+    AppStore.updateSettings({
+      lastSeenChangelogVersion: ' 1.0.72 ',
+      pendingUpdateChangelog: {
+        version: ' 1.0.73 ',
+        releaseName: ' AGBench 1.0.73 ',
+        releaseDate: ' 2026-06-04T12:00:00.000Z ',
+        releaseNotes: [{ version: ' 1.0.73 ', note: 'Updater UI.' }, { version: '', note: '' }]
+      }
+    })
+
+    expect(AppStore.getSettings()).toMatchObject({
+      lastSeenChangelogVersion: '1.0.72',
+      pendingUpdateChangelog: {
+        version: '1.0.73',
+        releaseName: 'AGBench 1.0.73',
+        releaseDate: '2026-06-04T12:00:00.000Z',
+        releaseNotes: [{ version: '1.0.73', note: 'Updater UI.' }]
+      }
+    })
+  })
+})
diff --git a/src/main/EnsemblePrompt.test.ts b/src/main/EnsemblePrompt.test.ts
index 23be3111..29907715 100644
--- a/src/main/EnsemblePrompt.test.ts
+++ b/src/main/EnsemblePrompt.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
   buildEnsembleParticipantPrompt,
+  buildParticipantTokenMap,
   formatRoundModeInstructions,
   formatSameProviderDisambiguationNote,
   formatToolTraceSummary,
@@ -381,8 +382,10 @@ describe('Ensemble prompt composition', () => {
       currentPrompt: 'Walk through this codebase.',
       roundId: 'round-1'
     })
-    // Roster marker present for the first speaker
-    expect(prompt).toContain('Claude / Reviewer (you — first speaker)')
+    // Roster marker present for the first speaker. 1.0.7 — the
+    // rename-stable handle `#p1` now sits between the role and the
+    // position marker (Claude's id sorts first → `p1`).
+    expect(prompt).toContain('Claude / Reviewer #p1 (you — first speaker)')
     // Scoping rule present in the Rules section
     expect(prompt).toContain('SPEAKING FIRST in a multi-participant round')
     expect(prompt).toContain('Scope the problem and propose a direction')
@@ -401,7 +404,8 @@ describe('Ensemble prompt composition', () => {
     // 1.0.4-AJ — middle slot now carries an explicit position
     // count ("you — position 2 of 3") to give the model a turn-
     // awareness signal. The first-speaker rule itself stays off.
-    expect(prompt).toContain('Codex / Worker (you — position 2 of 3)')
+    // 1.0.7 — `#p2` (Codex's id sorts second) sits before the marker.
+    expect(prompt).toContain('Codex / Worker #p2 (you — position 2 of 3)')
     expect(prompt).not.toContain('first speaker')
     expect(prompt).not.toContain('SPEAKING FIRST')
   })
@@ -421,8 +425,9 @@ describe('Ensemble prompt composition', () => {
       roundId: 'round-1'
     })
     // Even for the single participant, no "first speaker" framing
-    // since there's no second/third speaker to defer to.
-    expect(prompt).toContain('Claude / Reviewer (you)')
+    // since there's no second/third speaker to defer to. 1.0.7 — a
+    // solo roster still gets a handle (`#p1`) for tag consistency.
+    expect(prompt).toContain('Claude / Reviewer #p1 (you)')
     expect(prompt).not.toContain('first speaker')
     expect(prompt).not.toContain('SPEAKING FIRST')
   })
@@ -443,7 +448,7 @@ describe('Ensemble prompt composition', () => {
       currentPrompt: 'Close out the round.',
       roundId: 'round-1'
     })
-    expect(prompt).toContain('Gemini / Researcher (you — last speaker, position 3 of 3)')
+    expect(prompt).toContain('Gemini / Researcher #p3 (you — last speaker, position 3 of 3)')
     expect(prompt).toContain('SPEAKING LAST in this turn-bound round')
     expect(prompt).toContain('position 3 of 3')
     expect(prompt).toContain('`ensemble_yield(target: ...)` cannot route')
@@ -462,7 +467,8 @@ describe('Ensemble prompt composition', () => {
     expect(prompt).not.toContain('SPEAKING LAST')
     expect(prompt).not.toContain('last speaker')
     // Middle slot in 3+ round gets the bare position marker
-    expect(prompt).toContain('Codex / Worker (you — position 2 of 3)')
+    // (1.0.7 — with the `#p2` handle ahead of it).
+    expect(prompt).toContain('Codex / Worker #p2 (you — position 2 of 3)')
   })
 
   it('does NOT emit the last-speaker rule in continuous orchestration mode', () => {
@@ -486,8 +492,8 @@ describe('Ensemble prompt composition', () => {
     // Continuous-mode speaker at the bottom of the roster still
     // gets a position marker for context (the round can extend
     // via the hop budget; "position 3 of 3" reflects roster
-    // position, not a hard-end).
-    expect(prompt).toContain('Gemini / Researcher (you — position 3 of 3)')
+    // position, not a hard-end). 1.0.7 — `#p3` handle ahead of it.
+    expect(prompt).toContain('Gemini / Researcher #p3 (you — position 3 of 3)')
   })
 
   it('emits the hops-near-cap rule when continuous round is near its limit', () => {
@@ -653,6 +659,186 @@ describe('Ensemble prompt composition', () => {
   })
 })
 
+/*
+ * 1.0.7 — rename-stable participant handle (`#pN`) in the agent-
+ * visible tag.
+ *
+ * The handle is derived from a STABLE ordering of the roster by the
+ * immutable participant id (NOT `order`, NOT `role`), so a seat keeps
+ * the same `#pN` across role renames + speaking-order reshuffles. It's
+ * an identity anchor — `#`-prefixed so it can never resolve as an
+ * `@`-mention — that lets a reader tie a renamed seat's later messages
+ * back to its earlier frozen-role messages.
+ */
+describe('buildParticipantTokenMap (1.0.7 stable handle)', () => {
+  it('assigns p1..pN by stable id sort, independent of speaking order', () => {
+    // Speaking `order` is deliberately reversed vs id sort to prove
+    // the token tracks the id, not the order.
+    const map = buildParticipantTokenMap([
+      { ...ensemble.participants[0], id: 'gemini', order: 1 },
+      { ...ensemble.participants[1], id: 'codex', order: 2 },
+      { ...ensemble.participants[2], id: 'claude', order: 3 }
+    ])
+    // claude < codex < gemini lexicographically.
+    expect(map.get('claude')).toBe('p1')
+    expect(map.get('codex')).toBe('p2')
+    expect(map.get('gemini')).toBe('p3')
+  })
+
+  it('is stable across a role rename (token keyed on id, not role)', () => {
+    const before = buildParticipantTokenMap([
+      { ...ensemble.participants[0], id: 'seat-a', role: 'Planner' },
+      { ...ensemble.participants[1], id: 'seat-b', role: 'Worker' }
+    ])
+    const after = buildParticipantTokenMap([
+      { ...ensemble.participants[0], id: 'seat-a', role: 'Architect' }, // renamed
+      { ...ensemble.participants[1], id: 'seat-b', role: 'Worker' }
+    ])
+    expect(after.get('seat-a')).toBe(before.get('seat-a'))
+    expect(after.get('seat-b')).toBe(before.get('seat-b'))
+  })
+
+  it('is stable across a speaking-order reshuffle', () => {
+    const before = buildParticipantTokenMap([
+      { ...ensemble.participants[0], id: 'seat-a', order: 1 },
+      { ...ensemble.participants[1], id: 'seat-b', order: 2 }
+    ])
+    const after = buildParticipantTokenMap([
+      { ...ensemble.participants[1], id: 'seat-b', order: 1 }, // moved up
+      { ...ensemble.participants[0], id: 'seat-a', order: 2 }
+    ])
+    expect(after.get('seat-a')).toBe(before.get('seat-a'))
+    expect(after.get('seat-b')).toBe(before.get('seat-b'))
+  })
+
+  it('dedupes repeated ids and tolerates an empty roster', () => {
+    expect(buildParticipantTokenMap(undefined).size).toBe(0)
+    expect(buildParticipantTokenMap([]).size).toBe(0)
+    const dup = buildParticipantTokenMap([
+      { ...ensemble.participants[0], id: 'x' },
+      { ...ensemble.participants[1], id: 'x' }
+    ])
+    expect(dup.size).toBe(1)
+    expect(dup.get('x')).toBe('p1')
+  })
+})
+
+describe('Ensemble tag carries the #pN handle (1.0.7)', () => {
+  function chatWithParticipantMessages(): ChatRecord {
+    const base = chat()
+    // Stamp ensembleParticipantId so the tag can resolve a seat token.
+    return {
+      ...base,
+      messages: [
+        {
+          id: 'u1',
+          role: 'user',
+          content: 'Initial request',
+          timestamp: '2026-05-24T00:00:00.000Z'
+        },
+        {
+          id: 'a1',
+          role: 'assistant',
+          content: 'Review response',
+          timestamp: '2026-05-24T00:00:01.000Z',
+          metadata: {
+            ensembleProvider: 'claude',
+            ensembleRole: 'Reviewer',
+            ensembleParticipantId: 'claude'
+          }
+        }
+      ]
+    }
+  }
+
+  it('appends #pN to the transcript tag for a message with a roster-resolved id', () => {
+    const prompt = buildEnsembleParticipantPrompt({
+      chat: chatWithParticipantMessages(),
+      config: ensemble,
+      participant: ensemble.participants[1],
+      currentPrompt: 'Continue.',
+      roundId: 'round-2',
+      chatContextTurns: 4
+    })
+    // claude sorts first → #p1.
+    expect(prompt).toContain('[Claude / Reviewer #p1]')
+  })
+
+  it('keeps the frozen role but the CURRENT seat handle after a rename (continuity)', () => {
+    // The historical message froze role "Reviewer"; the roster has
+    // since renamed that same id to "Critic". The transcript tag must
+    // keep the FROZEN role (Reviewer) yet still carry the stable seat
+    // handle (#p1) so a reader can tie the two together.
+    const renamedConfig: EnsembleConfig = {
+      ...ensemble,
+      participants: ensemble.participants.map((p) =>
+        p.id === 'claude' ? { ...p, role: 'Critic' } : p
+      )
+    }
+    const prompt = buildEnsembleParticipantPrompt({
+      chat: chatWithParticipantMessages(),
+      config: renamedConfig,
+      participant: renamedConfig.participants[1],
+      currentPrompt: 'Continue.',
+      roundId: 'round-2',
+      chatContextTurns: 4
+    })
+    // Frozen role retained in the transcript line...
+    expect(prompt).toContain('[Claude / Reviewer #p1]')
+    // ...and the CURRENT roster line shows the renamed role with the
+    // SAME handle, anchoring the identity across the rename.
+    expect(prompt).toContain('Claude / Critic #p1')
+  })
+
+  it('omits the handle for a message whose id is no longer in the roster', () => {
+    const base = chatWithParticipantMessages()
+    const orphan: ChatRecord = {
+      ...base,
+      messages: [
+        ...base.messages,
+        {
+          id: 'a2',
+          role: 'assistant',
+          content: 'Departed participant response',
+          timestamp: '2026-05-24T00:00:02.000Z',
+          metadata: {
+            ensembleProvider: 'kimi',
+            ensembleRole: 'Coder',
+            ensembleParticipantId: 'removed-seat'
+          }
+        }
+      ]
+    }
+    const prompt = buildEnsembleParticipantPrompt({
+      chat: orphan,
+      config: ensemble,
+      participant: ensemble.participants[1],
+      currentPrompt: 'Continue.',
+      roundId: 'round-2',
+      chatContextTurns: 4
+    })
+    // No roster seat for `removed-seat` → bare provider/role tag.
+    expect(prompt).toContain('[Kimi / Coder]')
+    expect(prompt).not.toContain('Kimi / Coder #')
+  })
+
+  it('leaves messages without an ensembleParticipantId in the bare tag form', () => {
+    // The base fixture message (a1) here intentionally has NO
+    // participant id — older transcript rows predate the id stamp.
+    const base = chat() // unmodified: a1 lacks ensembleParticipantId
+    const prompt = buildEnsembleParticipantPrompt({
+      chat: base,
+      config: ensemble,
+      participant: ensemble.participants[1],
+      currentPrompt: 'Continue.',
+      roundId: 'round-2',
+      chatContextTurns: 4
+    })
+    expect(prompt).toContain('[Claude / Reviewer]')
+    expect(prompt).not.toContain('[Claude / Reviewer #')
+  })
+})
+
 describe('formatSameProviderDisambiguationNote', () => {
   function participant(
     overrides: Partial<EnsembleParticipant> & Pick<EnsembleParticipant, 'id' | 'provider'>
diff --git a/src/main/EnsemblePrompt.ts b/src/main/EnsemblePrompt.ts
index b674209a..0ec451a7 100644
--- a/src/main/EnsemblePrompt.ts
+++ b/src/main/EnsemblePrompt.ts
@@ -149,7 +149,18 @@ function applyChairSummaryOrder(
 
 export function buildEnsembleParticipantPrompt(input: BuildEnsemblePromptInput): string {
   const orderedParticipants = getOrderedEnsembleParticipants(input.config, input.currentPrompt)
-  const participantLabel = `${providerLabel(input.participant.provider)} / ${input.participant.role || 'Participant'}`
+  // 1.0.7 — rename-stable participant handles (`#p3`) keyed on the
+  // immutable participant id. Built from the FULL roster (not just the
+  // enabled/ordered subset) so a message authored by a participant who
+  // was later disabled still resolves to its seat token, and so the
+  // self-label, roster lines, and tagged transcript all reference the
+  // SAME handle. See `buildParticipantTokenMap` for the derivation +
+  // why the `#`-prefixed token is resolver-safe.
+  const participantTokens = buildParticipantTokenMap(input.config.participants)
+  const selfToken = participantTokens.get(input.participant.id)
+  const participantLabel = `${providerLabel(input.participant.provider)} / ${input.participant.role || 'Participant'}${
+    selfToken ? ` #${selfToken}` : ''
+  }`
   const orchestrationMode =
     input.config.orchestrationMode === 'continuous' ? 'continuous' : 'turn_bound'
   const maxContinuationHops = input.config.maxContinuationHops || 6
@@ -256,7 +267,15 @@ export function buildEnsembleParticipantPrompt(input: BuildEnsemblePromptInput):
         modelHintRaw ? `@${titleCase(modelHintRaw)}` : ''
       ].filter(Boolean)
       const hint = hintTokens.length ? ` — address with ${hintTokens.join(' or ')}` : ''
-      return `${participant.order}. ${providerLabel(participant.provider)} / ${participant.role || 'Participant'}${marker}${hint}`
+      // 1.0.7 — rename-stable handle (`#p3`). Placed right after the
+      // role so the roster line mirrors the transcript tag form
+      // (`Provider / Role #pN`). It's an identity anchor, not an
+      // addressing form — the `@Role` / `@Model` hints above remain
+      // the routing handles; `#pN` lets a reader (human or agent)
+      // tie a renamed seat back to its earlier frozen-role messages.
+      const rosterToken = participantTokens.get(participant.id)
+      const tokenSuffix = rosterToken ? ` #${rosterToken}` : ''
+      return `${participant.order}. ${providerLabel(participant.provider)} / ${participant.role || 'Participant'}${tokenSuffix}${marker}${hint}`
     })
     .join('\n')
   const disambigNote = formatSameProviderDisambiguationNote(orderedParticipants)
@@ -267,7 +286,14 @@ export function buildEnsembleParticipantPrompt(input: BuildEnsemblePromptInput):
   // skipped. Either both ship together or neither does.
   const hasWorkspaceStanza = workspaceStanza !== null
   const sessionEventsStanza = formatSessionEventsStanza(input.config)
-  const transcript = buildTaggedTranscript(input.chat.messages || [], input.chatContextTurns || 8)
+  // Threaded into the tagged-transcript builder so every
+  // `[Provider / Role #pN]` header carries the same handle the
+  // roster + self-label use.
+  const transcript = buildTaggedTranscript(
+    input.chat.messages || [],
+    input.chatContextTurns || 8,
+    participantTokens
+  )
 
   return [
     'AGBench Ensemble Mode',
@@ -563,14 +589,71 @@ export function formatToolTraceSummary(activities: readonly ToolActivity[] | und
   return `(tools: ${segments.join(' · ')}${suffix})`
 }
 
-function buildTaggedTranscript(messages: ChatMessage[], contextTurns: number): string {
+/**
+ * 1.0.7 — stable per-participant handle for the agent-visible
+ * transcript tag (`[Codex / Planner #p3]`).
+ *
+ * Problem it solves: the tag historically carried only `provider /
+ * role`. When the user renames a participant's role mid-session
+ * ("Planner" → "Architect"), agents lost the thread — there was no
+ * rename-stable identifier they could anchor on to address a peer
+ * across the change. The role is mutable; the model name can be
+ * shared by multiple participants; only the participant **id** is
+ * both stable and unique. But the raw id (`ensemble-participant-7`,
+ * or a base36-timestamp fallback) is long + opaque — unfit for an
+ * inline tag every model reads each round.
+ *
+ * The token derives a short, readable `pN` handle from a STABLE
+ * ordering of the roster by participant id (NOT by `order`, which
+ * the user can reshuffle, and NOT by `role`, which they can
+ * rename). Sorting by the immutable id means a given participant
+ * keeps the same `pN` across renames AND reorders — the exact
+ * mutations this feature targets. (Adding/removing a roster member
+ * can shift the indices, since they're roster-relative; that's an
+ * accepted trade-off for a readable sequential form, and matches
+ * the "unique within the roster" contract rather than a globally
+ * frozen handle.)
+ *
+ * The `#`-prefix is deliberate and load-bearing for resolver
+ * safety: `EnsembleMentionAlias`'s `MENTION_REGEX` requires a
+ * LETTER immediately after `@`, so `@#p3` can never match as a
+ * standalone mention — the token cannot be mistaken for, or
+ * resolve to, a participant. When an agent copies the full role
+ * form `@Planner #p3`, the resolver consumes `planner` (the role
+ * alias) and leaves ` #p3` as trailing prose, exactly as it would
+ * any other trailing word. The token is purely additive: it adds
+ * NO alias to the resolver and widens NO contract.
+ */
+export function buildParticipantTokenMap(
+  participants: readonly EnsembleParticipant[] | undefined
+): Map<string, string> {
+  const map = new Map<string, string>()
+  if (!participants || participants.length === 0) return map
+  // Stable ordering keyed on the immutable id so the token survives
+  // role renames + speaking-order reshuffles. Dedupe ids defensively
+  // (a malformed roster could repeat one) so each id maps to exactly
+  // one token.
+  const ids = Array.from(new Set(participants.map((p) => p.id).filter(Boolean))).sort((a, b) =>
+    a.localeCompare(b)
+  )
+  ids.forEach((id, index) => {
+    map.set(id, `p${index + 1}`)
+  })
+  return map
+}
+
+function buildTaggedTranscript(
+  messages: ChatMessage[],
+  contextTurns: number,
+  participantTokens?: Map<string, string>
+): string {
   const relevant = messages
     .filter((message) => message.role !== 'tool')
     .slice(-Math.max(1, contextTurns * 2))
   const lines: string[] = []
   let used = 0
   for (const message of relevant) {
-    const tag = messageTag(message)
+    const tag = messageTag(message, participantTokens)
     // M6 (1.0.7) — thinking-ephemerality. Strip any inlined reasoning chain
     // from a message authored by an ephemeral-reasoning provider before it
     // enters FUTURE-round context, keyed on the message's own authoring
@@ -599,13 +682,28 @@ function buildTaggedTranscript(messages: ChatMessage[], contextTurns: number): s
   return lines.join('\n\n')
 }
 
-function messageTag(message: ChatMessage): string {
+function messageTag(message: ChatMessage, participantTokens?: Map<string, string>): string {
   if (message.role === 'user') return 'User'
   if (message.role === 'assistant') {
     const provider = message.metadata?.ensembleProvider as ProviderId | undefined
     const role =
       typeof message.metadata?.ensembleRole === 'string' ? message.metadata.ensembleRole : ''
-    if (provider) return `${providerLabel(provider)}${role ? ` / ${role}` : ''}`
+    if (provider) {
+      // 1.0.7 — append the rename-stable participant handle (`#p3`)
+      // when this message carries an `ensembleParticipantId` that maps
+      // to a CURRENT roster seat. Messages from a participant since
+      // removed from the roster (or older messages predating the id
+      // stamp) carry no token and fall back to the bare provider/role
+      // form. See `buildParticipantTokenMap` for why the token is
+      // resolver-safe.
+      const participantId =
+        typeof message.metadata?.ensembleParticipantId === 'string'
+          ? message.metadata.ensembleParticipantId
+          : ''
+      const token = participantId ? participantTokens?.get(participantId) : undefined
+      const tokenSuffix = token ? ` #${token}` : ''
+      return `${providerLabel(provider)}${role ? ` / ${role}` : ''}${tokenSuffix}`
+    }
     return 'Assistant'
   }
   if (message.role === 'error') return 'Error'
diff --git a/src/main/IpcValidation.ts b/src/main/IpcValidation.ts
index 5df370b2..e3f70abe 100644
--- a/src/main/IpcValidation.ts
+++ b/src/main/IpcValidation.ts
@@ -114,6 +114,13 @@ export const IPC_ARGUMENT_SCHEMAS: Record<string, ArgSpec[]> = {
   'download-update': [],
   'install-update-on-quit': [],
   'install-update-now': [],
+  // Changelog sheet (update-pill feature): `changelog-snapshot` is a no-arg
+  // read returning ProductChangelogSnapshot | null; `mark-changelog-seen`
+  // persists the last-seen version. The handler coerces a missing/empty
+  // version defensively (returns the snapshot unchanged), so optionalString
+  // mirrors the store-*-api-key channels rather than nonEmptyString.
+  'changelog-snapshot': [],
+  'mark-changelog-seen': ['optionalString'],
   // Agent-question modal replies (the payload object carries questionId).
   'answer-agent-question': ['optionalObject'],
   'cancel-agent-question': ['optionalObject'],
@@ -130,6 +137,12 @@ export const IPC_ARGUMENT_SCHEMAS: Record<string, ArgSpec[]> = {
   'store-kimi-api-key': ['optionalString'],
   'clear-kimi-api-key': [],
   // GitHub PR creation (optional payload with target path / options).
+  'git:snapshot': ['optionalObject'],
+  'git:stage': ['optionalObject'],
+  'git:commit': ['optionalObject'],
+  'git:push': ['optionalObject'],
+  'github:pr-status': ['optionalObject'],
+  'github:pr-readiness': ['optionalObject'],
   'create-github-pr': ['optionalObject'],
   'agentic-yolo-get': [],
   'agentic-yolo-set': ['boolean'],
diff --git a/src/main/ProviderCapabilities.test.ts b/src/main/ProviderCapabilities.test.ts
index 5fdea7a6..ca380783 100644
--- a/src/main/ProviderCapabilities.test.ts
+++ b/src/main/ProviderCapabilities.test.ts
@@ -40,6 +40,11 @@ describe('ProviderCapabilities', () => {
     expect(contract.tools.fileChanges.tools).toEqual([])
     expect(contract.mcp.tools).toEqual([])
     expect(contract.warnings.map((warning) => warning.id)).toContain('gemini-bridge-disabled')
+    // elicit/delegate are unavailable until the bridge is up.
+    expect(contract.tools.elicit.state).toBe('unavailable')
+    expect(contract.tools.delegate.state).toBe('unavailable')
+    expect(contract.tools.elicit.tools).toEqual([])
+    expect(contract.tools.delegate.tools).toEqual([])
   })
 
   it('advertises Gemini bridge tools with AgentBench approval gates when available', () => {
@@ -69,6 +74,14 @@ describe('ProviderCapabilities', () => {
     ])
     expect(contract.mcp.tools).toContain('list_directory')
     expect(contract.approvals.inAppApprovals).toBe(true)
+    // ask_user_question is auto-allowed once the bridge is up; delegate
+    // inherits the subThreadDelegation policy ('ask' -> gated).
+    expect(contract.tools.elicit.state).toBe('available')
+    expect(contract.tools.elicit.requiresApproval).toBe(false)
+    expect(contract.tools.elicit.tools).toEqual(['ask_user_question'])
+    expect(contract.tools.delegate.state).toBe('gated')
+    expect(contract.tools.delegate.tools).toEqual(['delegate_to_subthread'])
+    expect(contract.tools.delegate.policy).toBe('ask')
   })
 
   it('honors blocked settings in the Codex tooling contract', () => {
@@ -87,6 +100,12 @@ describe('ProviderCapabilities', () => {
     expect(contract.tools.networkAccess.state).toBe('blocked')
     expect(contract.mcp.tools).toEqual(['read', 'search'])
     expect(contract.warnings.map((warning) => warning.id)).toContain('codex-shellCommands-blocked')
+    // Codex routes the AGBench elicitation/delegation tools regardless of the
+    // codex-native MCP server count; delegate tracks subThreadDelegation ('ask').
+    expect(contract.tools.elicit.state).toBe('available')
+    expect(contract.tools.elicit.enforcedByAgentBench).toBe(true)
+    expect(contract.tools.delegate.state).toBe('gated')
+    expect(contract.tools.delegate.enforcedByAgentBench).toBe(true)
   })
 
   it('keeps a provider runnable when optional metadata has an error', () => {
@@ -123,5 +142,88 @@ describe('ProviderCapabilities', () => {
     expect(kimi.tools.fileChanges.state).toBe('delegated')
     expect(kimi.approvals.inAppApprovals).toBe(true)
     expect(kimi.warnings.map((warning) => warning.id)).toContain('kimi-provider-managed-tools')
+    // Without an available AGBench MCP bridge (no mcpStatus), Claude/Kimi
+    // elicit/delegate are unavailable rather than delegated, mirroring how
+    // their bridge-backed tooling falls closed.
+    expect(claude.tools.elicit.state).toBe('unavailable')
+    expect(claude.tools.delegate.state).toBe('unavailable')
+    expect(kimi.tools.elicit.state).toBe('unavailable')
+    expect(kimi.tools.delegate.state).toBe('unavailable')
+  })
+
+  it('marks Claude/Kimi elicit/delegate available once the AGBench MCP bridge is up', () => {
+    const claude = buildProviderCapabilityContract({
+      provider: 'claude',
+      settings: settings(),
+      status: { provider: 'claude', available: true, version: '1.0.0' },
+      mcpStatus: {
+        enabled: true,
+        available: true,
+        serverName: 'AGBench',
+        tools: ['ask_user_question']
+      }
+    })
+
+    expect(claude.tools.elicit.state).toBe('available')
+    expect(claude.tools.elicit.requiresApproval).toBe(false)
+    expect(claude.tools.delegate.state).toBe('gated')
+    expect(claude.tools.delegate.policy).toBe('ask')
+  })
+
+  it('treats grok/cursor elicit/delegate as provider-delegated', () => {
+    const grok = buildProviderCapabilityContract({
+      provider: 'grok',
+      settings: settings(),
+      status: { provider: 'grok', available: true, version: '1.0.0' }
+    })
+
+    expect(grok.tools.elicit.state).toBe('delegated')
+    expect(grok.tools.elicit.enforcedByAgentBench).toBe(false)
+    expect(grok.tools.delegate.state).toBe('delegated')
+    expect(grok.tools.delegate.enforcedByAgentBench).toBe(false)
+  })
+
+  it('reflects a denied subThreadDelegation policy as a blocked delegate row', () => {
+    const codex = buildProviderCapabilityContract({
+      provider: 'codex',
+      settings: settings({ ...defaultServices, subThreadDelegation: 'deny' }),
+      status: { provider: 'codex', available: true, version: '1.0.0', appServer: 'started' }
+    })
+
+    expect(codex.tools.delegate.state).toBe('blocked')
+    expect(codex.tools.delegate.policy).toBe('deny')
+    // elicit is unaffected by the delegation policy.
+    expect(codex.tools.elicit.state).toBe('available')
+  })
+
+  it('does not double-count the elicit/delegate rows against the enforcement tally', () => {
+    // Roster where delegation was already enforced (subThreadDelegation 'allow').
+    // The five functional controls drive the enforced count; promoting
+    // elicit/delegate to rows must NOT change that 5-row tally.
+    const codex = buildProviderCapabilityContract({
+      provider: 'codex',
+      settings: settings({ ...defaultServices, subThreadDelegation: 'allow' }),
+      status: { provider: 'codex', available: true, version: '1.0.0', appServer: 'started' }
+    })
+
+    const controlIds = [
+      'shellCommands',
+      'fileChanges',
+      'mcpTools',
+      'creativeApps',
+      'networkAccess'
+    ] as const
+    const controlRows = controlIds.map((id) => codex.tools[id])
+    const enforcedControls = controlRows.filter((tool) => tool.enforcedByAgentBench).length
+
+    // Codex: shell+file+creative are AGBench-enforced, mcpTools(provider) and
+    // networkAccess(allow/none) are not -> 3/5, unchanged by the new rows.
+    expect(controlRows.length).toBe(5)
+    expect(enforcedControls).toBe(3)
+    // delegate is allowed/enforced as a DISPLAY row but lives outside the tally.
+    expect(codex.tools.delegate.state).toBe('available')
+    expect(codex.tools.delegate.enforcedByAgentBench).toBe(true)
+    expect(controlIds).not.toContain('delegate')
+    expect(controlIds).not.toContain('elicit')
   })
 })
diff --git a/src/main/ProviderCapabilities.ts b/src/main/ProviderCapabilities.ts
index 168b89c7..9b0bd119 100644
--- a/src/main/ProviderCapabilities.ts
+++ b/src/main/ProviderCapabilities.ts
@@ -1,6 +1,5 @@
 import type {
   AgenticNetworkPolicy,
-  AgenticServiceId,
   AgenticServicePolicy,
   AgenticServicesSettings,
   AppSettings,
@@ -24,7 +23,38 @@ const TOOLING_LABELS: Record<ProviderToolingCapabilityId, string> = {
   fileChanges: 'File changes',
   mcpTools: 'MCP and tool calls',
   creativeApps: 'Creative app tools',
-  networkAccess: 'Network access'
+  networkAccess: 'Network access',
+  elicit: 'Ask the user',
+  delegate: 'Delegate to sub-thread'
+}
+
+/** The original five "functional control" rows whose AGBench-enforcement is
+ * tallied across the renderer (ToolingContractCard `enforcedCount`,
+ * SettingsPanel contract hint) and main (ProviderPreflightService delegated
+ * chip, DelegationAudit policy label). The `elicit` / `delegate` rows are
+ * DISPLAY-only additions and are intentionally excluded from these tallies so
+ * promoting `subThreadDelegation` to a first-class row does not double-count
+ * against its existing settings gate or inflate the enforced/delegated counts.
+ * Consumers that tally enforcement MUST iterate this list rather than
+ * `Object.values(contract.tools)`. */
+export const TOOLING_CONTROL_IDS = [
+  'shellCommands',
+  'fileChanges',
+  'mcpTools',
+  'creativeApps',
+  'networkAccess'
+] as const satisfies readonly ProviderToolingCapabilityId[]
+
+export type ToolingControlId = (typeof TOOLING_CONTROL_IDS)[number]
+
+/** The five functional-control rows of a contract, in canonical order. Tally
+ * sites (enforced/delegated counts) MUST use this rather than
+ * `Object.values(contract.tools)` so the DISPLAY-only `elicit` / `delegate`
+ * rows never shift the enforced/delegated numerator or denominator. */
+export function toolingControlRows(
+  tools: Record<ProviderToolingCapabilityId, ProviderToolingCapability>
+): ProviderToolingCapability[] {
+  return TOOLING_CONTROL_IDS.map((id) => tools[id])
 }
 
 interface BuildProviderCapabilityContractInput {
@@ -59,7 +89,7 @@ function serviceRequiresApproval(policy?: AgenticServicePolicy): boolean {
 }
 
 function serviceCapability(
-  id: Exclude<AgenticServiceId, 'subThreadDelegation'>,
+  id: ProviderToolingCapabilityId,
   policy: AgenticServicePolicy | undefined,
   source: ProviderToolingCapability['source'],
   tools: string[],
@@ -80,7 +110,7 @@ function serviceCapability(
 }
 
 function unavailableCapability(
-  id: Exclude<AgenticServiceId, 'subThreadDelegation'>,
+  id: ProviderToolingCapabilityId,
   source: ProviderToolingCapability['source'],
   details: string
 ): ProviderToolingCapability {
@@ -98,7 +128,7 @@ function unavailableCapability(
 }
 
 function delegatedCapability(
-  id: Exclude<AgenticServiceId, 'subThreadDelegation'>,
+  id: ProviderToolingCapabilityId,
   policy: AgenticServicePolicy | undefined,
   tools: string[],
   details: string
@@ -117,6 +147,82 @@ function delegatedCapability(
   }
 }
 
+/** `ask_user_question` (the `ui_elicitation` tool class) lets a participant
+ * ask the user a clarifying question mid-run. It is a universally
+ * auto-allowed AGBench MCP tool (see AgentbenchMcpTools `ask_user_question`),
+ * so it carries no service-policy gate — it is reachable whenever the AGBench
+ * MCP bridge is advertised to the provider, and provider-managed otherwise.
+ * DISPLAY-only row: excluded from the enforced/delegated tallies. */
+function elicitCapability(
+  source: ProviderToolingCapability['source'],
+  mcpAvailable: boolean,
+  details: string,
+  unavailableDetails?: string
+): ProviderToolingCapability {
+  const bridgeBacked = source === 'bridge' || source === 'agentbench'
+  if (bridgeBacked && !mcpAvailable) {
+    return unavailableCapability('elicit', source, unavailableDetails || details)
+  }
+  return {
+    id: 'elicit',
+    label: TOOLING_LABELS.elicit,
+    state: bridgeBacked ? 'available' : 'delegated',
+    source,
+    enforcedByAgentBench: bridgeBacked,
+    enforcement: bridgeBacked ? source : 'provider',
+    requiresApproval: false,
+    tools: ['ask_user_question'],
+    details
+  }
+}
+
+/** `delegate_to_subthread` (`subThreadDelegation`) lets a participant spawn a
+ * cross-provider sub-thread. It IS gated by the existing
+ * `agenticServices.subThreadDelegation` settings policy (see the
+ * SettingsPanel tool→service map). Promoting it to a first-class row must NOT
+ * change that gate or the enforcement tallies, so this is a DISPLAY-only row
+ * excluded from `TOOLING_CONTROL_IDS`; the gate semantics stay in
+ * PermissionService / EffectiveRunPermissions exactly as before. Its state is
+ * derived from the same `subThreadDelegation` policy the gate already reads. */
+function delegateCapability(
+  source: ProviderToolingCapability['source'],
+  policy: AgenticServicePolicy | undefined,
+  mcpAvailable: boolean,
+  details: string,
+  unavailableDetails?: string
+): ProviderToolingCapability {
+  const bridgeBacked = source === 'bridge' || source === 'agentbench'
+  if (bridgeBacked && !mcpAvailable) {
+    return unavailableCapability('delegate', source, unavailableDetails || details)
+  }
+  if (!bridgeBacked) {
+    return {
+      id: 'delegate',
+      label: TOOLING_LABELS.delegate,
+      state: policy === 'deny' ? 'blocked' : 'delegated',
+      source,
+      enforcedByAgentBench: false,
+      enforcement: policy === 'deny' ? 'best_effort' : 'provider',
+      policy,
+      requiresApproval: policy !== 'allow' && policy !== 'deny',
+      tools: ['delegate_to_subthread'],
+      details
+    }
+  }
+  return {
+    id: 'delegate',
+    label: TOOLING_LABELS.delegate,
+    state: serviceState(policy),
+    source,
+    enforcedByAgentBench: true,
+    enforcement: source,
+    policy,
+    requiresApproval: serviceRequiresApproval(policy),
+    tools: ['delegate_to_subthread'],
+    details
+  }
+}
+
 function networkCapability(policy?: AgenticNetworkPolicy): ProviderToolingCapability {
   return {
     id: 'networkAccess',
@@ -371,6 +477,8 @@ export function buildProviderCapabilityContract({
   let shellCommands: ProviderToolingCapability
   let fileChanges: ProviderToolingCapability
   let mcpTools: ProviderToolingCapability
+  let elicit: ProviderToolingCapability
+  let delegate: ProviderToolingCapability
   let mcp: ProviderMcpCapability
 
   if (provider === 'gemini') {
@@ -397,6 +505,17 @@ export function buildProviderCapabilityContract({
         ['read_file', 'list_directory'],
         'Gemini uses the AGBench MCP bridge for workspace read/list tools.'
       )
+      elicit = elicitCapability(
+        'bridge',
+        true,
+        'Gemini can ask the user a clarifying question through the AGBench MCP bridge (auto-allowed).'
+      )
+      delegate = delegateCapability(
+        'bridge',
+        services.subThreadDelegation,
+        true,
+        'Gemini can spawn cross-provider sub-threads through the AGBench MCP bridge, gated by the sub-thread delegation setting.'
+      )
     } else {
       shellCommands = unavailableCapability(
         'shellCommands',
@@ -413,6 +532,17 @@ export function buildProviderCapabilityContract({
         'bridge',
         'AGBench MCP tools are not advertised to Gemini until the bridge is enabled, installed, and available.'
       )
+      elicit = elicitCapability(
+        'bridge',
+        false,
+        'Gemini cannot ask the user through AGBench until the MCP bridge is enabled, installed, and available.'
+      )
+      delegate = delegateCapability(
+        'bridge',
+        services.subThreadDelegation,
+        false,
+        'Gemini cannot delegate to sub-threads through AGBench until the MCP bridge is enabled, installed, and available.'
+      )
       warnings.push(
         warning(
           mcp.enabled ? 'gemini-bridge-unavailable' : 'gemini-bridge-disabled',
@@ -449,6 +579,17 @@ export function buildProviderCapabilityContract({
       'Codex file approvals and diffs are routed through AGBench.'
     )
     mcpTools = serviceCapability('mcpTools', services.mcpTools, 'provider', mcp.tools, mcp.message)
+    elicit = elicitCapability(
+      'agentbench',
+      true,
+      'Codex can ask the user a clarifying question through the AGBench MCP tool surface (auto-allowed).'
+    )
+    delegate = delegateCapability(
+      'agentbench',
+      services.subThreadDelegation,
+      true,
+      'Codex can spawn cross-provider sub-threads through AGBench, gated by the sub-thread delegation setting.'
+    )
     if (settings.codexSandboxFallback === 'ask_rerun') {
       warnings.push(
         warning(
@@ -485,6 +626,33 @@ export function buildProviderCapabilityContract({
             mcp.tools,
             mcp.message || `${label} MCP status is unavailable.`
           )
+    if (provider === 'claude' || provider === 'kimi') {
+      elicit = elicitCapability(
+        'bridge',
+        mcp.available,
+        `${label} can ask the user a clarifying question through the AGBench MCP bridge (auto-allowed).`,
+        `AGBench cannot route ${label} user questions until the AGBench MCP bridge is available.`
+      )
+      delegate = delegateCapability(
+        'bridge',
+        services.subThreadDelegation,
+        mcp.available,
+        `${label} can spawn cross-provider sub-threads through the AGBench MCP bridge, gated by the sub-thread delegation setting.`,
+        `AGBench cannot route ${label} sub-thread delegation until the AGBench MCP bridge is available.`
+      )
+    } else {
+      elicit = elicitCapability(
+        'provider',
+        false,
+        `${label} user-question handling is delegated to the provider CLI; AGBench does not advertise its elicitation tool here yet.`
+      )
+      delegate = delegateCapability(
+        'provider',
+        services.subThreadDelegation,
+        false,
+        `${label} sub-thread delegation is delegated to the provider CLI; AGBench does not advertise its delegation tool here yet.`
+      )
+    }
     warnings.push(
       warning(
         `${provider}-provider-managed-tools`,
@@ -532,7 +700,9 @@ export function buildProviderCapabilityContract({
       fileChanges,
       mcpTools,
       creativeApps,
-      networkAccess
+      networkAccess,
+      elicit,
+      delegate
     },
     approvals: approvalContract(provider, requestedMode, effectiveMode),
     mcp,
diff --git a/src/main/ProviderPreflightService.test.ts b/src/main/ProviderPreflightService.test.ts
index 9503bb6a..50138d2d 100644
--- a/src/main/ProviderPreflightService.test.ts
+++ b/src/main/ProviderPreflightService.test.ts
@@ -66,6 +66,26 @@ function contract(partial: Partial<ProviderCapabilityContract> = {}): ProviderCa
         enforcement: 'none',
         requiresApproval: false,
         tools: []
+      },
+      elicit: {
+        id: 'elicit',
+        label: 'Ask the user',
+        state: 'available',
+        source: 'agentbench',
+        enforcedByAgentBench: true,
+        enforcement: 'agentbench',
+        requiresApproval: false,
+        tools: ['ask_user_question']
+      },
+      delegate: {
+        id: 'delegate',
+        label: 'Delegate to sub-thread',
+        state: 'gated',
+        source: 'agentbench',
+        enforcedByAgentBench: true,
+        enforcement: 'agentbench',
+        requiresApproval: true,
+        tools: ['delegate_to_subthread']
       }
     },
     approvals: {
diff --git a/src/main/ProviderPreflightService.ts b/src/main/ProviderPreflightService.ts
index 3aeff240..323fc3d5 100644
--- a/src/main/ProviderPreflightService.ts
+++ b/src/main/ProviderPreflightService.ts
@@ -4,6 +4,7 @@ import type {
   ProviderCapabilityWarning,
   ProviderId
 } from './store/types'
+import { toolingControlRows } from './ProviderCapabilities'
 
 export type ProviderPreflightState = 'ready' | 'repairable' | 'blocked'
 export type ProviderPreflightRepairAction =
@@ -97,16 +98,18 @@ export class ProviderPreflightService {
       }
     }
 
-    const delegatedTools = Object.values(contract.tools).filter(
-      (tool) => !tool.enforcedByAgentBench
-    )
+    // Tally over the five functional-control rows only. The DISPLAY-only
+    // elicit/delegate rows are intentionally excluded so promoting
+    // subThreadDelegation to a row never inflates this count.
+    const controlRows = toolingControlRows(contract.tools)
+    const delegatedTools = controlRows.filter((tool) => !tool.enforcedByAgentBench)
     if (delegatedTools.length > 0) {
       chips.unshift(
         warning(
           `${input.provider}-delegated-enforcement`,
           'info',
           'Provider-managed controls',
-          `${delegatedTools.length}/${Object.values(contract.tools).length} tooling controls are delegated or best-effort for ${label}.`
+          `${delegatedTools.length}/${controlRows.length} tooling controls are delegated or best-effort for ${label}.`
         )
       )
     }
diff --git a/src/main/UpdateService.test.ts b/src/main/UpdateService.test.ts
index f5bf0aca..03494803 100644
--- a/src/main/UpdateService.test.ts
+++ b/src/main/UpdateService.test.ts
@@ -23,6 +23,13 @@ vi.mock('electron-updater', () => ({
 
 import { UpdateService } from './UpdateService'
 
+function emitUpdaterEvent(name: string, payload?: unknown): void {
+  const handler = mockAutoUpdater.on.mock.calls.find((call) => call[0] === name)?.[1]
+  if (typeof handler === 'function') {
+    handler(payload)
+  }
+}
+
 describe('UpdateService', () => {
   beforeEach(() => {
     mockAutoUpdater.checkForUpdates.mockClear()
@@ -170,6 +177,74 @@ describe('UpdateService', () => {
     expect(new Date(snap.lastCheckedAt!).getTime()).toBeGreaterThan(0)
   })
 
+  it('captures release metadata when an update is available', () => {
+    const svc = new UpdateService()
+    svc.configure({ channel: 'stable', enabled: true })
+    emitUpdaterEvent('update-available', {
+      version: '1.0.73',
+      files: [],
+      path: 'AGBench-1.0.73.dmg',
+      sha512: 'abc',
+      releaseName: 'AGBench 1.0.73',
+      releaseDate: '2026-06-04T12:00:00.000Z',
+      releaseNotes: 'New updater UI.'
+    })
+
+    expect(svc.snapshot()).toMatchObject({
+      status: 'available',
+      latestVersion: '1.0.73',
+      releaseName: 'AGBench 1.0.73',
+      releaseDate: '2026-06-04T12:00:00.000Z',
+      releaseNotes: 'New updater UI.',
+      releasePageUrl: 'https://github.com/boggspa/AGBench/releases/tag/v1.0.73'
+    })
+  })
+
+  it('preserves full changelog arrays when an update is downloaded', () => {
+    const svc = new UpdateService()
+    svc.configure({ channel: 'stable', enabled: true })
+    emitUpdaterEvent('update-downloaded', {
+      version: '1.0.74',
+      files: [],
+      path: 'AGBench-1.0.74.dmg',
+      sha512: 'abc',
+      releaseDate: '2026-06-04T13:00:00.000Z',
+      releaseNotes: [
+        { version: '1.0.74', note: 'Second update.' },
+        { version: '1.0.73', note: null }
+      ]
+    })
+
+    expect(svc.snapshot()).toMatchObject({
+      status: 'downloaded',
+      latestVersion: '1.0.74',
+      releaseNotes: [
+        { version: '1.0.74', note: 'Second update.' },
+        { version: '1.0.73', note: null }
+      ]
+    })
+  })
+
+  it('clears stale release metadata when no update is available', () => {
+    const svc = new UpdateService()
+    svc.configure({ channel: 'stable', enabled: true })
+    emitUpdaterEvent('update-available', {
+      version: '1.0.73',
+      files: [],
+      path: 'AGBench-1.0.73.dmg',
+      sha512: 'abc',
+      releaseDate: '2026-06-04T12:00:00.000Z',
+      releaseNotes: 'New updater UI.'
+    })
+    emitUpdaterEvent('update-not-available')
+
+    expect(svc.snapshot()).toMatchObject({
+      status: 'not-available',
+      latestVersion: undefined,
+      releaseNotes: undefined
+    })
+  })
+
   it('reconfigure to debug after enabled returns to disabled', () => {
     const svc = new UpdateService()
     svc.configure({ channel: 'stable', enabled: true })
diff --git a/src/main/UpdateService.ts b/src/main/UpdateService.ts
index 11bf82f7..f7d9abd5 100644
--- a/src/main/UpdateService.ts
+++ b/src/main/UpdateService.ts
@@ -4,7 +4,11 @@ import {
   type UpdateInfo,
   type ProgressInfo
 } from 'electron-updater'
-import type { ProductUpdateChannel } from './store/types'
+import type {
+  ProductUpdateChannel,
+  ProductUpdateReleaseNoteInfo,
+  ProductUpdateReleaseNotes
+} from './store/types'
 
 /**
  * UpdateService — Phase G2 wrapper around `electron-updater`.
@@ -61,6 +65,10 @@ export interface UpdateStateSnapshot {
   enabled: boolean
   channel: ProductUpdateChannel
   latestVersion?: string
+  releaseName?: string
+  releaseDate?: string
+  releaseNotes?: ProductUpdateReleaseNotes
+  releasePageUrl?: string
   downloadProgress?: ProgressInfo
   errorMessage?: string
   /** When the last manual or automatic check was attempted. ISO. */
@@ -73,6 +81,10 @@ export class UpdateService {
   private channel: ProductUpdateChannel = 'debug'
   private status: UpdateStatus = 'disabled'
   private latestVersion: string | undefined
+  private releaseName: string | undefined
+  private releaseDate: string | undefined
+  private releaseNotes: ProductUpdateReleaseNotes | undefined
+  private releasePageUrl: string | undefined
   private downloadProgress: ProgressInfo | undefined
   private errorMessage: string | undefined
   private lastCheckedAt: string | undefined
@@ -98,6 +110,9 @@ export class UpdateService {
     this.channel = args.channel
     if (!args.enabled || args.channel === 'debug') {
       this.status = 'disabled'
+      this.downloadProgress = undefined
+      this.errorMessage = undefined
+      this.clearReleaseMetadata()
       this.publish()
       return
     }
@@ -112,6 +127,9 @@ export class UpdateService {
     autoUpdater.autoDownload = false
     autoUpdater.autoInstallOnAppQuit = false
     this.status = 'idle'
+    this.downloadProgress = undefined
+    this.errorMessage = undefined
+    this.clearReleaseMetadata()
     this.publish()
   }
 
@@ -123,6 +141,8 @@ export class UpdateService {
     this.status = 'checking'
     this.lastCheckedAt = new Date().toISOString()
     this.errorMessage = undefined
+    this.downloadProgress = undefined
+    this.clearReleaseMetadata()
     this.publish()
     try {
       const result = await autoUpdater.checkForUpdates()
@@ -171,6 +191,10 @@ export class UpdateService {
       enabled: this.status !== 'disabled',
       channel: this.channel,
       latestVersion: this.latestVersion,
+      releaseName: this.releaseName,
+      releaseDate: this.releaseDate,
+      releaseNotes: this.releaseNotes,
+      releasePageUrl: this.releasePageUrl,
       downloadProgress: this.downloadProgress,
       errorMessage: this.errorMessage,
       lastCheckedAt: this.lastCheckedAt
@@ -195,11 +219,12 @@ export class UpdateService {
     })
     autoUpdater.on('update-available', (info) => {
       this.status = 'available'
-      this.latestVersion = info.version
+      this.applyUpdateInfo(info)
       this.publish()
     })
     autoUpdater.on('update-not-available', () => {
       this.status = 'not-available'
+      this.clearReleaseMetadata()
       this.publish()
     })
     autoUpdater.on('error', (err) => {
@@ -212,12 +237,30 @@ export class UpdateService {
     })
     autoUpdater.on('update-downloaded', (info) => {
       this.status = 'downloaded'
-      this.latestVersion = info.version
+      this.applyUpdateInfo(info)
       this.downloadProgress = undefined
       this.publish()
     })
   }
 
+  private applyUpdateInfo(info: UpdateInfo): void {
+    this.latestVersion = info.version
+    this.releaseName = info.releaseName || undefined
+    this.releaseDate = info.releaseDate || undefined
+    this.releaseNotes = normalizeReleaseNotes(info.releaseNotes)
+    this.releasePageUrl = info.version
+      ? `https://github.com/boggspa/AGBench/releases/tag/v${info.version}`
+      : undefined
+  }
+
+  private clearReleaseMetadata(): void {
+    this.latestVersion = undefined
+    this.releaseName = undefined
+    this.releaseDate = undefined
+    this.releaseNotes = undefined
+    this.releasePageUrl = undefined
+  }
+
   private handleError(message: string): void {
     this.status = 'error'
     this.errorMessage = message
@@ -239,3 +282,22 @@ export class UpdateService {
     }
   }
 }
+
+function normalizeReleaseNotes(
+  notes: UpdateInfo['releaseNotes']
+): ProductUpdateReleaseNotes | undefined {
+  if (typeof notes === 'string') return notes
+  if (!Array.isArray(notes)) return undefined
+  const normalized = notes
+    .map((note): ProductUpdateReleaseNoteInfo | null => {
+      if (!note || typeof note.version !== 'string' || !note.version.trim()) {
+        return null
+      }
+      return {
+        version: note.version.trim(),
+        note: typeof note.note === 'string' ? note.note : null
+      }
+    })
+    .filter((note): note is ProductUpdateReleaseNoteInfo => note !== null)
+  return normalized.length > 0 ? normalized : undefined
+}
diff --git a/src/main/index.ts b/src/main/index.ts
index ec239c2d..c97d9ab2 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -88,6 +88,7 @@ import { RunCoordinator } from './services/RunCoordinator'
 import { RunQueueService } from './services/RunQueueService'
 import { SettingsService } from './services/SettingsService'
 import { WorkspaceService } from './services/WorkspaceService'
+import { GitService } from './services/GitService'
 import { AppShellStatsService } from './services/AppShellStatsService'
 import { getWorkspaceActivitySnapshot } from './WorkspaceActivityService'
 import { getCurrentFxRates, refreshFxRates, startFxRateScheduler } from './services/FxRateService'
@@ -153,6 +154,8 @@ import {
   ProductCrashInput,
   ProductDiagnosticsExportResult,
   ProductOperationsStatus,
+  ProductChangelogSnapshot,
+  ProductUpdateChangelog,
   RuntimeProfile,
   HandoffCard,
   HandoffCardFilter,
@@ -4045,6 +4048,30 @@ function claudeProgrammaticUsageWarning(runtime: 'sdk' | 'cli-print', usesApiKey
   return `${runtimeLabel} is a programmatic Claude path. Anthropic says programmatic Claude usage uses separate Agent SDK credit from 2026-06-15, not the normal interactive Claude Code subscription limit. Use interactive Claude in a terminal when you need native Claude Code subscription-limit behavior.`
 }
 
+// Recover a single tool-call identifier from a bridge tool payload, regardless
+// of which field the provider populates. A `ToolCall` notification keys it `id`;
+// the matching `ToolResult` echoes it under `tool_call_id` (and some shapes use
+// `call_id` / `tool_id`). Resolving both branches through the SAME ordered
+// lookup guarantees the call and its result share one id, so the renderer
+// coalesces them into one inline card instead of stacking each event. Mirrors
+// the multi-field lookup Grok's mapper already uses (GrokStreamingJson). Falls
+// back to a unique generated id only when no identifier is present at all (which
+// keeps two genuinely id-less calls from merging).
+function cliProviderToolId(payload: Record<string, unknown>, prefix: string): string {
+  const candidates = [
+    payload.tool_call_id,
+    payload.toolCallId,
+    payload.id,
+    payload.tool_id,
+    payload.toolId,
+    payload.call_id
+  ]
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) return candidate.trim()
+  }
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+}
+
 function emitCliProviderToolEvent(state: CliProviderStreamState, event: unknown): void {
   if (!isRecord(event)) return
   const params = nestedRecord(event, 'params')
@@ -4094,23 +4121,34 @@ function emitCliProviderToolEvent(state: CliProviderStreamState, event: unknown)
 
   if (event.method === 'event' && params.type === 'ToolCall') {
     const toolFunction = nestedRecord(payload, 'function')
+    // Kimi tool calls must COALESCE with their matching ToolResult into one
+    // inline card (the way Codex/Claude/Grok do). The renderer pairs a result
+    // back to its call by `tool_id`, so the call and the result MUST resolve to
+    // the SAME stable id. Kimi keys the call identifier as `id` here, but the
+    // result echoes it under `tool_call_id` (see the ToolResult branch + the
+    // wire-protocol approval echo in ApprovalService, `request_id: payload.id`).
+    // Mirror Grok's multi-field id lookup (GrokStreamingJson) so the same value
+    // is recovered regardless of which field Kimi populates on each side.
+    const toolCallId = cliProviderToolId(payload, 'tool')
+    // Moonshot/OpenAI function-calling sends `function.arguments` as a
+    // JSON-ENCODED STRING, so the old `isRecord(...)` check dropped them to `{}`
+    // — that's why the card never showed the target filename. normalizeMcpTool-
+    // Arguments parses the string (or passes an object through) so ToolParser
+    // can surface `file_path`/`path` in the card label.
+    const rawToolArgs = toolFunction.arguments ?? payload.arguments
     sendAgentCompatLine(
       state.sender,
       state.provider,
       {
         type: 'tool_use',
-        tool_id: typeof payload.id === 'string' ? payload.id : `tool-${Date.now()}`,
+        tool_id: toolCallId,
         tool_name:
           typeof toolFunction.name === 'string'
             ? toolFunction.name
             : typeof payload.name === 'string'
               ? payload.name
               : 'tool',
-        parameters: isRecord(toolFunction.arguments)
-          ? toolFunction.arguments
-          : isRecord(payload.arguments)
-            ? payload.arguments
-            : {},
+        parameters: normalizeMcpToolArguments(rawToolArgs),
         provider: state.provider
       },
       state
@@ -4119,13 +4157,15 @@ function emitCliProviderToolEvent(state: CliProviderStreamState, event: unknown)
 
   if (event.method === 'event' && params.type === 'ToolResult') {
     const returnValue = nestedRecord(payload, 'return_value')
+    // Same stable-id resolution as the ToolCall branch above so the result
+    // pairs back to its call card instead of stacking as a fresh orphan.
+    const toolResultId = cliProviderToolId(payload, 'tool')
     sendAgentCompatLine(
       state.sender,
       state.provider,
       {
         type: 'tool_result',
-        tool_id:
-          typeof payload.tool_call_id === 'string' ? payload.tool_call_id : `tool-${Date.now()}`,
+        tool_id: toolResultId,
         status: returnValue.is_error ? 'error' : 'success',
         output: contentPartsToText(returnValue.output || returnValue.message || ''),
         provider: state.provider
@@ -10188,7 +10228,7 @@ async function getProductOperationsStatus(): Promise<ProductOperationsStatus> {
   const recentCrashes = AppStore.getProductCrashes({ limit: 20 })
 
   return buildProductOperationsStatus({
-    updateChannel: settings.updateChannel || 'debug',
+    updateChannel: settings.updateChannel || 'stable',
     appName: app.getName() || 'AGBench',
     appVersion: app.getVersion() || 'unknown',
     isPackaged: app.isPackaged,
@@ -13147,6 +13187,31 @@ function resolveNativeVibrancy(
   return useNativeGlass ? NATIVE_GLASS_VIBRANCY : undefined
 }
 
+/*
+ * Per-theme opaque backdrop for popout BrowserWindows. Before React
+ * mounts (and applies `data-theme`), the OS paints `backgroundColor`.
+ * A hardcoded `#1e1e1e` flashed a dark slab on the light themes
+ * (light/citrus/mist/sage/alabaster), which is jarring. We mirror
+ * each light theme's `--app-bg` so the pre-paint matches the rendered
+ * surface; every dark theme (and `system`/`dark`, which the renderer
+ * resolves to the dark `:root`) keeps the original `#1e1e1e`.
+ * Returns undefined when a glass window is used (caller passes the
+ * transparent backdrop in that case).
+ */
+const LIGHT_THEME_POPOUT_BACKDROPS: Record<string, string> = {
+  light: '#f4f6f8',
+  citrus: '#f4f6f8',
+  mist: '#eef4f6',
+  sage: '#f0f5f0',
+  alabaster: '#f4f3ef'
+}
+
+function resolvePopoutBackgroundColor(useGlassWindow: boolean): string {
+  if (useGlassWindow) return '#00000000'
+  const theme = AppStore.getSettings().themeAppearance
+  return LIGHT_THEME_POPOUT_BACKDROPS[theme] ?? '#1e1e1e'
+}
+
 function resolveWorkspaceChild(workspace: string, filePath: string): string {
   const workspaceRoot = resolve(workspace)
   const targetPath = isAbsolute(filePath) ? resolve(filePath) : resolve(workspaceRoot, filePath)
@@ -13671,7 +13736,7 @@ async function openWorkspacePopout(input: unknown): Promise<{ ok: true }> {
         : undefined,
     visualEffectState: 'active',
     transparent: false,
-    backgroundColor: useGlassWindow ? '#00000000' : '#1e1e1e',
+    backgroundColor: resolvePopoutBackgroundColor(useGlassWindow),
     ...(process.platform === 'linux' ? { icon } : {}),
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
@@ -14502,6 +14567,8 @@ if (isGeminiMcpBridgeProcess) {
       }
     })
 
+    const gitService = new GitService()
+
     // Phase G2: auto-update wiring. Default-off (env override available).
     // Only enabled in packaged builds AND when updateChannel != 'debug'.
     // The `AGBENCH_AUTO_UPDATE` env var forces enable/disable for
@@ -14529,9 +14596,35 @@ if (isGeminiMcpBridgeProcess) {
       channel: initialSettings.updateChannel,
       enabled: autoUpdateEnabled
     })
+    const updateSnapshotToChangelog = (
+      snapshot: UpdateStateSnapshot
+    ): ProductUpdateChangelog | undefined => {
+      if (!snapshot.latestVersion) return undefined
+      return {
+        version: snapshot.latestVersion,
+        ...(snapshot.releaseName ? { releaseName: snapshot.releaseName } : {}),
+        ...(snapshot.releaseDate ? { releaseDate: snapshot.releaseDate } : {}),
+        ...(snapshot.releaseNotes ? { releaseNotes: snapshot.releaseNotes } : {})
+      }
+    }
+    const changelogSnapshot = (): ProductChangelogSnapshot => {
+      const settings = AppStore.getSettings()
+      return {
+        currentVersion: app.getVersion() || 'unknown',
+        lastSeenChangelogVersion: settings.lastSeenChangelogVersion,
+        pendingUpdateChangelog: settings.pendingUpdateChangelog,
+        latestUpdateChangelog: updateSnapshotToChangelog(updateService.snapshot())
+      }
+    }
     // Broadcast snapshot changes to the renderer so the Settings panel
     // can show live status.
     updateService.subscribe((snapshot: UpdateStateSnapshot) => {
+      if (snapshot.status === 'downloaded') {
+        const pendingUpdateChangelog = updateSnapshotToChangelog(snapshot)
+        if (pendingUpdateChangelog) {
+          AppStore.updateSettings({ pendingUpdateChangelog })
+        }
+      }
       try {
         mainWindow?.webContents.send('update-status-changed', snapshot)
       } catch {
@@ -14587,6 +14680,18 @@ if (isGeminiMcpBridgeProcess) {
       updateService.quitAndInstall()
       return updateService.snapshot()
     })
+    ipcMain.handle('changelog-snapshot', () => changelogSnapshot())
+    ipcMain.handle('mark-changelog-seen', (_, version: string) => {
+      const normalizedVersion = typeof version === 'string' ? version.trim() : ''
+      if (!normalizedVersion) return changelogSnapshot()
+      AppStore.updateSettings({ lastSeenChangelogVersion: normalizedVersion })
+      return changelogSnapshot()
+    })
+    if (updateService.snapshot().enabled) {
+      setTimeout(() => {
+        void updateService.checkForUpdates()
+      }, 3000)
+    }
 
     ipcMain.handle(
       'bridge-finalize-pairing',
@@ -15675,110 +15780,112 @@ if (isGeminiMcpBridgeProcess) {
       }
     })
 
+    const gitPayloadPath = (payload?: { workspacePath?: string; repoPath?: string }) =>
+      typeof payload?.repoPath === 'string' && payload.repoPath.trim()
+        ? payload.repoPath
+        : payload?.workspacePath || ''
+
+    ipcMain.handle(
+      'git:snapshot',
+      async (_event, payload?: { workspacePath?: string; repoPath?: string }) =>
+        gitService.snapshot(gitPayloadPath(payload))
+    )
+
+    ipcMain.handle(
+      'git:stage',
+      async (
+        _event,
+        payload?: {
+          workspacePath?: string
+          repoPath?: string
+          paths?: string[]
+          all?: boolean
+          update?: boolean
+          patch?: string
+        }
+      ) =>
+        gitService.stage({
+          repoPath: gitPayloadPath(payload),
+          paths: payload?.paths,
+          all: payload?.all,
+          update: payload?.update,
+          patch: payload?.patch
+        })
+    )
+
+    ipcMain.handle(
+      'git:commit',
+      async (
+        _event,
+        payload?: {
+          workspacePath?: string
+          repoPath?: string
+          message?: string
+        }
+      ) =>
+        gitService.commit({
+          repoPath: gitPayloadPath(payload),
+          message: payload?.message || ''
+        })
+    )
+
+    ipcMain.handle(
+      'git:push',
+      async (
+        _event,
+        payload?: {
+          workspacePath?: string
+          repoPath?: string
+          setUpstream?: boolean
+          remote?: string
+        }
+      ) =>
+        gitService.push({
+          repoPath: gitPayloadPath(payload),
+          setUpstream: payload?.setUpstream,
+          remote: payload?.remote
+        })
+    )
+
+    ipcMain.handle(
+      'github:pr-status',
+      async (_event, payload?: { workspacePath?: string; repoPath?: string }) =>
+        gitService.pullRequestStatus(gitPayloadPath(payload))
+    )
+
+    ipcMain.handle(
+      'github:pr-readiness',
+      async (_event, payload?: { workspacePath?: string; repoPath?: string }) =>
+        gitService.pullRequestReadiness(gitPayloadPath(payload))
+    )
+
     ipcMain.handle(
       'create-github-pr',
       async (
         _event,
         payload?: {
           workspacePath?: string
+          repoPath?: string
           title?: string
           body?: string
           draft?: boolean
           openInBrowser?: boolean
         }
       ) => {
-        const requestedPath = expandHomePath(payload?.workspacePath || '')
-        if (!requestedPath) {
-          return { ok: false, error: 'A workspace path is required to open a pull request.' }
-        }
-        try {
-          const stat = await fs.stat(requestedPath)
-          if (!stat.isDirectory()) {
-            return { ok: false, error: 'Workspace path is not a directory.' }
+        const result = await gitService.createPullRequest({
+          repoPath: gitPayloadPath(payload),
+          title: payload?.title,
+          body: payload?.body,
+          draft: payload?.draft
+        })
+        if (result.ok) {
+          const url = result.data.url
+          if (url && payload?.openInBrowser !== false) {
+            shell.openExternal(url).catch(() => {})
           }
-        } catch {
-          return { ok: false, error: 'Workspace path does not exist on disk.' }
-        }
-        const args = ['pr', 'create']
-        const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
-        const body = typeof payload?.body === 'string' ? payload.body.trim() : ''
-        if (title) {
-          args.push('--title', title)
-        }
-        if (body) {
-          args.push('--body', body)
+          return { ok: true, ...result.data }
         }
-        if (!title && !body) {
-          args.push('--fill')
-        }
-        if (payload?.draft) {
-          args.push('--draft')
-        }
-        return await new Promise<{ ok: boolean; url?: string; error?: string; stderr?: string }>(
-          (resolve) => {
-            let stdout = ''
-            let stderr = ''
-            let settled = false
-            let child: ReturnType<typeof spawn>
-            try {
-              child = spawn('gh', args, {
-                cwd: requestedPath,
-                env: { ...process.env },
-                stdio: ['ignore', 'pipe', 'pipe']
-              })
-            } catch (error) {
-              resolve({
-                ok: false,
-                error: `Failed to launch \`gh\`: ${error instanceof Error ? error.message : String(error)}`
-              })
-              return
-            }
-            const settle = (result: {
-              ok: boolean
-              url?: string
-              error?: string
-              stderr?: string
-            }) => {
-              if (settled) return
-              settled = true
-              resolve(result)
-            }
-            child.stdout?.on('data', (chunk: Buffer) => {
-              stdout += chunk.toString('utf8')
-            })
-            child.stderr?.on('data', (chunk: Buffer) => {
-              stderr += chunk.toString('utf8')
-            })
-            child.on('error', (error) => {
-              const message =
-                (error as NodeJS.ErrnoException)?.code === 'ENOENT'
-                  ? 'GitHub CLI (`gh`) is not installed or not on PATH. Install it from https://cli.github.com.'
-                  : `Failed to launch \`gh\`: ${error.message}`
-              settle({ ok: false, error: message })
-            })
-            child.on('close', (code) => {
-              const trimmedOut = stdout.trim()
-              const trimmedErr = stderr.trim()
-              if (code === 0) {
-                const url = trimmedOut.match(/https?:\/\/[^\s]+/)?.[0]
-                if (url && payload?.openInBrowser !== false) {
-                  shell.openExternal(url).catch(() => {})
-                }
-                settle({ ok: true, url, stderr: trimmedErr || undefined })
-              } else {
-                settle({
-                  ok: false,
-                  error: trimmedErr || trimmedOut || `\`gh pr create\` exited with code ${code}.`,
-                  stderr: trimmedErr || undefined
-                })
-              }
-            })
-            setTimeout(
-              () => settle({ ok: false, error: '`gh pr create` timed out after 30s.' }),
-              30_000
-            )
-          }
-        )
+        return result
       }
     )
 
@@ -16692,7 +16799,17 @@ if (isGeminiMcpBridgeProcess) {
 
     ipcMain.handle(
       'respond-agent-approval',
-      async (_, requestId: string, action: AgentApprovalAction) => {
+      async (_, requestId: string, action: AgentApprovalAction, intentNote?: string) => {
+        // Order-4 — optional one-line "why" note captured in the
+        // approval card. Trim + cap defensively (the renderer already
+        // trims, but the IPC boundary is untrusted) and ride it on the
+        // existing ledger metadata channel as `intentNote`. Empty stays
+        // off the metadata entirely so we never persist a blank note.
+        const trimmedIntentNote =
+          typeof intentNote === 'string' ? intentNote.trim().slice(0, 280) : ''
+        const resolveOptions = trimmedIntentNote
+          ? { extraMetadata: { intentNote: trimmedIntentNote } }
+          : undefined
         // Slice 5 v2 of the external-path-redesign arc. When the user
         // clicks "Grant read access" / "Grant edit access" in an
         // external-path approval modal, peek at the pending approval's stashed
@@ -16744,7 +16861,7 @@ if (isGeminiMcpBridgeProcess) {
             }
           }
         }
-        return approvalServiceInstance.resolve(requestId, action)
+        return approvalServiceInstance.resolve(requestId, action, resolveOptions)
       }
     )
 
diff --git a/src/main/services/AuditService.test.ts b/src/main/services/AuditService.test.ts
index 1eafc50b..cf064167 100644
--- a/src/main/services/AuditService.test.ts
+++ b/src/main/services/AuditService.test.ts
@@ -61,6 +61,17 @@ describe('AuditService', () => {
     )
   })
 
+  it('threads an optional intent note through extraMetadata (Order-4)', () => {
+    const { deps } = makeDeps()
+    const service = new AuditService(deps)
+    service.resolveApprovalLedgerResponse('approval-1', 'accept', 'user', {
+      intentNote: 'reviewed the diff, safe'
+    })
+    expect(deps.resolveApprovalResponse).toHaveBeenCalledWith('approval-1', 'accept', 'user', {
+      intentNote: 'reviewed the diff, safe'
+    })
+  })
+
   it('does not throw when ledger response resolution fails', () => {
     const error = new Error('ledger unavailable')
     const { deps, errors } = makeDeps({
diff --git a/src/main/services/GitService.test.ts b/src/main/services/GitService.test.ts
new file mode 100644
index 00000000..b9e3125c
--- /dev/null
+++ b/src/main/services/GitService.test.ts
@@ -0,0 +1,316 @@
+import { execFileSync, spawnSync } from 'child_process'
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { GitService, parseStatusPorcelainZ, type GitCommandRunner } from './GitService'
+
+function runGit(cwd: string, args: string[]): string {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
+}
+
+function createRepo(): string {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), 'agbench-git-service-')))
+  runGit(repo, ['init', '-b', 'main'])
+  runGit(repo, ['config', 'user.name', 'AGBench Test'])
+  runGit(repo, ['config', 'user.email', 'agbench@example.test'])
+  writeFileSync(join(repo, 'README.md'), 'initial\n')
+  runGit(repo, ['add', 'README.md'])
+  runGit(repo, ['commit', '-m', 'Initial commit'])
+  return repo
+}
+
+describe('GitService', () => {
+  let repo: string
+  let extraTempPaths: string[]
+
+  beforeEach(() => {
+    repo = createRepo()
+    extraTempPaths = []
+  })
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true })
+    for (const tempPath of extraTempPaths) {
+      rmSync(tempPath, { recursive: true, force: true })
+    }
+  })
+
+  function addBareRemote(): string {
+    const remote = realpathSync(mkdtempSync(join(tmpdir(), 'agbench-git-remote-')))
+    extraTempPaths.push(remote)
+    runGit(remote, ['init', '--bare'])
+    runGit(repo, ['remote', 'add', 'origin', remote])
+    runGit(repo, ['push', '-u', 'origin', 'main'])
+    return remote
+  }
+
+  it('parses porcelain status records', () => {
+    expect(parseStatusPorcelainZ(' M README.md\0?? new file.txt\0')).toEqual([
+      {
+        path: 'README.md',
+        index: ' ',
+        workingTree: 'M',
+        kind: 'modified',
+        staged: false,
+        unstaged: true
+      },
+      {
+        path: 'new file.txt',
+        index: '?',
+        workingTree: '?',
+        kind: 'untracked',
+        staged: false,
+        unstaged: true
+      }
+    ])
+  })
+
+  it('resolves the repository root from a nested directory', async () => {
+    const nested = join(repo, 'src', 'feature')
+    mkdirSync(nested, { recursive: true })
+
+    const result = await new GitService().snapshot(nested)
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.repoRoot).toBe(repo)
+    expect(result.data.requestedPath).toBe(nested)
+    expect(result.data.branch).toBe('main')
+    expect(result.data.clean).toBe(true)
+  })
+
+  it('reports changed and untracked files', async () => {
+    writeFileSync(join(repo, 'README.md'), 'changed\n')
+    writeFileSync(join(repo, 'new.txt'), 'new\n')
+
+    const result = await new GitService().snapshot(repo)
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.counts.changed).toBe(2)
+    expect(result.data.files).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ path: 'README.md', kind: 'modified', unstaged: true }),
+        expect.objectContaining({ path: 'new.txt', kind: 'untracked', unstaged: true })
+      ])
+    )
+  })
+
+  it('stages selected paths without staging every file', async () => {
+    writeFileSync(join(repo, 'one.txt'), 'one\n')
+    writeFileSync(join(repo, 'two.txt'), 'two\n')
+
+    const result = await new GitService().stage({ repoPath: repo, paths: ['one.txt'] })
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.files).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ path: 'one.txt', staged: true }),
+        expect.objectContaining({ path: 'two.txt', kind: 'untracked', staged: false })
+      ])
+    )
+  })
+
+  it('rejects staging paths that escape the repository', async () => {
+    writeFileSync(join(repo, 'safe.txt'), 'safe\n')
+    const service = new GitService()
+
+    const traversal = await service.stage({ repoPath: repo, paths: ['../outside.txt'] })
+    const absolute = await service.stage({ repoPath: repo, paths: [join(repo, 'safe.txt')] })
+
+    expect(traversal).toEqual({
+      ok: false,
+      error: 'Stage paths must stay inside the repository.'
+    })
+    expect(absolute).toEqual({
+      ok: false,
+      error: 'Stage paths must be relative to the repository.'
+    })
+    expect(runGit(repo, ['diff', '--cached', '--name-only']).trim()).toBe('')
+  })
+
+  it('commits staged changes and returns a clean snapshot', async () => {
+    writeFileSync(join(repo, 'committed.txt'), 'committed\n')
+    const service = new GitService()
+    const stageResult = await service.stage({ repoPath: repo, all: true })
+    expect(stageResult.ok).toBe(true)
+
+    const commitResult = await service.commit({ repoPath: repo, message: 'Add committed file' })
+
+    expect(commitResult.ok).toBe(true)
+    if (!commitResult.ok) return
+    expect(commitResult.data.clean).toBe(true)
+    expect(runGit(repo, ['log', '-1', '--pretty=%s']).trim()).toBe('Add committed file')
+  })
+
+  it('refuses to commit with no staged changes', async () => {
+    const result = await new GitService().commit({ repoPath: repo, message: 'Nothing staged' })
+
+    expect(result).toEqual({ ok: false, error: 'No staged changes to commit.' })
+  })
+
+  it('refuses to push a branch with no remote', async () => {
+    const result = await new GitService().push({ repoPath: repo })
+
+    expect(result).toEqual({
+      ok: false,
+      error: 'No git remote is configured. Add a remote before pushing.'
+    })
+  })
+
+  it('refuses to push from a detached HEAD', async () => {
+    addBareRemote()
+    runGit(repo, ['checkout', '--detach', 'HEAD'])
+
+    const result = await new GitService().push({ repoPath: repo })
+
+    expect(result).toEqual({
+      ok: false,
+      error: 'Cannot push from a detached HEAD. Create or switch to a branch first.'
+    })
+  })
+
+  it('runs gh pr create from the resolved repository root', async () => {
+    addBareRemote()
+    const nested = join(repo, 'nested')
+    mkdirSync(nested, { recursive: true })
+    const calls: Array<{
+      command: string
+      args: string[]
+      cwd: string
+      env?: Record<string, string>
+    }> = []
+    const runner: GitCommandRunner = async (command, args, options) => {
+      calls.push({ command, args, cwd: options.cwd, env: options.env })
+      if (command === 'gh') {
+        if (args.includes('view')) {
+          return {
+            stdout: '',
+            stderr: 'no pull requests found for branch "main"',
+            code: 1
+          }
+        }
+        return {
+          stdout: 'https://github.com/boggspa/AGBench/pull/42\n',
+          stderr: '',
+          code: 0
+        }
+      }
+      const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+      })
+      return {
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+        code: result.status ?? 0
+      }
+    }
+
+    const result = await new GitService({ run: runner }).createPullRequest({
+      repoPath: nested,
+      draft: true
+    })
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.url).toBe('https://github.com/boggspa/AGBench/pull/42')
+    expect(calls.find((call) => call.command === 'gh' && call.args.includes('create'))).toEqual({
+      command: 'gh',
+      args: ['pr', 'create', '--fill', '--draft'],
+      cwd: repo,
+      env: { GH_PROMPT_DISABLED: '1' }
+    })
+  })
+
+  it('reports PR readiness when the branch needs to be pushed first', async () => {
+    addBareRemote()
+    writeFileSync(join(repo, 'ahead.txt'), 'ahead\n')
+    runGit(repo, ['add', 'ahead.txt'])
+    runGit(repo, ['commit', '-m', 'Ahead commit'])
+
+    const result = await new GitService({
+      run: async (command, args, options) => {
+        if (command === 'gh') {
+          return {
+            stdout: '',
+            stderr: 'no pull requests found for branch "main"',
+            code: 1
+          }
+        }
+        const git = spawnSync(command, args, {
+          cwd: options.cwd,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe']
+        })
+        return {
+          stdout: git.stdout || '',
+          stderr: git.stderr || '',
+          code: git.status ?? 0
+        }
+      }
+    }).pullRequestReadiness(repo)
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.canCreatePullRequest).toBe(false)
+    expect(result.data.shouldPushFirst).toBe(true)
+    expect(result.data.reason).toBe('Push the current branch before creating a pull request.')
+  })
+
+  it('reports an existing pull request as not creatable', async () => {
+    addBareRemote()
+    const result = await new GitService({
+      run: async (command, args, options) => {
+        if (command === 'gh') {
+          return {
+            stdout: JSON.stringify({
+              number: 42,
+              url: 'https://github.com/boggspa/AGBench/pull/42',
+              state: 'OPEN',
+              isDraft: false,
+              headRefName: 'main',
+              baseRefName: 'master',
+              statusCheckRollup: []
+            }),
+            stderr: '',
+            code: 0
+          }
+        }
+        const git = spawnSync(command, args, {
+          cwd: options.cwd,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe']
+        })
+        return {
+          stdout: git.stdout || '',
+          stderr: git.stderr || '',
+          code: git.status ?? 0
+        }
+      }
+    }).pullRequestReadiness(repo)
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.canCreatePullRequest).toBe(false)
+    expect(result.data.existingPullRequest?.url).toBe('https://github.com/boggspa/AGBench/pull/42')
+    expect(result.data.reason).toBe('This branch already has a pull request.')
+  })
+
+  it('refuses PR creation before the current branch is pushed', async () => {
+    addBareRemote()
+    writeFileSync(join(repo, 'ahead-pr.txt'), 'ahead\n')
+    runGit(repo, ['add', 'ahead-pr.txt'])
+    runGit(repo, ['commit', '-m', 'Ahead PR commit'])
+
+    const result = await new GitService().createPullRequest({ repoPath: repo })
+
+    expect(result).toEqual({
+      ok: false,
+      error: 'Push the current branch before creating a pull request.'
+    })
+  })
+})
diff --git a/src/main/services/GitService.ts b/src/main/services/GitService.ts
new file mode 100644
index 00000000..29c3ee3f
--- /dev/null
+++ b/src/main/services/GitService.ts
@@ -0,0 +1,604 @@
+import { spawn } from 'child_process'
+import { promises as fs } from 'fs'
+import { homedir } from 'os'
+import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'path'
+
+const DEFAULT_TIMEOUT_MS = 30_000
+
+export interface GitCommandResult {
+  stdout: string
+  stderr: string
+  code: number
+}
+
+export interface GitCommandOptions {
+  cwd: string
+  timeoutMs?: number
+  env?: Record<string, string>
+}
+
+export interface GitCommandRunner {
+  (command: string, args: string[], options: GitCommandOptions): Promise<GitCommandResult>
+}
+
+export interface GitFileStatus {
+  path: string
+  originalPath?: string
+  index: string
+  workingTree: string
+  kind: 'created' | 'modified' | 'deleted' | 'renamed' | 'untracked' | 'conflicted' | 'ignored'
+  staged: boolean
+  unstaged: boolean
+}
+
+export interface GitRepositorySnapshot {
+  requestedPath: string
+  repoRoot: string
+  branch?: string
+  commit?: string
+  detached: boolean
+  upstream?: string
+  remoteName?: string
+  remoteUrl?: string
+  ahead: number
+  behind: number
+  files: GitFileStatus[]
+  counts: {
+    changed: number
+    staged: number
+    unstaged: number
+    untracked: number
+  }
+  clean: boolean
+}
+
+export interface GitPrSummary {
+  number?: number
+  url?: string
+  state?: string
+  isDraft?: boolean
+  headRefName?: string
+  baseRefName?: string
+  checks?: Array<{
+    name?: string
+    status?: string
+    conclusion?: string
+    url?: string
+  }>
+}
+
+export interface GitPrReadiness {
+  snapshot: GitRepositorySnapshot
+  existingPullRequest?: GitPrSummary
+  canCreatePullRequest: boolean
+  shouldPushFirst: boolean
+  reason?: string
+  warnings: string[]
+}
+
+export type GitResult<T> = { ok: true; data: T } | { ok: false; error: string; stderr?: string }
+
+export interface GitStageInput {
+  repoPath: string
+  paths?: string[]
+  all?: boolean
+  update?: boolean
+  patch?: string
+}
+
+export interface GitCommitInput {
+  repoPath: string
+  message: string
+}
+
+export interface GitPushInput {
+  repoPath: string
+  setUpstream?: boolean
+  remote?: string
+}
+
+export interface GitCreatePrInput {
+  repoPath: string
+  title?: string
+  body?: string
+  draft?: boolean
+}
+
+export class GitService {
+  private run: GitCommandRunner
+  private timeoutMs: number
+
+  constructor(options: { run?: GitCommandRunner; timeoutMs?: number } = {}) {
+    this.run = options.run || runCommand
+    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS
+  }
+
+  async snapshot(inputPath: string): Promise<GitResult<GitRepositorySnapshot>> {
+    try {
+      return { ok: true, data: await this.buildSnapshot(inputPath) }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async stage(input: GitStageInput): Promise<GitResult<GitRepositorySnapshot>> {
+    try {
+      const repo = await this.resolveRepository(input.repoPath)
+      const paths = sanitizeRepoPaths(input.paths, repo.repoRoot)
+      if (input.patch && input.patch.trim()) {
+        return {
+          ok: false,
+          error: 'Patch staging is not available through the desktop Git service yet.'
+        }
+      }
+      if (input.all) {
+        await this.mustRun('git', ['add', '-A'], repo.repoRoot)
+      } else if (input.update) {
+        await this.mustRun('git', ['add', '-u'], repo.repoRoot)
+      } else if (paths.length > 0) {
+        await this.mustRun('git', ['add', '--', ...paths], repo.repoRoot)
+      } else {
+        return { ok: false, error: 'Choose files to stage or pass all=true.' }
+      }
+      return { ok: true, data: await this.buildSnapshot(repo.repoRoot) }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async commit(input: GitCommitInput): Promise<GitResult<GitRepositorySnapshot>> {
+    try {
+      const message = input.message.trim()
+      if (!message) return { ok: false, error: 'Commit message is required.' }
+      const repo = await this.resolveRepository(input.repoPath)
+      const staged = await this.run('git', ['diff', '--cached', '--quiet'], {
+        cwd: repo.repoRoot,
+        timeoutMs: this.timeoutMs
+      })
+      if (staged.code === 0) return { ok: false, error: 'No staged changes to commit.' }
+      await this.mustRun('git', ['commit', '-m', message], repo.repoRoot)
+      return { ok: true, data: await this.buildSnapshot(repo.repoRoot) }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async push(input: GitPushInput): Promise<GitResult<GitRepositorySnapshot>> {
+    try {
+      const snapshot = await this.buildSnapshot(input.repoPath)
+      if (snapshot.detached || !snapshot.branch) {
+        return { ok: false, error: 'Cannot push from a detached HEAD. Create or switch to a branch first.' }
+      }
+      if (!snapshot.remoteUrl && !input.remote?.trim()) {
+        return { ok: false, error: 'No git remote is configured. Add a remote before pushing.' }
+      }
+      const remote = input.remote?.trim() || snapshot.remoteName || 'origin'
+      const args =
+        snapshot.upstream && !input.setUpstream
+          ? ['push']
+          : ['push', '-u', remote, snapshot.branch]
+      await this.mustRun('git', args, snapshot.repoRoot)
+      return { ok: true, data: await this.buildSnapshot(snapshot.repoRoot) }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async createPullRequest(input: GitCreatePrInput): Promise<GitResult<GitPrSummary>> {
+    try {
+      const snapshot = await this.buildSnapshot(input.repoPath)
+      if (snapshot.detached || !snapshot.branch) {
+        return { ok: false, error: 'Cannot create a pull request from a detached HEAD.' }
+      }
+      if (!snapshot.remoteUrl) {
+        return { ok: false, error: 'No git remote is configured. Add and push to a remote before creating a pull request.' }
+      }
+      if (!snapshot.upstream || snapshot.ahead > 0) {
+        return { ok: false, error: 'Push the current branch before creating a pull request.' }
+      }
+      const existingPr = await this.readPullRequestSummary(snapshot.repoRoot)
+      if (existingPr.ok && existingPr.summary?.url) {
+        return { ok: false, error: 'This branch already has a pull request.', stderr: existingPr.summary.url }
+      }
+      const args = ['pr', 'create']
+      const title = input.title?.trim() || ''
+      const body = input.body?.trim() || ''
+      if (title) args.push('--title', title)
+      if (body) args.push('--body', body)
+      if (!title && !body) args.push('--fill')
+      if (input.draft) args.push('--draft')
+
+      const result = await this.runGh(args, snapshot.repoRoot)
+      if (result.code !== 0) {
+        return {
+          ok: false,
+          error: result.stderr.trim() || result.stdout.trim() || '`gh pr create` failed.',
+          stderr: result.stderr.trim() || undefined
+        }
+      }
+      return {
+        ok: true,
+        data: {
+          url: result.stdout.trim().match(/https?:\/\/[^\s]+/)?.[0],
+          headRefName: snapshot.branch
+        }
+      }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async pullRequestStatus(inputPath: string): Promise<GitResult<GitPrSummary>> {
+    try {
+      const snapshot = await this.buildSnapshot(inputPath)
+      if (snapshot.detached || !snapshot.branch) {
+        return { ok: false, error: 'Cannot read pull request status from a detached HEAD.' }
+      }
+      const existingPr = await this.readPullRequestSummary(snapshot.repoRoot)
+      if (!existingPr.ok) {
+        return {
+          ok: false,
+          error: existingPr.error,
+          stderr: existingPr.stderr
+        }
+      }
+      if (!existingPr.summary) {
+        return { ok: false, error: 'No pull request found for the current branch.' }
+      }
+      return { ok: true, data: existingPr.summary }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async pullRequestReadiness(inputPath: string): Promise<GitResult<GitPrReadiness>> {
+    try {
+      const snapshot = await this.buildSnapshot(inputPath)
+      const warnings: string[] = []
+      let existingPullRequest: GitPrSummary | undefined
+      if (!snapshot.detached && snapshot.branch && snapshot.remoteUrl) {
+        const existingPr = await this.readPullRequestSummary(snapshot.repoRoot)
+        if (existingPr.ok) {
+          existingPullRequest = existingPr.summary
+        } else if (!existingPr.notFound) {
+          warnings.push(existingPr.error)
+        }
+      }
+      let reason: string | undefined
+      if (snapshot.detached || !snapshot.branch) {
+        reason = 'Cannot create a pull request from a detached HEAD.'
+      } else if (!snapshot.remoteUrl) {
+        reason = 'No git remote is configured.'
+      } else if (!snapshot.upstream || snapshot.ahead > 0) {
+        reason = 'Push the current branch before creating a pull request.'
+      } else if (existingPullRequest?.url) {
+        reason = 'This branch already has a pull request.'
+      }
+      const shouldPushFirst = Boolean(
+        snapshot.branch && snapshot.remoteUrl && (!snapshot.upstream || snapshot.ahead > 0)
+      )
+      return {
+        ok: true,
+        data: {
+          snapshot,
+          ...(existingPullRequest ? { existingPullRequest } : {}),
+          canCreatePullRequest: !reason,
+          shouldPushFirst,
+          ...(reason ? { reason } : {}),
+          warnings
+        }
+      }
+    } catch (error) {
+      return failure(error)
+    }
+  }
+
+  async resolveRepository(inputPath: string): Promise<{ requestedPath: string; repoRoot: string }> {
+    const rawPath = expandHomePath(inputPath || '').trim()
+    if (!rawPath) throw new Error('Repository path is required.')
+    const requestedPath = resolve(rawPath)
+    let cwd = requestedPath
+    try {
+      const stat = await fs.stat(requestedPath)
+      if (!stat.isDirectory()) cwd = dirname(requestedPath)
+    } catch {
+      throw new Error('Path does not exist on disk.')
+    }
+    const result = await this.run('git', ['rev-parse', '--show-toplevel'], {
+      cwd,
+      timeoutMs: this.timeoutMs
+    })
+    if (result.code !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || 'Path is not inside a git repository.')
+    }
+    return {
+      requestedPath,
+      repoRoot: result.stdout.trim()
+    }
+  }
+
+  private async readPullRequestSummary(repoRoot: string): Promise<
+    | { ok: true; summary?: GitPrSummary }
+    | { ok: false; error: string; stderr?: string; notFound?: boolean }
+  > {
+    const result = await this.runGh(
+      [
+        'pr',
+        'view',
+        '--json',
+        'number,url,state,isDraft,headRefName,baseRefName,statusCheckRollup'
+      ],
+      repoRoot
+    )
+    if (result.code !== 0) {
+      const stderr = result.stderr.trim()
+      const stdout = result.stdout.trim()
+      const message = stderr || stdout || '`gh pr view` failed.'
+      if (isNoPullRequestMessage(message)) {
+        return { ok: true }
+      }
+      return {
+        ok: false,
+        error: message,
+        stderr: stderr || undefined
+      }
+    }
+    return { ok: true, summary: parsePullRequestSummary(result.stdout) }
+  }
+
+  private async runGh(args: string[], cwd: string): Promise<GitCommandResult> {
+    return this.run('gh', args, {
+      cwd,
+      timeoutMs: this.timeoutMs,
+      env: { GH_PROMPT_DISABLED: '1' }
+    })
+  }
+
+  private async buildSnapshot(inputPath: string): Promise<GitRepositorySnapshot> {
+    const repo = await this.resolveRepository(inputPath)
+    const [branchResult, commitResult, upstreamResult, remoteResult, statusResult] =
+      await Promise.all([
+        this.run('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], {
+          cwd: repo.repoRoot,
+          timeoutMs: this.timeoutMs
+        }),
+        this.run('git', ['rev-parse', '--short', 'HEAD'], {
+          cwd: repo.repoRoot,
+          timeoutMs: this.timeoutMs
+        }),
+        this.run('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], {
+          cwd: repo.repoRoot,
+          timeoutMs: this.timeoutMs
+        }),
+        this.run('git', ['config', '--get', 'remote.origin.url'], {
+          cwd: repo.repoRoot,
+          timeoutMs: this.timeoutMs
+        }),
+        this.run('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all'], {
+          cwd: repo.repoRoot,
+          timeoutMs: this.timeoutMs
+        })
+      ])
+
+    const branch = branchResult.code === 0 ? branchResult.stdout.trim() : undefined
+    const upstream = upstreamResult.code === 0 ? upstreamResult.stdout.trim() : undefined
+    const files = parseStatusPorcelainZ(statusResult.stdout)
+    const aheadBehind = upstream
+      ? await this.readAheadBehind(repo.repoRoot)
+      : { ahead: 0, behind: 0 }
+
+    return {
+      requestedPath: repo.requestedPath,
+      repoRoot: repo.repoRoot,
+      branch,
+      commit: commitResult.code === 0 ? commitResult.stdout.trim() : undefined,
+      detached: !branch,
+      upstream,
+      remoteName: upstream?.includes('/') ? upstream.split('/')[0] : remoteResult.code === 0 ? 'origin' : undefined,
+      remoteUrl: remoteResult.code === 0 ? remoteResult.stdout.trim() : undefined,
+      ahead: aheadBehind.ahead,
+      behind: aheadBehind.behind,
+      files,
+      counts: {
+        changed: files.length,
+        staged: files.filter((file) => file.staged).length,
+        unstaged: files.filter((file) => file.unstaged).length,
+        untracked: files.filter((file) => file.kind === 'untracked').length
+      },
+      clean: files.length === 0
+    }
+  }
+
+  private async readAheadBehind(repoRoot: string): Promise<{ ahead: number; behind: number }> {
+    const result = await this.run('git', ['rev-list', '--left-right', '--count', 'HEAD...@{u}'], {
+      cwd: repoRoot,
+      timeoutMs: this.timeoutMs
+    })
+    if (result.code !== 0) return { ahead: 0, behind: 0 }
+    const [aheadRaw, behindRaw] = result.stdout.trim().split(/\s+/)
+    return {
+      ahead: Number(aheadRaw) || 0,
+      behind: Number(behindRaw) || 0
+    }
+  }
+
+  private async mustRun(command: string, args: string[], cwd: string): Promise<GitCommandResult> {
+    const result = await this.run(command, args, { cwd, timeoutMs: this.timeoutMs })
+    if (result.code !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || `${command} ${args.join(' ')} failed.`)
+    }
+    return result
+  }
+}
+
+export function parseStatusPorcelainZ(output: string): GitFileStatus[] {
+  const entries: GitFileStatus[] = []
+  const parts = output.split('\0')
+  let i = 0
+  while (i < parts.length) {
+    const entry = parts[i]
+    if (!entry || entry.length < 3) {
+      i++
+      continue
+    }
+    const index = entry[0] || ' '
+    const workingTree = entry[1] || ' '
+    const path = entry.slice(3)
+    let originalPath: string | undefined
+    if ((index === 'R' || index === 'C') && i + 1 < parts.length) {
+      originalPath = parts[i + 1] || undefined
+      i += 2
+    } else {
+      i++
+    }
+    entries.push({
+      path,
+      originalPath,
+      index,
+      workingTree,
+      kind: classifyStatus(index, workingTree),
+      staged: index !== ' ' && index !== '?' && index !== '!',
+      unstaged: workingTree !== ' ' || index === '?' || index === '!'
+    })
+  }
+  return entries
+}
+
+async function runCommand(
+  command: string,
+  args: string[],
+  options: GitCommandOptions
+): Promise<GitCommandResult> {
+  return await new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...(command === 'gh' ? { GH_PROMPT_DISABLED: '1' } : {}), ...options.env },
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+    const timeout = setTimeout(() => {
+      if (settled) return
+      settled = true
+      child.kill()
+      resolve({ stdout, stderr: `${command} timed out after ${options.timeoutMs || DEFAULT_TIMEOUT_MS}ms.`, code: -1 })
+    }, options.timeoutMs || DEFAULT_TIMEOUT_MS)
+    child.stdout?.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString('utf8')
+    })
+    child.stderr?.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString('utf8')
+    })
+    child.on('error', (error: NodeJS.ErrnoException) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timeout)
+      const message =
+        error.code === 'ENOENT'
+          ? `${command} is not installed or not on PATH.`
+          : `Failed to launch ${command}: ${error.message}`
+      resolve({ stdout, stderr: message, code: -1 })
+    })
+    child.on('close', (code) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timeout)
+      resolve({ stdout, stderr, code: code ?? 0 })
+    })
+  })
+}
+
+function classifyStatus(
+  index: string,
+  workingTree: string
+): GitFileStatus['kind'] {
+  if (index === '?' || workingTree === '?') return 'untracked'
+  if (index === '!' || workingTree === '!') return 'ignored'
+  if (index === 'U' || workingTree === 'U' || (index === 'A' && workingTree === 'A')) {
+    return 'conflicted'
+  }
+  if (index === 'R' || workingTree === 'R') return 'renamed'
+  if (index === 'A' || workingTree === 'A') return 'created'
+  if (index === 'D' || workingTree === 'D') return 'deleted'
+  return 'modified'
+}
+
+function sanitizeRepoPaths(paths: string[] | undefined, repoRoot: string): string[] {
+  if (!Array.isArray(paths)) return []
+  const sanitized: string[] = []
+  for (const candidate of paths) {
+    const trimmed = String(candidate || '').trim()
+    if (!trimmed) continue
+    if (isAbsolute(trimmed)) {
+      throw new Error('Stage paths must be relative to the repository.')
+    }
+    const normalized = normalize(trimmed)
+    if (normalized === '.' || normalized === '..' || normalized.startsWith(`..${sep}`)) {
+      throw new Error('Stage paths must stay inside the repository.')
+    }
+    const resolvedPath = resolve(repoRoot, normalized)
+    const relativePath = relative(repoRoot, resolvedPath)
+    if (!relativePath || relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+      throw new Error('Stage paths must stay inside the repository.')
+    }
+    sanitized.push(relativePath)
+  }
+  return sanitized
+}
+
+function expandHomePath(value?: string | null): string {
+  const raw = String(value || '').trim()
+  if (!raw) return ''
+  if (raw === '~') return homedir()
+  if (raw.startsWith('~/')) return join(homedir(), raw.slice(2))
+  return raw
+}
+
+function parsePullRequestSummary(output: string): GitPrSummary {
+  const parsed = JSON.parse(output || '{}') as Record<string, unknown>
+  const checks = Array.isArray(parsed.statusCheckRollup)
+    ? parsed.statusCheckRollup.map((item) => {
+        const record = isRecord(item) ? item : {}
+        return {
+          name: stringField(record.name),
+          status: stringField(record.status),
+          conclusion: stringField(record.conclusion),
+          url: stringField(record.detailsUrl) || stringField(record.url)
+        }
+      })
+    : undefined
+  return {
+    number: typeof parsed.number === 'number' ? parsed.number : undefined,
+    url: stringField(parsed.url),
+    state: stringField(parsed.state),
+    isDraft: typeof parsed.isDraft === 'boolean' ? parsed.isDraft : undefined,
+    headRefName: stringField(parsed.headRefName),
+    baseRefName: stringField(parsed.baseRefName),
+    checks
+  }
+}
+
+function isNoPullRequestMessage(message: string): boolean {
+  const normalized = message.toLowerCase()
+  return (
+    normalized.includes('no pull requests found') ||
+    normalized.includes('no open pull requests') ||
+    normalized.includes('could not find any pull requests')
+  )
+}
+
+function failure<T>(error: unknown): GitResult<T> {
+  return {
+    ok: false,
+    error: error instanceof Error ? error.message : String(error)
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+function stringField(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
diff --git a/src/main/settings/MainSanitizers.test.ts b/src/main/settings/MainSanitizers.test.ts
index 132dcc9e..e628fc9b 100644
--- a/src/main/settings/MainSanitizers.test.ts
+++ b/src/main/settings/MainSanitizers.test.ts
@@ -143,4 +143,32 @@ describe('MainSanitizers settings patches', () => {
       mainAuthorityMs: 60_000
     })
   })
+
+  it('sanitizes changelog persistence settings', () => {
+    const settings = makeSettings()
+    const { sanitizeSettingsPatch } = makeSanitizers(settings)
+
+    const sanitized = sanitizeSettingsPatch({
+      lastSeenChangelogVersion: ' 1.0.73 ',
+      pendingUpdateChangelog: {
+        version: ' 1.0.74 ',
+        releaseName: ' AGBench 1.0.74 ',
+        releaseDate: ' 2026-06-04T13:00:00.000Z ',
+        releaseNotes: [
+          { version: ' 1.0.74 ', note: 'Updater pill.' },
+          { version: '', note: 'ignored' }
+        ]
+      }
+    })
+
+    expect(sanitized).toMatchObject({
+      lastSeenChangelogVersion: '1.0.73',
+      pendingUpdateChangelog: {
+        version: '1.0.74',
+        releaseName: 'AGBench 1.0.74',
+        releaseDate: '2026-06-04T13:00:00.000Z',
+        releaseNotes: [{ version: '1.0.74', note: 'Updater pill.' }]
+      }
+    })
+  })
 })
diff --git a/src/main/settings/MainSanitizers.ts b/src/main/settings/MainSanitizers.ts
index 5c5d5fd9..031803ed 100644
--- a/src/main/settings/MainSanitizers.ts
+++ b/src/main/settings/MainSanitizers.ts
@@ -7,6 +7,7 @@ import type {
   HandoffCard,
   HandoffCardFilter,
   ProviderId,
+  ProductUpdateChangelog,
   RuntimeProfile,
   ScheduledTask,
   WorkspaceRecord
@@ -65,6 +66,8 @@ const SETTINGS_PATCH_KEYS = new Set<keyof AppSettings>([
   'bridgeDaemonEnabled',
   'codexSandboxFallback',
   'updateChannel',
+  'lastSeenChangelogVersion',
+  'pendingUpdateChangelog',
   'approvalTimeouts'
 ])
 
@@ -207,6 +210,40 @@ function sanitizeApprovalTimeoutMs(value: unknown, fallback: number): number {
   return Math.max(5_000, Math.min(3_600_000, parsed))
 }
 
+function sanitizeUpdateChangelog(value: unknown): ProductUpdateChangelog | undefined {
+  const record = isRecord(value) ? value : {}
+  const version = typeof record.version === 'string' ? record.version.trim() : ''
+  if (!version) return undefined
+
+  const changelog: ProductUpdateChangelog = { version }
+  if (typeof record.releaseName === 'string' && record.releaseName.trim()) {
+    changelog.releaseName = record.releaseName.trim()
+  }
+  if (typeof record.releaseDate === 'string' && record.releaseDate.trim()) {
+    changelog.releaseDate = record.releaseDate.trim()
+  }
+  if (typeof record.releaseNotes === 'string') {
+    changelog.releaseNotes = record.releaseNotes
+  } else if (Array.isArray(record.releaseNotes)) {
+    const notes = record.releaseNotes
+      .map((item) => {
+        const noteRecord = isRecord(item) ? item : {}
+        const noteVersion =
+          typeof noteRecord.version === 'string' ? noteRecord.version.trim() : ''
+        if (!noteVersion) return null
+        return {
+          version: noteVersion,
+          note: typeof noteRecord.note === 'string' ? noteRecord.note : null
+        }
+      })
+      .filter((item): item is { version: string; note: string | null } => item !== null)
+    if (notes.length > 0) {
+      changelog.releaseNotes = notes
+    }
+  }
+  return changelog
+}
+
 export function normalizeEnsembleRunIdentity(value: unknown): EnsembleRunIdentity | undefined {
   if (!isRecord(value)) return undefined
   return {
@@ -615,6 +652,24 @@ export function createMainSanitizers(deps: MainSanitizerDeps) {
         mainAuthorityMs: sanitizeApprovalTimeoutMs(prefs.mainAuthorityMs, current.mainAuthorityMs)
       }
     }
+    if ('lastSeenChangelogVersion' in sanitized) {
+      if (
+        typeof sanitized.lastSeenChangelogVersion === 'string' &&
+        sanitized.lastSeenChangelogVersion.trim()
+      ) {
+        sanitized.lastSeenChangelogVersion = sanitized.lastSeenChangelogVersion.trim()
+      } else {
+        delete sanitized.lastSeenChangelogVersion
+      }
+    }
+    if ('pendingUpdateChangelog' in sanitized) {
+      const changelog = sanitizeUpdateChangelog(sanitized.pendingUpdateChangelog)
+      if (changelog) {
+        sanitized.pendingUpdateChangelog = changelog
+      } else {
+        delete sanitized.pendingUpdateChangelog
+      }
+    }
     if ('kimiSanitiserEnabled' in sanitized) {
       sanitized.kimiSanitiserEnabled =
         typeof sanitized.kimiSanitiserEnabled === 'boolean'
diff --git a/src/main/store/index.ts b/src/main/store/index.ts
index 1c06f7b5..89b46efd 100644
--- a/src/main/store/index.ts
+++ b/src/main/store/index.ts
@@ -31,7 +31,8 @@ import {
   ProductCrashRecord,
   RuntimeProfile,
   HandoffCard,
-  HandoffCardFilter
+  HandoffCardFilter,
+  ProductUpdateChangelog
 } from './types'
 import { canonicalizeExternalPathGrantMetadata } from './ExternalPathGrants'
 import { createDefaultEnsembleConfig } from '../EnsembleDefaults'
@@ -97,6 +98,10 @@ const runEventHashCache = new Map<string, string>()
 // so their global chats have a usable runtime out of the box. Unconditional:
 // unused default profiles for a force-disabled provider are harmless data.
 const providerIds: ProviderId[] = ['gemini', 'codex', 'claude', 'kimi', 'grok', 'cursor']
+const LEGACY_AGBENCH_FONT_STACK =
+  '"SF Pro", "SF Pro Text", "SF Pro Display", -apple-system, BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", Roboto, Arial, sans-serif'
+const AGBENCH_DEFAULT_FONT_STACK =
+  '"Avenir Next", Avenir, system-ui, -apple-system, BlinkMacSystemFont, "SF Pro Text", "Segoe UI", sans-serif'
 
 const defaultSettings: AppSettings = {
   activeProvider: 'gemini',
@@ -120,8 +125,7 @@ const defaultSettings: AppSettings = {
   userBubbleColor: 'system',
   promptSurfaceStyle: 'liquid_glass',
   composerStyle: 'default',
-  transcriptFontFamily:
-    '"SF Pro", "SF Pro Text", "SF Pro Display", -apple-system, BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", Roboto, Arial, sans-serif',
+  transcriptFontFamily: AGBENCH_DEFAULT_FONT_STACK,
   composerFontFamily: 'match-transcript',
   // 1.0.5-EW25 — Display currency for cost / token-spend chips.
   // USD by default; user can switch to GBP / EUR via Settings →
@@ -132,16 +136,20 @@ const defaultSettings: AppSettings = {
   // General lets the user dial 0–25%. Applied in `formatCost.ts`
   // before FX conversion so the bias is currency-agnostic.
   currencyOverestimatePercent: 0,
+  dashboardStatPrefs: {
+    dashboardSize: 'small'
+  },
   welcomeHeatmapPrefs: {
+    layout: 'single',
     workspaceActivityEnabled: true,
     agbenchActivityEnabled: true,
     externalActivityEnabled: true
   },
-  // 1.0.5-EW26 — Kimi compatibility filter defaults. Off by
-  // default; the user opts in from Settings → General when they
-  // hit a Moonshot content_filter rejection on an incidental
-  // topic. Custom keywords stay empty until the user adds any.
-  kimiSanitiserEnabled: false,
+  // 1.0.5-EW26 — Kimi compatibility filter defaults. On by
+  // default so Moonshot content_filter retries get the compatibility
+  // pass automatically. Custom keywords stay empty until the user
+  // adds any.
+  kimiSanitiserEnabled: true,
   kimiSanitiserCustomKeywords: '',
   // 1.0.7-M10 — second-pass classifier stays opt-in; when unset
   // or false, the retry envelope remains keyword-only.
@@ -177,7 +185,7 @@ const defaultSettings: AppSettings = {
   geminiMcpBridgeLastStatus: undefined,
   bridgeDaemonEnabled: true,
   codexSandboxFallback: 'ask_rerun',
-  updateChannel: 'debug',
+  updateChannel: 'stable',
   approvalTimeouts: {
     enabled: true,
     // Defaults mirror DEFAULT_APPROVAL_TIMEOUT_POLICY in
@@ -216,6 +224,50 @@ function objectOrUndefined<T extends object>(value: T | null | undefined): T | u
   return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined
 }
 
+function normalizeUpdateChangelog(value: unknown): ProductUpdateChangelog | undefined {
+  const record = objectOrUndefined(value as Record<string, unknown> | null | undefined)
+  if (!record || typeof record.version !== 'string' || !record.version.trim()) {
+    return undefined
+  }
+  const releaseNotes = record.releaseNotes
+  const normalized: ProductUpdateChangelog = {
+    version: record.version.trim()
+  }
+  if (typeof record.releaseName === 'string' && record.releaseName.trim()) {
+    normalized.releaseName = record.releaseName.trim()
+  }
+  if (typeof record.releaseDate === 'string' && record.releaseDate.trim()) {
+    normalized.releaseDate = record.releaseDate.trim()
+  }
+  if (typeof releaseNotes === 'string') {
+    normalized.releaseNotes = releaseNotes
+  } else if (Array.isArray(releaseNotes)) {
+    const notes = releaseNotes
+      .map((item) => {
+        const noteRecord = objectOrUndefined(item as Record<string, unknown> | null | undefined)
+        if (!noteRecord || typeof noteRecord.version !== 'string' || !noteRecord.version.trim()) {
+          return null
+        }
+        return {
+          version: noteRecord.version.trim(),
+          note: typeof noteRecord.note === 'string' ? noteRecord.note : null
+        }
+      })
+      .filter((item): item is { version: string; note: string | null } => item !== null)
+    if (notes.length > 0) {
+      normalized.releaseNotes = notes
+    }
+  }
+  return normalized
+}
+
+function normalizeSettingsFontFamily(value: unknown, fallback: string): string {
+  if (typeof value !== 'string') return fallback
+  const trimmed = value.trim()
+  if (!trimmed) return fallback
+  return trimmed === LEGACY_AGBENCH_FONT_STACK ? AGBENCH_DEFAULT_FONT_STACK : trimmed
+}
+
 function writeJson<T>(filePath: string, data: T) {
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`
   let fd: number | null = null
@@ -285,6 +337,36 @@ function runEventFilePath(runId: string): string {
   return path.join(runEventsDir, safeRunEventFileName(runId))
 }
 
+// Per-run artifact directory. Mirrors the path derivation in
+// appendRunStreamArtifact (the `.jsonl`-stripped run file name is used as a
+// dedicated directory holding stdout/stderr/stdin .log files for the run), so
+// every artifact for a given runId lives under exactly this path. Deriving it
+// from `safeRunEventFileName` keeps deletion in lockstep with creation.
+function runArtifactDirPath(runId: string): string {
+  return path.join(runArtifactsDir, safeRunEventFileName(runId).replace(/\.jsonl$/, ''))
+}
+
+// Best-effort, non-fatal cleanup of one run's on-disk forensic data: its
+// run-event `.jsonl` ledger and its artifact directory. Each removal is mapped
+// from a KNOWN runId via the deterministic safeRunEventFileName transform — we
+// never readdir-and-match-by-prefix, so a sibling run whose id is a prefix of
+// this one (e.g. `run-1` vs `run-1-extra`) can never be caught: the targets are
+// exact file/dir names (`run-1.jsonl` ≠ `run-1-extra.jsonl`). Missing files are
+// ignored so a partially-written run cannot abort the chat deletion.
+function deleteRunForensicFiles(runId: string): void {
+  if (!runId) return
+  try {
+    fs.rmSync(runEventFilePath(runId), { force: true })
+  } catch (e) {
+    console.error(`Failed to delete run-event file for run ${runId}`, e)
+  }
+  try {
+    fs.rmSync(runArtifactDirPath(runId), { recursive: true, force: true })
+  } catch (e) {
+    console.error(`Failed to delete run artifacts for run ${runId}`, e)
+  }
+}
+
 function readRunEventFile(filePath: string): RunEventRecord[] {
   try {
     if (!fs.existsSync(filePath)) return []
@@ -370,6 +452,7 @@ export class AppStore {
     const storedWelcomeHeatmapPrefs = objectOrUndefined(stored.welcomeHeatmapPrefs)
     const storedApprovalTimeouts = objectOrUndefined(stored.approvalTimeouts)
     const storedApprovalTimeoutProviderMs = objectOrUndefined(storedApprovalTimeouts?.perProviderMs)
+    const pendingUpdateChangelog = normalizeUpdateChangelog(stored.pendingUpdateChangelog)
     return {
       ...defaultSettings,
       ...stored,
@@ -384,6 +467,14 @@ export class AppStore {
             ? null
             : defaultSettings.defaultGeminiAuthProfileId,
       geminiAuthProfiles: Array.isArray(stored.geminiAuthProfiles) ? stored.geminiAuthProfiles : [],
+      transcriptFontFamily: normalizeSettingsFontFamily(
+        stored.transcriptFontFamily,
+        defaultSettings.transcriptFontFamily || AGBENCH_DEFAULT_FONT_STACK
+      ),
+      composerFontFamily: normalizeSettingsFontFamily(
+        stored.composerFontFamily,
+        defaultSettings.composerFontFamily || 'match-transcript'
+      ),
       // Phase M1 — coerce any non-enum value (missing, typo'd, legacy)
       // back to the safe default so the eventual API-vs-CLI dispatch
       // logic never sees an unexpected mode.
@@ -397,7 +488,10 @@ export class AppStore {
         ...defaultSettings.agenticServices,
         ...(stored.agenticServices || {})
       },
-      dashboardStatPrefs: storedDashboardStatPrefs ? { ...storedDashboardStatPrefs } : undefined,
+      dashboardStatPrefs: {
+        ...(defaultSettings.dashboardStatPrefs || {}),
+        ...(storedDashboardStatPrefs || {})
+      },
       welcomeHeatmapPrefs: {
         ...defaultSettings.welcomeHeatmapPrefs,
         ...(storedWelcomeHeatmapPrefs || {})
@@ -409,6 +503,12 @@ export class AppStore {
         stored.nativeSubAgentRequests === 'provider' || stored.nativeSubAgentRequests === 'agbench'
           ? stored.nativeSubAgentRequests
           : 'ask',
+      lastSeenChangelogVersion:
+        typeof stored.lastSeenChangelogVersion === 'string' &&
+        stored.lastSeenChangelogVersion.trim()
+          ? stored.lastSeenChangelogVersion.trim()
+          : undefined,
+      pendingUpdateChangelog,
       // Normalize: a stored non-boolean (e.g. an older settings file
       // where the field is missing) falls back to the default (true)
       // so the auto-resume behaviour is on for upgrading users.
@@ -872,6 +972,19 @@ export class AppStore {
   }
 
   static deleteChat(chatId: string) {
+    // Read the chat's KNOWN runs before unlinking so we can clean up its
+    // per-run forensic files (run-event ledger + artifacts) that would
+    // otherwise be orphaned on disk forever. Derived purely from this chat's
+    // own runIds (never a directory scan), so a sibling chat's similar/prefixed
+    // run files are guaranteed untouched. All cleanup is best-effort.
+    const chat = this.getChat(chatId)
+    const runs = Array.isArray(chat?.runs) ? chat.runs : []
+    for (const run of runs) {
+      if (run && typeof run.runId === 'string') {
+        deleteRunForensicFiles(run.runId)
+      }
+    }
+
     const chatPath = path.join(chatsDir, `${chatId}.json`)
     if (fs.existsSync(chatPath)) {
       fs.unlinkSync(chatPath)
diff --git a/src/main/store/types.ts b/src/main/store/types.ts
index b443bb35..0cf410e8 100644
--- a/src/main/store/types.ts
+++ b/src/main/store/types.ts
@@ -168,6 +168,23 @@ export type PermissionPresetId =
   | 'custom'
 export type CodexSandboxFallbackMode = 'ask_rerun' | 'off'
 export type ProductUpdateChannel = 'debug' | 'stable' | 'nightly'
+export interface ProductUpdateReleaseNoteInfo {
+  version: string
+  note: string | null
+}
+export type ProductUpdateReleaseNotes = string | ProductUpdateReleaseNoteInfo[]
+export interface ProductUpdateChangelog {
+  version: string
+  releaseName?: string
+  releaseDate?: string
+  releaseNotes?: ProductUpdateReleaseNotes
+}
+export interface ProductChangelogSnapshot {
+  currentVersion: string
+  lastSeenChangelogVersion?: string
+  pendingUpdateChangelog?: ProductUpdateChangelog
+  latestUpdateChangelog?: ProductUpdateChangelog
+}
 /** Phase M1 — picks which runtime path AGBench uses for Gemini runs.
  *
  *   - `'auto'` (default): use the API runtime when an API key /
@@ -999,6 +1016,8 @@ export type ProviderToolingCapabilityId =
   | Exclude<AgenticServiceId, 'subThreadDelegation'>
   | 'creativeApps'
   | 'networkAccess'
+  | 'elicit'
+  | 'delegate'
 
 export interface ProviderCapabilityWarning {
   id: string
@@ -1386,9 +1405,8 @@ export interface AppSettings {
      */
     dashboardEnabled?: boolean
     /**
-     * Welcome dashboard display size. Large preserves the existing full-size
-     * layout; small renders the same dashboard scaled to 30% and pinned to the
-     * top-right of the welcome surface.
+     * Welcome dashboard display size. Small is the default compact welcome
+     * treatment; large preserves the full-size layout.
      */
     dashboardSize?: 'large' | 'small'
   }
@@ -1402,9 +1420,9 @@ export interface AppSettings {
     externalActivityEnabled?: boolean
     /**
      * 1.0.72 — Layout for the welcome standalone heatmaps:
-     *   - 'stacked' (default): every enabled heatmap stacked vertically
+     *   - 'stacked': every enabled heatmap stacked vertically
      *     (the long-standing layout).
-     *   - 'single': one heatmap at a time, auto-cycling every 90s through
+     *   - 'single' (default): one heatmap at a time, auto-cycling every 90s through
      *     the enabled heatmaps (mirrors the dashboard tab auto-cycle).
      */
     layout?: 'single' | 'stacked'
@@ -1415,9 +1433,8 @@ export interface AppSettings {
    * containing a configured trigger keyword (default list +
    * `kimiSanitiserCustomKeywords`) is replaced with a redacted
    * placeholder before the Kimi process spawns. Other
-   * participants always see the unfiltered prompt. Default
-   * `false` — opt-in for users who hit Moonshot content_filter
-   * rejections on incidental world-news / geopolitics digressions. */
+   * participants always see the unfiltered prompt. Default `true`
+   * so Moonshot compatibility retries are available out of the box. */
   kimiSanitiserEnabled: boolean
   /** 1.0.5-EW26 — Newline-separated extra trigger keywords the
    * user wants the Kimi compatibility filter to catch on top of
@@ -1460,6 +1477,8 @@ export interface AppSettings {
   bridgeDaemonEnabled?: boolean
   codexSandboxFallback: CodexSandboxFallbackMode
   updateChannel: ProductUpdateChannel
+  lastSeenChangelogVersion?: string
+  pendingUpdateChangelog?: ProductUpdateChangelog
   /** Per-provider + main-authority approval timeout policy (Phase E1.1).
    * When an approval enters the pending registry, a timer fires after
    * the matching ms value and auto-denies the request. `enabled: false`
diff --git a/src/preload/index.d.ts b/src/preload/index.d.ts
index 9b8c54c6..33e07d75 100644
--- a/src/preload/index.d.ts
+++ b/src/preload/index.d.ts
@@ -37,6 +37,7 @@ import {
   ProductCrashRecord,
   ProductDiagnosticsExportResult,
   ProductOperationsStatus,
+  ProductChangelogSnapshot,
   RuntimeProfile,
   HandoffCard,
   HandoffCardFilter,
@@ -47,6 +48,12 @@ import type { UpdateStateSnapshot } from '../main/UpdateService'
 import type { GrokUsageSnapshot } from '../main/grok/GrokUsage'
 import type { AppShellStatsSnapshot } from '../main/services/AppShellStatsService'
 import type { SessionCheckpointRecord } from '../main/checkpoints/SessionCheckpoint'
+import type {
+  GitPrReadiness,
+  GitPrSummary,
+  GitRepositorySnapshot,
+  GitResult
+} from '../main/services/GitService'
 
 type GeminiCapabilityKind = 'mcp' | 'extensions' | 'skills' | 'agents'
 type GeminiCapabilityFormat = 'json' | 'raw' | 'error'
@@ -315,8 +322,40 @@ declare global {
       getCodexUsageSnapshot: () => Promise<any>
       getExternalUsage: () => Promise<UsageRecord[]>
       probeGrokUsage: () => Promise<GrokUsageSnapshot>
+      gitSnapshot: (payload: {
+        workspacePath?: string
+        repoPath?: string
+      }) => Promise<GitResult<GitRepositorySnapshot>>
+      gitStage: (payload: {
+        workspacePath?: string
+        repoPath?: string
+        paths?: string[]
+        all?: boolean
+        update?: boolean
+        patch?: string
+      }) => Promise<GitResult<GitRepositorySnapshot>>
+      gitCommit: (payload: {
+        workspacePath?: string
+        repoPath?: string
+        message: string
+      }) => Promise<GitResult<GitRepositorySnapshot>>
+      gitPush: (payload: {
+        workspacePath?: string
+        repoPath?: string
+        setUpstream?: boolean
+        remote?: string
+      }) => Promise<GitResult<GitRepositorySnapshot>>
+      githubPrStatus: (payload: {
+        workspacePath?: string
+        repoPath?: string
+      }) => Promise<GitResult<GitPrSummary>>
+      githubPrReadiness: (payload: {
+        workspacePath?: string
+        repoPath?: string
+      }) => Promise<GitResult<GitPrReadiness>>
       createGithubPr: (payload: {
         workspacePath?: string
+        repoPath?: string
         title?: string
         body?: string
         draft?: boolean
@@ -363,7 +402,11 @@ declare global {
         numTurns?: number
       ) => Promise<any>
       startAgentReview: (provider: ProviderId, threadId: string, params?: any) => Promise<any>
-      respondAgentApproval: (requestId: string, action: AgentApprovalAction) => Promise<boolean>
+      respondAgentApproval: (
+        requestId: string,
+        action: AgentApprovalAction,
+        intentNote?: string
+      ) => Promise<boolean>
       writeGeminiInput: (data: string) => Promise<boolean>
       getDiff: (workspace: string) => Promise<{
         type: 'not_repo' | 'no_changes' | 'changes' | 'error'
@@ -481,7 +524,9 @@ declare global {
       downloadUpdate: () => Promise<UpdateStateSnapshot>
       installUpdateOnQuit: () => Promise<UpdateStateSnapshot>
       installUpdateNow: () => Promise<UpdateStateSnapshot>
-      onUpdateStatusChanged: (callback: (snapshot: UpdateStateSnapshot) => void) => void
+      changelogSnapshot: () => Promise<ProductChangelogSnapshot>
+      markChangelogSeen: (version: string) => Promise<ProductChangelogSnapshot>
+      onUpdateStatusChanged: (callback: (snapshot: UpdateStateSnapshot) => void) => () => void
       bridgeNetworkingStatus: () => Promise<{
         lan: {
           enabled: boolean
diff --git a/src/preload/index.ts b/src/preload/index.ts
index eb641f35..f22d170b 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -6,6 +6,12 @@ import type {
 } from '../main/store/types'
 import type { AppShellStatsSnapshot } from '../main/services/AppShellStatsService'
 import type { SessionCheckpointRecord } from '../main/checkpoints/SessionCheckpoint'
+import type {
+  GitPrReadiness,
+  GitPrSummary,
+  GitRepositorySnapshot,
+  GitResult
+} from '../main/services/GitService'
 
 type ComposerImageAttachment = {
   id?: string
@@ -132,8 +138,31 @@ const api = {
   getCodexUsageSnapshot: () => ipcRenderer.invoke('get-codex-usage-snapshot'),
   getExternalUsage: () => ipcRenderer.invoke('get-external-usage'),
   probeGrokUsage: () => ipcRenderer.invoke('grok-usage:probe'),
+  gitSnapshot: (payload: { workspacePath?: string; repoPath?: string }) =>
+    ipcRenderer.invoke('git:snapshot', payload) as Promise<GitResult<GitRepositorySnapshot>>,
+  gitStage: (payload: {
+    workspacePath?: string
+    repoPath?: string
+    paths?: string[]
+    all?: boolean
+    update?: boolean
+    patch?: string
+  }) => ipcRenderer.invoke('git:stage', payload) as Promise<GitResult<GitRepositorySnapshot>>,
+  gitCommit: (payload: { workspacePath?: string; repoPath?: string; message: string }) =>
+    ipcRenderer.invoke('git:commit', payload) as Promise<GitResult<GitRepositorySnapshot>>,
+  gitPush: (payload: {
+    workspacePath?: string
+    repoPath?: string
+    setUpstream?: boolean
+    remote?: string
+  }) => ipcRenderer.invoke('git:push', payload) as Promise<GitResult<GitRepositorySnapshot>>,
+  githubPrStatus: (payload: { workspacePath?: string; repoPath?: string }) =>
+    ipcRenderer.invoke('github:pr-status', payload) as Promise<GitResult<GitPrSummary>>,
+  githubPrReadiness: (payload: { workspacePath?: string; repoPath?: string }) =>
+    ipcRenderer.invoke('github:pr-readiness', payload) as Promise<GitResult<GitPrReadiness>>,
   createGithubPr: (payload: {
     workspacePath?: string
+    repoPath?: string
     title?: string
     body?: string
     draft?: boolean
@@ -177,8 +206,11 @@ const api = {
       | 'cancel'
       | 'grantExternalPathRead'
       | 'grantExternalPathEdit'
-      | 'declineExternalPath'
-  ) => ipcRenderer.invoke('respond-agent-approval', requestId, action),
+      | 'declineExternalPath',
+    // Order-4 — optional one-line "why" note. Persisted onto the
+    // approval-ledger row's metadata; never required.
+    intentNote?: string
+  ) => ipcRenderer.invoke('respond-agent-approval', requestId, action, intentNote),
   writeGeminiInput: (data: string) => ipcRenderer.invoke('write-gemini-input', data),
   getDiff: (workspace: string) => ipcRenderer.invoke('get-diff', workspace),
   openWorkspacePopout: (input: { kind: 'file-editor' | 'diff-studio'; workspacePath: string }) =>
@@ -378,8 +410,13 @@ const api = {
   downloadUpdate: () => ipcRenderer.invoke('download-update'),
   installUpdateOnQuit: () => ipcRenderer.invoke('install-update-on-quit'),
   installUpdateNow: () => ipcRenderer.invoke('install-update-now'),
+  changelogSnapshot: () => ipcRenderer.invoke('changelog-snapshot'),
+  markChangelogSeen: (version: string) => ipcRenderer.invoke('mark-changelog-seen', version),
   onUpdateStatusChanged: (callback: (snapshot: unknown) => void) => {
-    ipcRenderer.on('update-status-changed', (_event, snapshot) => callback(snapshot))
+    const listener = (_event: Electron.IpcRendererEvent, snapshot: unknown): void =>
+      callback(snapshot)
+    ipcRenderer.on('update-status-changed', listener)
+    return () => ipcRenderer.removeListener('update-status-changed', listener)
   },
   bridgeFinalizePairing: (sessionID: string, userConfirmed: boolean) =>
     ipcRenderer.invoke('bridge-finalize-pairing', sessionID, userConfirmed),
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 50dddd5c..9a3225f7 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -52,6 +52,7 @@ import {
   RunRecoveryRecord,
   ProductOperationsStatus,
   ProductUpdateChannel,
+  ProductChangelogSnapshot,
   ChatScope,
   RuntimeProfile,
   HandoffCard,
@@ -96,7 +97,10 @@ import { WorkspaceActivityHeatmap } from './components/WorkspaceActivityHeatmap'
 import { WelcomeHeatmaps, type WelcomeHeatmapSlot } from './components/WelcomeHeatmaps'
 import { useAppearance } from './hooks/useAppearance'
 import { useExternalPathRepoMetadata } from './hooks/useExternalPathRepoMetadata'
+import { useUpdateStatus } from './hooks/useUpdateStatus'
 import { ExternalPathAboveRow } from './components/ExternalPathAboveRow'
+import { GitCommitControls } from './components/GitCommitControls'
+import type { GitRepositorySnapshot } from '../../main/services/GitService'
 import { ProviderBadgeIcon, Sidebar } from './components/Sidebar'
 import { Inspector } from './components/Inspector'
 import { SettingsPanel, type SettingsTab } from './components/SettingsPanel'
@@ -104,6 +108,8 @@ import { SettingsSidebar } from './components/SettingsSidebar'
 import { SubThreadCreator } from './components/SubThreadCreator'
 import { FirstLaunchSheet } from './components/FirstLaunchSheet'
 import { BugReportSheet, type BugReportSubmission } from './components/BugReportSheet'
+import { ChangelogSheet } from './components/ChangelogSheet'
+import { UpdatePill } from './components/UpdatePill'
 import {
   WorkSessionSetupSheet,
   type WorkSessionSetupConfirmInput
@@ -124,6 +130,7 @@ import {
   FolderSymbolIcon,
   GhostCompanionIcon,
   LinkCircleSymbolIcon,
+  MascotGhost,
   ModelSymbolIcon,
   OverviewSymbolIcon,
   PermissionSymbolIcon,
@@ -175,7 +182,10 @@ import {
   rebindWelcomeEnsembleChatToGlobal,
   rebindWelcomeEnsembleChatToWorkspace
 } from './lib/ensembleWelcomeWorkspace'
-import { withSessionActivityLedger } from './lib/sessionActivityLedger'
+import {
+  deriveParticipantRenameContinuity,
+  withSessionActivityLedger
+} from './lib/sessionActivityLedger'
 // EnsembleSetupSheet retired in 1.0.3 — the bottom-pinned modal had a
 // z-index race with the picker popovers and the form felt foreign. All
 // per-participant config now lives inline in the composer above-row
@@ -291,9 +301,11 @@ import {
 } from './lib/usageStats'
 import {
   buildEnsembleRoundSummaryRows,
+  buildEscalationChips,
   buildRunCompleteSummaryRows,
   formatWorkDuration
 } from './lib/runCompleteSummary'
+import { fetchProviderRates, type RendererProviderRates } from './lib/providerRateEstimate'
 import {
   getMemoryPreviewText,
   mergeCommandPaletteItems,
@@ -878,6 +890,7 @@ function WelcomeUsageDashboard({
           replaces the stat grid / chart inside. */}
       {!data.hasActivity ? (
         <div className="welcome-usage-empty welcome-usage-empty--range">
+          <MascotGhost size={34} />
           <strong>No activity in the last 30 days.</strong>
           <span>Kick off a run on this workspace to start filling the dashboard.</span>
         </div>
@@ -2707,6 +2720,20 @@ type TranscriptPanelProps = {
    * is disengaged. A stable ref, so it never perturbs the memo.
    */
   autoFollowRef?: React.MutableRefObject<boolean>
+  /**
+   * 1.0.7 — display currency + conservative-overestimate bias (Settings →
+   * General), threaded in so the ensemble run-complete card's Cost row routes
+   * through `formatCost`. Defaults to USD / 0 when omitted.
+   */
+  currency?: DisplayCurrency
+  currencyOverestimatePercent?: number
+  /**
+   * 1.0.7 — per-provider rate table (USD per 1M tokens) from the
+   * `providerRates:get` IPC. Used ONLY to project a clearly-badged
+   * API-equivalent cost for subscription/credit seats that emit no
+   * `cost_usd` (Codex / Grok / Cursor). Absent → no estimate.
+   */
+  providerRates?: RendererProviderRates
 }
 
 /**
@@ -4148,7 +4175,10 @@ export const TranscriptPanel = memo(
     copiedId,
     copy,
     virtualize,
-    autoFollowRef
+    autoFollowRef,
+    currency,
+    currencyOverestimatePercent,
+    providerRates
   }: TranscriptPanelProps) {
     const visibleMessages = useMemo(() => {
       const source = isWelcomeChat ? EMPTY_CHAT_MESSAGES : messages
@@ -4172,10 +4202,25 @@ export const TranscriptPanel = memo(
       // last speaker's), round-envelope duration, and summed tokens.
       // Solo chats: the original single-run summary.
       if (currentChat?.chatKind === 'ensemble' && currentChat.ensemble?.activeRound) {
-        return buildEnsembleRoundSummaryRows(currentChat, runCompleteNotice?.exitCode !== 0)
+        return buildEnsembleRoundSummaryRows(currentChat, runCompleteNotice?.exitCode !== 0, {
+          currency,
+          overestimatePercent: currencyOverestimatePercent,
+          providerRates
+        })
       }
       return buildRunCompleteSummaryRows(currentRun)
-    }, [currentChat, currentRun, runCompleteNotice?.exitCode])
+    }, [
+      currentChat,
+      currentRun,
+      runCompleteNotice?.exitCode,
+      currency,
+      currencyOverestimatePercent,
+      providerRates
+    ])
+    // 1.0.7 (M5 surfacing) — advisory chips for the dark-shipped escalation
+    // signals on the current round. Read-only: the orchestrator persists
+    // these; we just surface label + recommended action.
+    const escalationChips = useMemo(() => buildEscalationChips(currentChat), [currentChat])
     const runBoundaryByMessageId = useMemo(() => {
       const runs = currentChat?.runs || []
       const runById = new Map<string, ChatRun>()
@@ -4404,6 +4449,19 @@ export const TranscriptPanel = memo(
                           currentProviderLabel,
                           currentProvider
                         )
+                        // 1.0.7 — participant-rename continuity. The
+                        // header keeps the FROZEN role label; this quiet
+                        // badge tells the reader the seat has since been
+                        // renamed (e.g. "Planner" here is the seat now
+                        // called "Architect") so they can follow one
+                        // participant across a mid-session rename. Ledger-
+                        // preferred, with a frozen-vs-current fallback —
+                        // see deriveParticipantRenameContinuity.
+                        const renameContinuity = deriveParticipantRenameContinuity(
+                          msg,
+                          currentChat?.ensemble?.participants,
+                          currentChat?.ensemble?.sessionActivityLedger
+                        )
                         return (
                           <div className={`message-meta${provider ? ` provider-${provider}` : ''}`}>
                             <span className="message-meta-label">{label}</span>
@@ -4416,6 +4474,15 @@ export const TranscriptPanel = memo(
                                 {modelBadge}
                               </span>
                             )}
+                            {renameContinuity && (
+                              <span
+                                className="message-meta-renamed-from"
+                                title={`Now: ${renameContinuity.currentRole}`}
+                                aria-label={`Renamed from ${renameContinuity.fromRole}; now ${renameContinuity.currentRole}`}
+                              >
+                                renamed from {renameContinuity.fromRole}
+                              </span>
+                            )}
                           </div>
                         )
                       }
@@ -4721,6 +4788,22 @@ export const TranscriptPanel = memo(
                   </div>
                 </div>
               )}
+              {escalationChips.length > 0 && (
+                <div
+                  className="ensemble-escalation-advisory"
+                  role="status"
+                  aria-label="Round advisories"
+                >
+                  {escalationChips.map((chip) => (
+                    <div key={chip.id} className={`ensemble-escalation-chip tone-${chip.tone}`}>
+                      <span className="ensemble-escalation-chip-label">{chip.label}</span>
+                      {chip.action && (
+                        <span className="ensemble-escalation-chip-action">{chip.action}</span>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              )}
               <div className="file-change-summary-card">
                 <div className="file-change-summary-header">
                   <strong>File changes</strong>
@@ -4885,6 +4968,10 @@ function App(): React.JSX.Element {
   // transient "Copied" state consistent across the transcript.
   const { copiedId, copy } = useCopyFeedback()
   const [settings, setSettings] = useState<AppSettings | null>(null)
+  // 1.0.7 — per-provider rate table (USD per 1M tokens) for the ensemble
+  // run-complete card's projected cost estimate. Hydrated once at mount from
+  // the `providerRates:get` IPC; empty until then (no estimate shown).
+  const [providerRates, setProviderRates] = useState<RendererProviderRates>({})
   const [chatContextTurns, setChatContextTurns] = useState<number>(DEFAULT_CONTEXT_TURNS)
   const [workspaces, setWorkspaces] = useState<WorkspaceRecord[]>([])
   const [workspacesHydrated, setWorkspacesHydrated] = useState(false)
@@ -5013,7 +5100,7 @@ function App(): React.JSX.Element {
   )
   const [codexSandboxFallback, setCodexSandboxFallback] =
     useState<CodexSandboxFallbackMode>('ask_rerun')
-  const [updateChannel, setUpdateChannel] = useState<ProductUpdateChannel>('debug')
+  const [updateChannel, setUpdateChannel] = useState<ProductUpdateChannel>('stable')
   const [approvalTimeouts, setApprovalTimeouts] = useState<AppSettings['approvalTimeouts']>({
     enabled: true,
     perProviderMs: { gemini: 120_000, codex: 30_000, claude: 120_000, kimi: 60_000 },
@@ -5200,6 +5287,25 @@ function App(): React.JSX.Element {
       cancelled = true
     }
   }, [])
+  /**
+   * 1.0.7 — one-shot fetch of the per-provider rate table over the existing
+   * `providerRates:get` IPC. Powers the ensemble run-complete card's projected
+   * cost ESTIMATE for subscription/credit seats (Codex / Grok / Cursor) that
+   * report no `cost_usd`. The rates are USD per 1M tokens and barely change
+   * during a session, so one read at mount is enough; on failure we leave the
+   * map empty and simply render no estimate.
+   */
+  useEffect(() => {
+    let cancelled = false
+    void (async () => {
+      const rates = await fetchProviderRates()
+      if (cancelled) return
+      setProviderRates(rates)
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [])
   /**
    * Inline bug-report sheet. The tester opens this from the
    * "!" button next to the onboarding `?` button, describes whatever
@@ -5208,6 +5314,24 @@ function App(): React.JSX.Element {
    * state — the sheet
    * resets every open. */
   const [showBugReportSheet, setShowBugReportSheet] = useState(false)
+  const updateStatus = useUpdateStatus()
+  const [showChangelogSheet, setShowChangelogSheet] = useState(false)
+  const [changelogSnapshot, setChangelogSnapshot] = useState<ProductChangelogSnapshot | null>(null)
+  const autoChangelogOpenedRef = useRef(false)
+  const refreshChangelogSnapshot =
+    useCallback(async (): Promise<ProductChangelogSnapshot | null> => {
+      try {
+        const next = await window.api.changelogSnapshot()
+        setChangelogSnapshot(next)
+        return next
+      } catch {
+        return null
+      }
+    }, [])
+  const handleOpenChangelogSheet = useCallback(() => {
+    setShowChangelogSheet(true)
+    void refreshChangelogSnapshot()
+  }, [refreshChangelogSnapshot])
   /** 1.0.4-AK2 — Work Session setup sheet open/closed state.
    * Opened by the composer's "Work Session" button (alongside
    * Turn/Continuous). On confirm, persists the WorkSessionConfig
@@ -5241,6 +5365,27 @@ function App(): React.JSX.Element {
       cancelled = true
     }
   }, [])
+  useEffect(() => {
+    void refreshChangelogSnapshot()
+  }, [refreshChangelogSnapshot])
+  useEffect(() => {
+    if (autoChangelogOpenedRef.current) return
+    if (!changelogSnapshot || appVersion === 'unknown') return
+    if (changelogSnapshot.pendingUpdateChangelog?.version !== appVersion) return
+    if (changelogSnapshot.lastSeenChangelogVersion === appVersion) return
+    autoChangelogOpenedRef.current = true
+    setShowChangelogSheet(true)
+  }, [appVersion, changelogSnapshot])
+  const handleDismissChangelogSheet = useCallback(() => {
+    setShowChangelogSheet(false)
+    const pendingVersion = changelogSnapshot?.pendingUpdateChangelog?.version
+    if (!pendingVersion || pendingVersion !== appVersion) return
+    if (changelogSnapshot?.lastSeenChangelogVersion === appVersion) return
+    void window.api
+      .markChangelogSeen(appVersion)
+      .then((next) => setChangelogSnapshot(next))
+      .catch(() => {})
+  }, [appVersion, changelogSnapshot])
   const handleSubmitBugReport = useCallback(
     async (submission: BugReportSubmission): Promise<void> => {
       const api = window.api as typeof window.api & {
@@ -5337,6 +5482,13 @@ function App(): React.JSX.Element {
   const [pendingApprovalQueueByChatId, setPendingApprovalQueueByChatId] = useState<
     Record<string, AgentApprovalRequest[]>
   >({})
+  // Order-4 — optional one-line "why" note the user can attach to an
+  // approval decision. Rides the existing approval-ledger metadata
+  // channel as `{ intentNote }` (no schema migration). At most one
+  // approval card is on screen at a time (the queue head), so a single
+  // string suffices; it's cleared whenever an approval resolves so the
+  // next queued request starts blank.
+  const [intentNote, setIntentNote] = useState('')
   const [isSendConfirming, setIsSendConfirming] = useState(false)
   // 1.0.6-EW66-1d — Create-PR state is now keyed by workspace PATH
   // so the primary workspace and each WRITE-access additional
@@ -5354,6 +5506,20 @@ function App(): React.JSX.Element {
   const setCreatePrStateFor = (path: string, next: CreatePrState): void =>
     setCreatePrStateByPath((prev) => ({ ...prev, [path]: next }))
   const [diffActionMenuOpen, setDiffActionMenuOpen] = useState(false)
+  // Live git snapshot lifted out of the GitCommitControls menu so the
+  // above-bar header can surface real repo state (branch, changed-file
+  // count, staged/unstaged, push/PR readiness) sourced from
+  // `gitSnapshot` rather than the stale `currentWorkspace.branch` /
+  // tool-derived diff counts. Null until the menu opens (lazy fetch) or
+  // the repo read fails.
+  const [primaryGitSnapshot, setPrimaryGitSnapshot] = useState<GitRepositorySnapshot | null>(null)
+  // Drop the lifted snapshot whenever the workspace changes so a stale
+  // repo's branch/counts never bleed into a freshly-switched workspace
+  // before its menu is reopened.
+  const currentWorkspacePath = currentWorkspace?.path
+  useEffect(() => {
+    setPrimaryGitSnapshot(null)
+  }, [currentWorkspacePath])
   const [isComposerDragOver, setIsComposerDragOver] = useState(false)
   type AttachedWindowSnapshot = {
     handleID: string
@@ -6750,7 +6916,7 @@ function App(): React.JSX.Element {
     setGeminiMcpBridgeEnabledState(Boolean(s.geminiMcpBridgeEnabled))
     setGeminiMcpBridgeStatus(s.geminiMcpBridgeLastStatus || null)
     setCodexSandboxFallback(s.codexSandboxFallback || 'ask_rerun')
-    setUpdateChannel(s.updateChannel || 'debug')
+    setUpdateChannel(s.updateChannel || 'stable')
     if (s.approvalTimeouts) {
       setApprovalTimeouts(s.approvalTimeouts)
     }
@@ -8073,12 +8239,12 @@ function App(): React.JSX.Element {
     }
   }
 
- /**
-  * Keep a ref to the *latest* `refreshUsageSummary` closure so the
-  * autonomous polling effect (below) doesn't need to depend on `codexStatus`
-  * and tear the timer down on every status mutation.
-  */
-  
+  /**
+   * Keep a ref to the *latest* `refreshUsageSummary` closure so the
+   * autonomous polling effect (below) doesn't need to depend on `codexStatus`
+   * and tear the timer down on every status mutation.
+   */
+
   refreshUsageSummaryRef.current = refreshUsageSummary
 
   const handleSelectWorkspace = async () => {
@@ -13399,8 +13565,13 @@ function App(): React.JSX.Element {
   }
 
   const handleAgentApprovalAction = async (requestId: string, action: AgentApprovalAction) => {
+    // Order-4 — capture the optional intent note (trimmed) at decision
+    // time and pass it down to the IPC, which stamps it onto the ledger
+    // row's metadata. Empty stays undefined so we never persist a blank
+    // note. Always optional — never gates the decision.
+    const noteForDecision = intentNote.trim() || undefined
     try {
-      await window.api.respondAgentApproval(requestId, action)
+      await window.api.respondAgentApproval(requestId, action, noteForDecision)
       setRawLogs((prev) => [
         ...prev,
         {
@@ -13430,6 +13601,9 @@ function App(): React.JSX.Element {
       // approval so this distinction didn't matter.
       const composerChatId = getCurrentComposerStateChatId()
       setPendingAgentApproval((prev) => (prev?.id === requestId ? null : prev))
+      // Order-4 — reset the intent note so the next queued approval
+      // (or the next request entirely) starts with an empty field.
+      setIntentNote('')
       if (composerChatId) {
         advanceApprovalQueueForChat(composerChatId)
       }
@@ -15654,19 +15828,12 @@ function App(): React.JSX.Element {
     window.setTimeout(() => setCreatePrStateFor(workspacePath, { status: 'idle' }), 6000)
   }
 
-  const handlePrimeCommitChangesPrompt = () => {
-    const fileCount = latestRunDiffStats.filesChanged
-    const diffSummary =
-      fileCount > 0
-        ? `${fileCount} ${fileCount === 1 ? 'file' : 'files'} changed (+${latestRunDiffStats.additions} -${latestRunDiffStats.deletions})`
-        : 'the current workspace changes'
-    setPrompt(
-      `Commit ${diffSummary}. Review the diff first, choose a concise commit message, then run the commit.`
-    )
-    window.requestAnimationFrame(() => {
-      composerTextareaRef.current?.focus()
-    })
-  }
+  // Phase Git-U1 — `handlePrimeCommitChangesPrompt` (which injected a
+  // "Commit N files… review the diff, then run the commit" prompt at the
+  // agent) has been removed. Committing is now a real user-driven flow
+  // via GitCommitControls (gitSnapshot → gitStage → gitCommit) in the
+  // composer above-bar's diff-action menu, so the model is no longer
+  // asked to drive git on the user's behalf.
 
   // Composer-unification (Phase J1): Gemini's standalone /stats, /help,
   // GEMINI.md, /restore, persistent-session and checkpoints buttons are
@@ -16183,6 +16350,16 @@ function App(): React.JSX.Element {
             >
               <GhostCompanionIcon />
             </button>
+            <button
+              className={`chat-corner-btn chat-corner-btn-changelog ${showChangelogSheet ? 'active' : ''}`}
+              type="button"
+              onClick={handleOpenChangelogSheet}
+              title={showChangelogSheet ? 'Hide changelog sheet' : 'Open changelog sheet'}
+              aria-label="Toggle changelog sheet"
+              aria-pressed={showChangelogSheet}
+            >
+              <span className="chat-corner-symbol">i</span>
+            </button>
             {/*
               First-launch onboarding sheet re-opener. The sheet
               auto-shows on a fresh install and stays available
@@ -16220,6 +16397,7 @@ function App(): React.JSX.Element {
             >
               <span className="chat-corner-symbol">!</span>
             </button>
+            <UpdatePill snapshot={updateStatus.snapshot} onOpen={handleOpenChangelogSheet} />
           </div>
 
           <div className="chat-corner-controls chat-corner-controls-right">
@@ -16497,6 +16675,9 @@ function App(): React.JSX.Element {
                 copiedId={copiedId}
                 copy={copy}
                 autoFollowRef={autoFollowRef}
+                currency={displayCurrency}
+                currencyOverestimatePercent={overestimatePercent}
+                providerRates={providerRates}
               />
             </>
           )}
@@ -16889,8 +17070,17 @@ function App(): React.JSX.Element {
                         <span>
                           {currentWorkspace.displayName}
                           {' · '}
+                          {/* Phase Git-U1 — prefer the LIVE branch from
+                            gitSnapshot (populated once the diff-action menu
+                            has been opened); fall back to the workspace
+                            record's cached branch before the first read. A
+                            detached snapshot reads "detached HEAD". */}
                           <em className="composer-above-bar-secondary-branch">
-                            {currentWorkspace?.branch || 'detached'}
+                            {primaryGitSnapshot
+                              ? primaryGitSnapshot.detached
+                                ? 'detached HEAD'
+                                : primaryGitSnapshot.branch || 'detached'
+                              : currentWorkspace?.branch || 'detached'}
                           </em>
                         </span>
                       </span>
@@ -16942,6 +17132,64 @@ function App(): React.JSX.Element {
                           </span>
                         )}
                       </span>
+                      {/* Phase Git-U1 — live git-state pill driven by
+                        gitSnapshot (populated once the diff-action menu has
+                        been opened). Surfaces staged/unstaged state and
+                        push/PR readiness right in the header so the user can
+                        see what the Review/Commit/Create-PR menu will act on
+                        without opening it. Rendered only once a snapshot is
+                        in hand so the header stays stable pre-read. */}
+                      {primaryGitSnapshot &&
+                        (() => {
+                          const c = primaryGitSnapshot.counts
+                          const stagedTitle = primaryGitSnapshot.clean
+                            ? 'Working tree clean'
+                            : `${c.changed} changed · ${c.staged} staged · ${c.unstaged} unstaged${
+                                c.untracked > 0 ? ` · ${c.untracked} new` : ''
+                              }`
+                          const needsPush =
+                            !primaryGitSnapshot.detached &&
+                            !!primaryGitSnapshot.branch &&
+                            (!primaryGitSnapshot.upstream || primaryGitSnapshot.ahead > 0)
+                          const prReady =
+                            !primaryGitSnapshot.detached &&
+                            !!primaryGitSnapshot.branch &&
+                            !!primaryGitSnapshot.remoteUrl
+                          return (
+                            <span
+                              className="composer-git-state-pill"
+                              title={stagedTitle}
+                              data-git-clean={primaryGitSnapshot.clean ? 'true' : 'false'}
+                            >
+                              {primaryGitSnapshot.clean ? (
+                                <span className="composer-git-state-clean">clean</span>
+                              ) : c.staged > 0 ? (
+                                <span className="composer-git-state-staged">{c.staged} staged</span>
+                              ) : (
+                                <span className="composer-git-state-unstaged">unstaged</span>
+                              )}
+                              {needsPush ? (
+                                <span
+                                  className="composer-git-state-flag is-push"
+                                  title={
+                                    primaryGitSnapshot.upstream
+                                      ? `${primaryGitSnapshot.ahead} commit(s) to push`
+                                      : 'No upstream — push to set one'
+                                  }
+                                >
+                                  push
+                                </span>
+                              ) : prReady ? (
+                                <span
+                                  className="composer-git-state-flag is-pr"
+                                  title="Branch is pushed and ready for a PR"
+                                >
+                                  PR ready
+                                </span>
+                              ) : null}
+                            </span>
+                          )
+                        })()}
                       {/*
                     Composer-unification (Phase J1): once the chat has
                     activity, External Path + Worktree migrate from the
@@ -16966,6 +17214,13 @@ function App(): React.JSX.Element {
                         // 1.0.6-EW66-1d — primary workspace's PR state is now
                         // read from the per-path map keyed by its own path.
                         const primaryPrState = getCreatePrState(currentWorkspace?.path)
+                        // Phase Git-U1 — the trigger button keeps "Review
+                        // changes" as the FIRST/primary action whenever there's
+                        // a diff (the canonical safety entry point); it falls
+                        // back to the PR label otherwise. The menu it opens is
+                        // now the real user-driven GitCommitControls (status +
+                        // review + stage/commit + gated PR) — no more agent
+                        // prompt-injection for committing.
                         const createPrLabel =
                           primaryPrState.status === 'pending'
                             ? 'Creating…'
@@ -16987,60 +17242,25 @@ function App(): React.JSX.Element {
                               aria-expanded={diffActionMenuOpen}
                               title={
                                 primaryPrState.message ||
-                                'Choose what to do with the current workspace changes'
+                                'Review, commit, or open a PR for the current workspace'
                               }
                             >
                               {primaryLabel}
                             </button>
                             {diffActionMenuOpen && (
                               <div className="composer-diff-action-menu" role="menu">
-                                <button
-                                  type="button"
-                                  role="menuitem"
-                                  onClick={() => {
-                                    setDiffActionMenuOpen(false)
-                                    setRightTab('diff')
-                                  }}
-                                  disabled={!hasReviewableDiff}
-                                  title={
-                                    hasReviewableDiff
-                                      ? 'Open Diff Studio to review the latest run changes'
-                                      : 'No latest run diff is available yet'
-                                  }
-                                >
-                                  Review changes
-                                </button>
-                                <button
-                                  type="button"
-                                  role="menuitem"
-                                  onClick={() => {
-                                    setDiffActionMenuOpen(false)
-                                    handlePrimeCommitChangesPrompt()
-                                  }}
-                                  disabled={!hasReviewableDiff}
-                                  title={
-                                    hasReviewableDiff
-                                      ? 'Ask the current agent to review and commit these changes'
-                                      : 'No latest run diff is available to commit yet'
-                                  }
-                                >
-                                  Commit Changes
-                                </button>
-                                <button
-                                  type="button"
-                                  role="menuitem"
-                                  onClick={() => {
-                                    setDiffActionMenuOpen(false)
+                                <GitCommitControls
+                                  workspacePath={currentWorkspace?.path}
+                                  open={diffActionMenuOpen}
+                                  hasReviewableDiff={hasReviewableDiff}
+                                  onReviewChanges={() => setRightTab('diff')}
+                                  onClose={() => setDiffActionMenuOpen(false)}
+                                  onCreatePr={() =>
                                     void handleCreateGithubPr(currentWorkspace?.path)
-                                  }}
-                                  disabled={primaryPrState.status === 'pending'}
-                                  title={
-                                    primaryPrState.message ||
-                                    'Run `gh pr create --fill` against the current branch'
                                   }
-                                >
-                                  {createPrLabel}
-                                </button>
+                                  prState={primaryPrState}
+                                  onSnapshot={setPrimaryGitSnapshot}
+                                />
                               </div>
                             )}
                           </span>
@@ -17239,7 +17459,7 @@ function App(): React.JSX.Element {
                 Schedule + runtime-profile controls remain — those
                 are genuinely actionable.
               */}
-              {(scheduleControls || runtimeProfileControl) && (
+              {!isCurrentEnsembleChat && (scheduleControls || runtimeProfileControl) && (
                 <div className="composer-top-toggles">
                   {scheduleControls}
                   {runtimeProfileControl}
@@ -17309,1606 +17529,1642 @@ function App(): React.JSX.Element {
                 </div>
               )}
 
-              {(() => {
-                // Gate the overlay activation: render the highlight
-                // layer only when the prompt contains at least one
-                // RESOLVED `@Token`. Without this, the textarea's
-                // `color: transparent` zeros out the text in shells
-                // where the overlay's font/padding drifts from the
-                // textarea (Claude / Codex / Kimi etc. each override
-                // base padding). the maintainer hit this on the ensemble
-                // welcome screen — text invisible in Claude shell,
-                // vertical sync issues in others.
-                // 1.0.4 — drop the `isCurrentEnsembleChat` precondition.
-                // `hasResolvedMention` already self-guards on
-                // `participants.length === 0`, so non-ensemble chats
-                // are excluded naturally. The extra gate caused a
-                // regression on the ensemble welcome screen where
-                // `chatKind === 'ensemble'` evaluated false during
-                // some welcome-surface render passes — leaving typed
-                // tags as plain white text instead of bold +
-                // provider-tinted (the maintainer's "tags not lighting up"
-                // report). Now: anywhere participants ARE configured
-                // and a mention resolves, the overlay activates.
-                const composerHasMention = hasResolvedMention(
-                  prompt,
-                  currentChat?.ensemble?.participants || []
-                )
-                // 1.0.4 — sync epoch for the overlay's auto-metric
-                // mirror. Any change in the inputs below can shift
-                // the textarea's computed font / padding / border,
-                // so we encode them into a single string the
-                // overlay watches as a useLayoutEffect dep. The
-                // ResizeObserver inside the overlay handles every
-                // size-changing variation that happens between
-                // these explicit triggers.
-                const composerOverlaySyncEpoch = `${appearance.composerStyle}|${appearance.themeAppearance}|${isWelcomeChat ? 'welcome' : 'active'}`
-                return (
-                  <div className="composer-textarea-wrap">
-                    {composerHasMention && (
-                      <ComposerHighlightOverlay
+              {/*
+                Console redesign — INNER MODULE. The textarea + the
+                two bottom-control rows are the actual *input*, so they
+                live on a normal theme-tone surface (`.composer-inner-
+                module`) that stays perfectly readable. The OUTER
+                `.composer-surface` is restyled (shard 07/03) into a
+                translucent CONTRAST glass (light glass on dark themes,
+                dark glass on light themes) that shows only as the FRAME
+                around this module via the surface's existing padding;
+                the provider rim carries onto BOTH rims. `.composer-
+                chips` + `.composer-top-toggles` (+ attachment tray)
+                stay above, as children of the outer frame.
+                NOTE: `.composer-bottom-controls` keeps its `display:
+                contents` (native shell) so its control-footer +
+                telemetry rows remain *effective* children of the input
+                container — now this inner module — exactly as the
+                "two rows" contract (below) documents.
+              */}
+              <div className="composer-inner-module">
+                {(() => {
+                  // Gate the overlay activation: render the highlight
+                  // layer only when the prompt contains at least one
+                  // RESOLVED `@Token`. Without this, the textarea's
+                  // `color: transparent` zeros out the text in shells
+                  // where the overlay's font/padding drifts from the
+                  // textarea (Claude / Codex / Kimi etc. each override
+                  // base padding). the maintainer hit this on the ensemble
+                  // welcome screen — text invisible in Claude shell,
+                  // vertical sync issues in others.
+                  // 1.0.4 — drop the `isCurrentEnsembleChat` precondition.
+                  // `hasResolvedMention` already self-guards on
+                  // `participants.length === 0`, so non-ensemble chats
+                  // are excluded naturally. The extra gate caused a
+                  // regression on the ensemble welcome screen where
+                  // `chatKind === 'ensemble'` evaluated false during
+                  // some welcome-surface render passes — leaving typed
+                  // tags as plain white text instead of bold +
+                  // provider-tinted (the maintainer's "tags not lighting up"
+                  // report). Now: anywhere participants ARE configured
+                  // and a mention resolves, the overlay activates.
+                  const composerHasMention = hasResolvedMention(
+                    prompt,
+                    currentChat?.ensemble?.participants || []
+                  )
+                  // 1.0.4 — sync epoch for the overlay's auto-metric
+                  // mirror. Any change in the inputs below can shift
+                  // the textarea's computed font / padding / border,
+                  // so we encode them into a single string the
+                  // overlay watches as a useLayoutEffect dep. The
+                  // ResizeObserver inside the overlay handles every
+                  // size-changing variation that happens between
+                  // these explicit triggers.
+                  const composerOverlaySyncEpoch = `${appearance.composerStyle}|${appearance.themeAppearance}|${isWelcomeChat ? 'welcome' : 'active'}`
+                  return (
+                    <div className="composer-textarea-wrap">
+                      {composerHasMention && (
+                        <ComposerHighlightOverlay
+                          value={prompt}
+                          participants={currentChat?.ensemble?.participants}
+                          textareaRef={composerTextareaRef}
+                          syncEpoch={composerOverlaySyncEpoch}
+                        />
+                      )}
+                      <textarea
+                        className={`composer-textarea${composerHasMention ? ' has-mention-overlay' : ''}`}
+                        ref={composerTextareaRef}
                         value={prompt}
-                        participants={currentChat?.ensemble?.participants}
-                        textareaRef={composerTextareaRef}
-                        syncEpoch={composerOverlaySyncEpoch}
-                      />
-                    )}
-                    <textarea
-                      className={`composer-textarea${composerHasMention ? ' has-mention-overlay' : ''}`}
-                      ref={composerTextareaRef}
-                      value={prompt}
-                      onChange={(e) => {
-                        const nextValue = e.target.value
-                        // 1.0.4-AQ3 — snapshot the caret position from
-                        // the change event BEFORE React reconciles. The
-                        // restoration layout effect below reads this ref
-                        // and re-applies the caret after the className
-                        // flip + overlay mount that can land mid-keystroke
-                        // when an `@token` resolves.
-                        composerSelectionRef.current = {
-                          start: e.target.selectionStart ?? nextValue.length,
-                          end: e.target.selectionEnd ?? nextValue.length
-                        }
-                        composerCaretRestoreEpochRef.current += 1
-                        setPrompt(nextValue)
-                        // Composer popover coordinator: scan the text before the
-                        // caret for a leading `/<query>` token (start-of-line or
-                        // after whitespace), then for an `@<query>` mention token.
-                        // Whichever matches wins; the other is force-closed. Only
-                        // one popover open at a time.
-                        const caret = e.target.selectionStart ?? nextValue.length
-                        const before = nextValue.slice(0, caret)
-                        const slashMatch = before.match(/(?:^|\s)\/([\w-]*)$/)
-                        const mentionTrigger = !slashMatch
-                          ? parseComposerMentionTrigger(nextValue, caret)
-                          : null
-                        if (slashMatch) {
-                          // The `/` itself sits at `caret - slashQueryLen - 1`.
-                          const queryLen = slashMatch[1].length
-                          slashAnchorIndexRef.current = caret - queryLen - 1
-                          setSlashQuery(slashMatch[1] || '')
-                          setSlashMenuOpen(true)
-                          if (mentionMenuOpen) {
-                            setMentionMenuOpen(false)
-                            setMentionQuery('')
-                            mentionAnchorIndexRef.current = null
-                          }
-                        } else if (mentionTrigger) {
-                          mentionAnchorIndexRef.current = mentionTrigger.anchorIndex
-                          mentionTriggerLengthRef.current = mentionTrigger.triggerLength
-                          setMentionTriggerKind(mentionTrigger.kind)
-                          setMentionQuery(mentionTrigger.query)
-                          setMentionMenuOpen(true)
-                          if (slashMenuOpen) {
-                            setSlashMenuOpen(false)
-                            setSlashQuery('')
-                            slashAnchorIndexRef.current = null
+                        onChange={(e) => {
+                          const nextValue = e.target.value
+                          // 1.0.4-AQ3 — snapshot the caret position from
+                          // the change event BEFORE React reconciles. The
+                          // restoration layout effect below reads this ref
+                          // and re-applies the caret after the className
+                          // flip + overlay mount that can land mid-keystroke
+                          // when an `@token` resolves.
+                          composerSelectionRef.current = {
+                            start: e.target.selectionStart ?? nextValue.length,
+                            end: e.target.selectionEnd ?? nextValue.length
                           }
-                        } else {
-                          if (mentionMenuOpen) {
-                            setMentionMenuOpen(false)
-                            setMentionQuery('')
-                            mentionAnchorIndexRef.current = null
+                          composerCaretRestoreEpochRef.current += 1
+                          setPrompt(nextValue)
+                          // Composer popover coordinator: scan the text before the
+                          // caret for a leading `/<query>` token (start-of-line or
+                          // after whitespace), then for an `@<query>` mention token.
+                          // Whichever matches wins; the other is force-closed. Only
+                          // one popover open at a time.
+                          const caret = e.target.selectionStart ?? nextValue.length
+                          const before = nextValue.slice(0, caret)
+                          const slashMatch = before.match(/(?:^|\s)\/([\w-]*)$/)
+                          const mentionTrigger = !slashMatch
+                            ? parseComposerMentionTrigger(nextValue, caret)
+                            : null
+                          if (slashMatch) {
+                            // The `/` itself sits at `caret - slashQueryLen - 1`.
+                            const queryLen = slashMatch[1].length
+                            slashAnchorIndexRef.current = caret - queryLen - 1
+                            setSlashQuery(slashMatch[1] || '')
+                            setSlashMenuOpen(true)
+                            if (mentionMenuOpen) {
+                              setMentionMenuOpen(false)
+                              setMentionQuery('')
+                              mentionAnchorIndexRef.current = null
+                            }
+                          } else if (mentionTrigger) {
+                            mentionAnchorIndexRef.current = mentionTrigger.anchorIndex
+                            mentionTriggerLengthRef.current = mentionTrigger.triggerLength
+                            setMentionTriggerKind(mentionTrigger.kind)
+                            setMentionQuery(mentionTrigger.query)
+                            setMentionMenuOpen(true)
+                            if (slashMenuOpen) {
+                              setSlashMenuOpen(false)
+                              setSlashQuery('')
+                              slashAnchorIndexRef.current = null
+                            }
+                          } else {
+                            if (mentionMenuOpen) {
+                              setMentionMenuOpen(false)
+                              setMentionQuery('')
+                              mentionAnchorIndexRef.current = null
+                            }
+                            if (slashMenuOpen) {
+                              setSlashMenuOpen(false)
+                              setSlashQuery('')
+                              slashAnchorIndexRef.current = null
+                            }
                           }
-                          if (slashMenuOpen) {
-                            setSlashMenuOpen(false)
-                            setSlashQuery('')
-                            slashAnchorIndexRef.current = null
+                        }}
+                        placeholder={composerPlaceholder}
+                        aria-label={composerAriaLabel}
+                        rows={1}
+                        disabled={!currentChat || (!isCurrentGlobalChat && !currentWorkspace)}
+                        onKeyDown={(e) => {
+                          if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
+                            e.preventDefault()
+                            triggerSendConfirmation()
+                            // DM target resolution order (first match wins):
+                            //   1. An explicit `@participant` mention in the
+                            //      prompt body (`ensemble-dm://` markdown link
+                            //      inserted by the mention picker).
+                            //   2. Legacy Cmd/Ctrl+Enter on a selected chip
+                            //      (A2 from 1.0.3 — kept so muscle memory
+                            //      still works).
+                            // Plain Enter with no mention + no modifier
+                            // dispatches the full round.
+                            const dmFromMention = isCurrentEnsembleChat
+                              ? extractFirstEnsembleDmTarget(
+                                  prompt,
+                                  currentChat?.ensemble?.participants
+                                )
+                              : null
+                            const dmTarget =
+                              dmFromMention ||
+                              (isCurrentEnsembleChat &&
+                              effectiveSelectedParticipantId &&
+                              (e.metaKey || e.ctrlKey)
+                                ? effectiveSelectedParticipantId
+                                : undefined)
+                            handleRun(undefined, undefined, dmTarget || undefined)
                           }
-                        }
-                      }}
-                      placeholder={composerPlaceholder}
-                      aria-label={composerAriaLabel}
-                      rows={1}
-                      disabled={!currentChat || (!isCurrentGlobalChat && !currentWorkspace)}
-                      onKeyDown={(e) => {
-                        if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
-                          e.preventDefault()
-                          triggerSendConfirmation()
-                          // DM target resolution order (first match wins):
-                          //   1. An explicit `@participant` mention in the
-                          //      prompt body (`ensemble-dm://` markdown link
-                          //      inserted by the mention picker).
-                          //   2. Legacy Cmd/Ctrl+Enter on a selected chip
-                          //      (A2 from 1.0.3 — kept so muscle memory
-                          //      still works).
-                          // Plain Enter with no mention + no modifier
-                          // dispatches the full round.
-                          const dmFromMention = isCurrentEnsembleChat
-                            ? extractFirstEnsembleDmTarget(
-                                prompt,
-                                currentChat?.ensemble?.participants
-                              )
-                            : null
-                          const dmTarget =
-                            dmFromMention ||
-                            (isCurrentEnsembleChat &&
-                            effectiveSelectedParticipantId &&
-                            (e.metaKey || e.ctrlKey)
-                              ? effectiveSelectedParticipantId
-                              : undefined)
-                          handleRun(undefined, undefined, dmTarget || undefined)
-                        }
-                      }}
-                    />
-                  </div>
-                )
-              })()}
-              <ComposerSlashMenu
-                open={slashMenuOpen}
-                anchorRef={composerTextareaRef}
-                query={slashQuery}
-                commands={composerSlashCommands}
-                composerStyle={appearance.composerStyle}
-                onDismiss={() => {
-                  setSlashMenuOpen(false)
-                  setSlashQuery('')
-                  slashAnchorIndexRef.current = null
-                }}
-                onPick={(command) => handleComposerSlash(command)}
-              />
-              <AgentMentionMenu
-                chat={currentChat || undefined}
-                provider={currentProvider}
-                composerStyle={appearance.composerStyle}
-                workspacePath={currentWorkspace?.path}
-                externalPathGrants={externalPathGrants}
-                /*
-                  1.0.5-EW53 — Dropped `prompt={prompt}` from this
-                  spread. The prop was never declared on
-                  AgentMentionMenuProps (the destructure doesn't
-                  pick it up), so the menu never read it — but
-                  passing it down made every keystroke flow a
-                  fresh string into JSX reconciliation. Once the
-                  menu is wrapped in memo (TODO), removing the
-                  unused prop keeps the prop diff clean.
-                */
-                open={mentionMenuOpen}
-                anchorRef={composerTextareaRef}
-                query={mentionQuery}
-                triggerKind={mentionTriggerKind}
-                ensembleParticipants={
-                  isCurrentEnsembleChat ? currentChat?.ensemble?.participants : undefined
-                }
-                onDismiss={() => {
-                  setMentionMenuOpen(false)
-                  setMentionQuery('')
-                  mentionAnchorIndexRef.current = null
-                }}
-                onPick={(mention) => {
-                  const anchor = mentionAnchorIndexRef.current
-                  if (anchor === null) {
+                        }}
+                      />
+                    </div>
+                  )
+                })()}
+                <ComposerSlashMenu
+                  open={slashMenuOpen}
+                  anchorRef={composerTextareaRef}
+                  query={slashQuery}
+                  commands={composerSlashCommands}
+                  composerStyle={appearance.composerStyle}
+                  onDismiss={() => {
+                    setSlashMenuOpen(false)
+                    setSlashQuery('')
+                    slashAnchorIndexRef.current = null
+                  }}
+                  onPick={(command) => handleComposerSlash(command)}
+                />
+                <AgentMentionMenu
+                  chat={currentChat || undefined}
+                  provider={currentProvider}
+                  composerStyle={appearance.composerStyle}
+                  workspacePath={currentWorkspace?.path}
+                  externalPathGrants={externalPathGrants}
+                  /*
+                    1.0.5-EW53 — Dropped `prompt={prompt}` from this
+                    spread. The prop was never declared on
+                    AgentMentionMenuProps (the destructure doesn't
+                    pick it up), so the menu never read it — but
+                    passing it down made every keystroke flow a
+                    fresh string into JSX reconciliation. Once the
+                    menu is wrapped in memo (TODO), removing the
+                    unused prop keeps the prop diff clean.
+                  */
+                  open={mentionMenuOpen}
+                  anchorRef={composerTextareaRef}
+                  query={mentionQuery}
+                  triggerKind={mentionTriggerKind}
+                  ensembleParticipants={
+                    isCurrentEnsembleChat ? currentChat?.ensemble?.participants : undefined
+                  }
+                  onDismiss={() => {
                     setMentionMenuOpen(false)
                     setMentionQuery('')
-                    return
-                  }
-                  // The trigger characters (`@` or `-@`) + the live
-                  // query string need to be stripped — replace them
-                  // wholesale with the chosen mention's insertion.
-                  const triggerLen = mentionTriggerLengthRef.current
-                  const before = prompt.slice(0, anchor)
-                  const afterQuery = prompt.slice(anchor + triggerLen + mentionQuery.length)
-                  const insertion = (() => {
-                    if (mention.kind === 'agent' && mention.agentId) {
-                      return `[@${mention.name}](agent://${mention.agentId}) `
+                    mentionAnchorIndexRef.current = null
+                  }}
+                  onPick={(mention) => {
+                    const anchor = mentionAnchorIndexRef.current
+                    if (anchor === null) {
+                      setMentionMenuOpen(false)
+                      setMentionQuery('')
+                      return
                     }
-                    if (mention.kind === 'participant' && mention.participantId) {
-                      // Ensemble DM mention. Insert PLAIN `@Role`
-                      // (no markdown link) so the composer textarea
-                      // shows a clean readable token instead of the
-                      // raw markdown URL. On send,
-                      // `extractFirstEnsembleDmTarget` resolves the
-                      // `@Role` against the chat's participants by
-                      // role (case-insensitive) → provider name and
-                      // produces the right `dmTargetParticipantId`.
-                      // This also means free-typed `@Gemini` or
-                      // `@Worker` works the same as a picker click.
-                      return `@${mention.name} `
-                    }
-                    return formatComposerPathMention(mention.path || mention.name)
-                  })()
-                  const next = `${before}${insertion}${afterQuery}`
-                  setPrompt(next)
-                  setMentionMenuOpen(false)
-                  setMentionQuery('')
-                  mentionAnchorIndexRef.current = null
-                  // Restore caret after the inserted mention/path.
-                  requestAnimationFrame(() => {
-                    const ta = composerTextareaRef.current
-                    if (!ta) return
-                    const newCaret = before.length + insertion.length
-                    ta.focus()
-                    ta.setSelectionRange(newCaret, newCaret)
-                  })
-                }}
-              />
-              {/*
-                1.0.6-EW68 — Two-container composer split (Obsidian +
-                Alabaster only). The control-footer (send row + Row A:
-                Turn/Continuous/Work-Session + provider + model +
-                approval) and the telemetry-row (Row B: timecode +
-                workspace + token tally) are wrapped here so those two
-                shells can render them as a SECOND lit rect below the
-                textarea rect. For the other nine shells this wrapper is
-                `display: contents`, so it vanishes from layout and the
-                two rows stay effective children of `.composer-surface`
-                exactly as before.
-              */}
-              <div className="composer-bottom-controls">
-                <div className="composer-control-footer">
-                  {currentProvider === 'codex' &&
-                    !isCurrentGlobalChat &&
-                    externalPathGrants.length > 0 && (
-                      <div className="composer-image-strip composer-external-grant-strip">
-                        {externalPathGrants.map((grant) => (
-                          <div
-                            key={grant.id}
-                            className={`composer-image-item external-grant access-${grant.access}`}
-                          >
-                            <PermissionSymbolIcon />
-                            <span className="composer-image-name" title={grant.path}>
-                              {grant.access === 'write' ? 'Edit' : 'Read'} {grant.kind}:{' '}
-                              {grant.path}
-                            </span>
-                            <button
-                              className="composer-image-remove"
-                              type="button"
-                              onClick={() => handleRemoveExternalPathGrant(grant.id)}
-                              disabled={isCurrentComposerLocked}
-                              title="Revoke external path grant"
+                    // The trigger characters (`@` or `-@`) + the live
+                    // query string need to be stripped — replace them
+                    // wholesale with the chosen mention's insertion.
+                    const triggerLen = mentionTriggerLengthRef.current
+                    const before = prompt.slice(0, anchor)
+                    const afterQuery = prompt.slice(anchor + triggerLen + mentionQuery.length)
+                    const insertion = (() => {
+                      if (mention.kind === 'agent' && mention.agentId) {
+                        return `[@${mention.name}](agent://${mention.agentId}) `
+                      }
+                      if (mention.kind === 'participant' && mention.participantId) {
+                        // Ensemble DM mention. Insert PLAIN `@Role`
+                        // (no markdown link) so the composer textarea
+                        // shows a clean readable token instead of the
+                        // raw markdown URL. On send,
+                        // `extractFirstEnsembleDmTarget` resolves the
+                        // `@Role` against the chat's participants by
+                        // role (case-insensitive) → provider name and
+                        // produces the right `dmTargetParticipantId`.
+                        // This also means free-typed `@Gemini` or
+                        // `@Worker` works the same as a picker click.
+                        return `@${mention.name} `
+                      }
+                      return formatComposerPathMention(mention.path || mention.name)
+                    })()
+                    const next = `${before}${insertion}${afterQuery}`
+                    setPrompt(next)
+                    setMentionMenuOpen(false)
+                    setMentionQuery('')
+                    mentionAnchorIndexRef.current = null
+                    // Restore caret after the inserted mention/path.
+                    requestAnimationFrame(() => {
+                      const ta = composerTextareaRef.current
+                      if (!ta) return
+                      const newCaret = before.length + insertion.length
+                      ta.focus()
+                      ta.setSelectionRange(newCaret, newCaret)
+                    })
+                  }}
+                />
+                {/*
+                  1.0.6-EW68 — Two-container composer split (Obsidian +
+                  Alabaster only). The control-footer (send row + Row A:
+                  Turn/Continuous/Work-Session + provider + model +
+                  approval) and the telemetry-row (Row B: timecode +
+                  workspace + token tally) are wrapped here so those two
+                  shells can render them as a SECOND lit rect below the
+                  textarea rect. For the other nine shells this wrapper is
+                  `display: contents`, so it vanishes from layout and the
+                  two rows stay effective children of `.composer-surface`
+                  exactly as before.
+                */}
+                <div className="composer-bottom-controls">
+                  <div className="composer-control-footer">
+                    {currentProvider === 'codex' &&
+                      !isCurrentGlobalChat &&
+                      externalPathGrants.length > 0 && (
+                        <div className="composer-image-strip composer-external-grant-strip">
+                          {externalPathGrants.map((grant) => (
+                            <div
+                              key={grant.id}
+                              className={`composer-image-item external-grant access-${grant.access}`}
                             >
-                              <XSymbolIcon />
-                            </button>
-                          </div>
-                        ))}
-                      </div>
-                    )}
-                  {permissionRequestPaths.length > 0 && (
-                    <div className="composer-permission-card">
-                      <div className="composer-permission-title">
-                        <span>{permissionRequestTitle}</span>
-                        {permissionRequestSource && (
-                          <span className="composer-permission-source">
-                            {permissionRequestSource}
-                          </span>
-                        )}
-                      </div>
-                      {permissionRequestMessage && (
-                        <div className="composer-permission-message">
-                          {permissionRequestMessage}
-                        </div>
-                      )}
-                      <div className="composer-permission-paths">
-                        {permissionRequestPaths.map((path) => (
-                          <span key={path} className="composer-permission-path">
-                            {path}
-                          </span>
-                        ))}
-                      </div>
-                      <div className="composer-permission-actions">
-                        <button
-                          className="btn btn-sm"
-                          type="button"
-                          onClick={handlePermissionRetry}
-                        >
-                          Add paths and rerun
-                        </button>
-                        <button
-                          className="btn btn-sm btn-ghost"
-                          type="button"
-                          onClick={clearImagePermissions}
-                        >
-                          Dismiss
-                        </button>
-                      </div>
-                    </div>
-                  )}
-                  {/* Phase J3: session-scoped YOLO indicator. Visible when the
-                    user has clicked "Trust this session" — every subsequent
-                    approval auto-allows. Includes a one-click disable.
-                    Slice A: dismissible via the inline ✕ button; the
-                    collapsed state is represented by `.composer-yolo-chip`
-                    in the action row below. */}
-                  {sessionYoloMode.enabled && !yoloBannerDismissed && (
-                    <div
-                      className="composer-permission-card provider-yolo"
-                      style={{
-                        background: 'rgba(244, 162, 97, 0.12)',
-                        borderColor: 'rgba(244, 162, 97, 0.5)'
-                      }}
-                    >
-                      <div className="composer-permission-title">
-                        <span>Trust mode active — every approval auto-allowed</span>
-                        <span className="composer-permission-source">YOLO</span>
-                      </div>
-                      <div className="composer-permission-message">
-                        Approval modals will be skipped for the rest of this app session. Global
-                        Deny policies still apply. Restart the app to revert, or disable here.
-                      </div>
-                      <div className="composer-permission-actions">
-                        <button
-                          className="btn btn-sm btn-ghost"
-                          type="button"
-                          onClick={async () => {
-                            try {
-                              await window.api.agenticYoloSet(false)
-                            } catch (error) {
-                              console.error('Failed to disable YOLO session mode', error)
-                            }
-                          }}
-                        >
-                          Disable trust mode
-                        </button>
-                        <button
-                          className="btn btn-sm btn-ghost composer-yolo-banner-dismiss"
-                          type="button"
-                          onClick={() => setYoloBannerDismissed(true)}
-                          title="Hide this banner (trust mode stays on)"
-                          aria-label="Dismiss trust mode banner"
-                        >
-                          ✕ Dismiss
-                        </button>
-                      </div>
-                    </div>
-                  )}
-                  {pendingAgentApproval && (
-                    <div
-                      className={`composer-permission-card provider-${pendingAgentApproval.provider}`}
-                    >
-                      <div className="composer-permission-title">
-                        <span>{pendingAgentApproval.title}</span>
-                        <span className="composer-permission-source">
-                          {getProviderLabel(pendingAgentApproval.provider)}
-                          {/* 1.0.4-AK4 — surface the queue depth so the
-                            user knows other approvals are waiting on
-                            this same chat. Common case (single
-                            approval at a time) shows nothing extra. */}
-                          {(() => {
-                            const queue = currentComposerChatId
-                              ? pendingApprovalQueueByChatId[currentComposerChatId] || []
-                              : []
-                            if (queue.length === 0) return null
-                            return (
-                              <span
-                                className="composer-permission-queue-badge"
-                                title={`${queue.length} more approval${
-                                  queue.length === 1 ? '' : 's'
-                                } queued behind this one — they appear in order as you respond.`}
-                              >
-                                +{queue.length} more
+                              <PermissionSymbolIcon />
+                              <span className="composer-image-name" title={grant.path}>
+                                {grant.access === 'write' ? 'Edit' : 'Read'} {grant.kind}:{' '}
+                                {grant.path}
                               </span>
-                            )
-                          })()}
-                        </span>
-                      </div>
-                      {pendingAgentApproval.body && (
-                        <div className="composer-permission-message">
-                          {pendingAgentApproval.body}
+                              <button
+                                className="composer-image-remove"
+                                type="button"
+                                onClick={() => handleRemoveExternalPathGrant(grant.id)}
+                                disabled={isCurrentComposerLocked}
+                                title="Revoke external path grant"
+                              >
+                                <XSymbolIcon />
+                              </button>
+                            </div>
+                          ))}
                         </div>
                       )}
-                      {/* Slice 4 of the external-path-redesign arc.
-                        When the runtime detector emits an external-path
-                        approval, it stashes the detected path under
-                        `preview.externalPathDetection`. Render it
-                        prominently so the user knows WHICH path they're
-                        granting before clicking the action button. */}
-                      {pendingAgentApproval.preview?.externalPathDetection?.path && (
-                        <div className="composer-permission-external-path">
-                          <span className="composer-permission-external-path-label">Path</span>
-                          <code className="composer-permission-external-path-value">
-                            {pendingAgentApproval.preview.externalPathDetection.path}
-                          </code>
+                    {permissionRequestPaths.length > 0 && (
+                      <div className="composer-permission-card">
+                        <div className="composer-permission-title">
+                          <span>{permissionRequestTitle}</span>
+                          {permissionRequestSource && (
+                            <span className="composer-permission-source">
+                              {permissionRequestSource}
+                            </span>
+                          )}
                         </div>
-                      )}
-                      {renderAgentApprovalPreview(pendingAgentApproval.preview)}
-                      <div className="composer-permission-actions">
-                        {(pendingAgentApproval.actions || ['accept']).includes('accept') && (
-                          <button
-                            className="btn btn-sm"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(pendingAgentApproval.id, 'accept')
-                            }
-                          >
-                            {pendingAgentApproval.method === 'hostCommand/rerun'
-                              ? 'Rerun outside sandbox'
-                              : 'Allow once'}
-                          </button>
+                        {permissionRequestMessage && (
+                          <div className="composer-permission-message">
+                            {permissionRequestMessage}
+                          </div>
                         )}
-                        {(pendingAgentApproval.actions || []).includes('useProviderNative') && (
+                        <div className="composer-permission-paths">
+                          {permissionRequestPaths.map((path) => (
+                            <span key={path} className="composer-permission-path">
+                              {path}
+                            </span>
+                          ))}
+                        </div>
+                        <div className="composer-permission-actions">
                           <button
                             className="btn btn-sm"
                             type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'useProviderNative'
-                              )
-                            }
-                          >
-                            Use Provider Native
-                          </button>
-                        )}
-                        {(pendingAgentApproval.actions || []).includes('useAGBenchSubthread') && (
-                          <button
-                            className="btn btn-sm btn-ghost"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'useAGBenchSubthread'
-                              )
-                            }
-                          >
-                            Use AGBench Sub-thread
-                          </button>
-                        )}
-                        {(pendingAgentApproval.actions || []).includes('acceptForWorkspace') && (
-                          <button
-                            className="btn btn-sm btn-ghost"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'acceptForWorkspace'
-                              )
-                            }
+                            onClick={handlePermissionRetry}
                           >
-                            Allow in workspace
+                            Add paths and rerun
                           </button>
-                        )}
-                        {(pendingAgentApproval.actions || ['acceptForSession']).includes(
-                          'acceptForSession'
-                        ) && (
                           <button
                             className="btn btn-sm btn-ghost"
                             type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'acceptForSession'
-                              )
-                            }
+                            onClick={clearImagePermissions}
                           >
-                            Allow for session
+                            Dismiss
                           </button>
-                        )}
-                        {/* Phase J3: "Trust this run" — accept the current modal AND enable
-                          session-wide YOLO so every subsequent approval auto-allows for
-                          the rest of the process lifetime. Never persisted to disk.
-                          Global `deny` policies still win. */}
-                        {!isNativeSubAgentPreferenceApproval(pendingAgentApproval) && (
+                        </div>
+                      </div>
+                    )}
+                    {/* Phase J3: session-scoped YOLO indicator. Visible when the
+                      user has clicked "Trust this session" — every subsequent
+                      approval auto-allows. Includes a one-click disable.
+                      Slice A: dismissible via the inline ✕ button; the
+                      collapsed state is represented by `.composer-yolo-chip`
+                      in the action row below. */}
+                    {sessionYoloMode.enabled && !yoloBannerDismissed && (
+                      <div
+                        className="composer-permission-card provider-yolo"
+                        style={{
+                          background: 'rgba(244, 162, 97, 0.12)',
+                          borderColor: 'rgba(244, 162, 97, 0.5)'
+                        }}
+                      >
+                        <div className="composer-permission-title">
+                          <span>Trust mode active — every approval auto-allowed</span>
+                          <span className="composer-permission-source">YOLO</span>
+                        </div>
+                        <div className="composer-permission-message">
+                          Approval modals will be skipped for the rest of this app session. Global
+                          Deny policies still apply. Restart the app to revert, or disable here.
+                        </div>
+                        <div className="composer-permission-actions">
                           <button
                             className="btn btn-sm btn-ghost"
                             type="button"
-                            title="Auto-allow every approval prompt for the rest of this session. Restart the app to revert. Doesn't override globally-denied services."
                             onClick={async () => {
                               try {
-                                await window.api.agenticYoloSet(true)
+                                await window.api.agenticYoloSet(false)
                               } catch (error) {
-                                console.error('Failed to enable YOLO session mode', error)
+                                console.error('Failed to disable YOLO session mode', error)
                               }
-                              await handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'acceptForSession'
-                              )
                             }}
                           >
-                            Trust this session
+                            Disable trust mode
                           </button>
-                        )}
-                        {(pendingAgentApproval.actions || ['decline']).includes('decline') && (
                           <button
-                            className="btn btn-sm btn-ghost"
+                            className="btn btn-sm btn-ghost composer-yolo-banner-dismiss"
                             type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(pendingAgentApproval.id, 'decline')
-                            }
-                          >
-                            Deny
-                          </button>
-                        )}
-                        {(pendingAgentApproval.actions || ['cancel']).includes('cancel') && (
-                          <button
-                            className="btn btn-sm btn-ghost"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(pendingAgentApproval.id, 'cancel')
-                            }
-                          >
-                            Cancel run
-                          </button>
-                        )}
-                        {/* Slice 4 external-path actions — only render when
-                          the runtime detector emitted the new action
-                          triplet. The generic accept/decline buttons
-                          above won't match those approvals' action list,
-                          so only these three appear for external-path
-                          prompts. */}
-                        {(pendingAgentApproval.actions || []).includes('grantExternalPathRead') && (
-                          <button
-                            className="btn btn-sm btn-primary"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'grantExternalPathRead'
-                              )
-                            }
+                            onClick={() => setYoloBannerDismissed(true)}
+                            title="Hide this banner (trust mode stays on)"
+                            aria-label="Dismiss trust mode banner"
                           >
-                            Grant read access
+                            ✕ Dismiss
                           </button>
-                        )}
-                        {(pendingAgentApproval.actions || []).includes('grantExternalPathEdit') && (
-                          <button
-                            className="btn btn-sm"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'grantExternalPathEdit'
-                              )
-                            }
-                          >
-                            Grant edit access
-                          </button>
-                        )}
-                        {(pendingAgentApproval.actions || []).includes('declineExternalPath') && (
-                          <button
-                            className="btn btn-sm btn-ghost"
-                            type="button"
-                            onClick={() =>
-                              void handleAgentApprovalAction(
-                                pendingAgentApproval.id,
-                                'declineExternalPath'
-                              )
-                            }
-                          >
-                            Deny once
-                          </button>
-                        )}
+                        </div>
                       </div>
-                    </div>
-                  )}
-                  {isCommandPaletteOpen && (
-                    <div className="composer-discovery-card command-palette-card">
-                      <div className="composer-discovery-header">
-                        <div>
-                          <strong>
-                            {currentProvider === 'gemini'
-                              ? 'Slash command palette'
-                              : `${currentProviderLabel} command palette`}
-                          </strong>
-                          <span>
-                            {currentProvider === 'gemini'
-                              ? commandDiscoveryStatus
-                              : `App-native ${currentProviderLabel} commands and provider controls.`}
+                    )}
+                    {pendingAgentApproval && (
+                      <div
+                        className={`composer-permission-card provider-${pendingAgentApproval.provider}`}
+                      >
+                        <div className="composer-permission-title">
+                          <span>{pendingAgentApproval.title}</span>
+                          <span className="composer-permission-source">
+                            {getProviderLabel(pendingAgentApproval.provider)}
+                            {/* 1.0.4-AK4 — surface the queue depth so the
+                              user knows other approvals are waiting on
+                              this same chat. Common case (single
+                              approval at a time) shows nothing extra. */}
+                            {(() => {
+                              const queue = currentComposerChatId
+                                ? pendingApprovalQueueByChatId[currentComposerChatId] || []
+                                : []
+                              if (queue.length === 0) return null
+                              return (
+                                <span
+                                  className="composer-permission-queue-badge"
+                                  title={`${queue.length} more approval${
+                                    queue.length === 1 ? '' : 's'
+                                  } queued behind this one — they appear in order as you respond.`}
+                                >
+                                  +{queue.length} more
+                                </span>
+                              )
+                            })()}
                           </span>
                         </div>
-                        <div className="composer-discovery-actions">
-                          {currentProvider === 'gemini' ? (
+                        {pendingAgentApproval.body && (
+                          <div className="composer-permission-message">
+                            {pendingAgentApproval.body}
+                          </div>
+                        )}
+                        {/* Slice 4 of the external-path-redesign arc.
+                          When the runtime detector emits an external-path
+                          approval, it stashes the detected path under
+                          `preview.externalPathDetection`. Render it
+                          prominently so the user knows WHICH path they're
+                          granting before clicking the action button. */}
+                        {pendingAgentApproval.preview?.externalPathDetection?.path && (
+                          <div className="composer-permission-external-path">
+                            <span className="composer-permission-external-path-label">Path</span>
+                            <code className="composer-permission-external-path-value">
+                              {pendingAgentApproval.preview.externalPathDetection.path}
+                            </code>
+                          </div>
+                        )}
+                        {renderAgentApprovalPreview(pendingAgentApproval.preview)}
+                        {/* Order-4 — optional one-line intent note. Always
+                          optional: it never blocks approve/deny. The text
+                          is captured at click time in
+                          `handleAgentApprovalAction` and persisted onto
+                          the approval-ledger row's metadata as
+                          `intentNote` (no schema migration). */}
+                        <input
+                          type="text"
+                          className="composer-permission-note"
+                          value={intentNote}
+                          onChange={(e) => setIntentNote(e.target.value)}
+                          placeholder="why? (optional)"
+                          aria-label="Optional note explaining this approval decision"
+                          maxLength={280}
+                        />
+                        <div className="composer-permission-actions">
+                          {(pendingAgentApproval.actions || ['accept']).includes('accept') && (
+                            <button
+                              className="btn btn-sm"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(pendingAgentApproval.id, 'accept')
+                              }
+                            >
+                              {pendingAgentApproval.method === 'hostCommand/rerun'
+                                ? 'Rerun outside sandbox'
+                                : 'Allow once'}
+                            </button>
+                          )}
+                          {(pendingAgentApproval.actions || []).includes('useProviderNative') && (
+                            <button
+                              className="btn btn-sm"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'useProviderNative'
+                                )
+                              }
+                            >
+                              Use Provider Native
+                            </button>
+                          )}
+                          {(pendingAgentApproval.actions || []).includes('useAGBenchSubthread') && (
                             <button
                               className="btn btn-sm btn-ghost"
                               type="button"
-                              onClick={() => void refreshCommandDiscovery()}
-                              disabled={!currentWorkspace}
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'useAGBenchSubthread'
+                                )
+                              }
                             >
-                              Refresh
+                              Use AGBench Sub-thread
                             </button>
-                          ) : currentProvider === 'codex' ? (
+                          )}
+                          {(pendingAgentApproval.actions || []).includes('acceptForWorkspace') && (
                             <button
                               className="btn btn-sm btn-ghost"
                               type="button"
-                              onClick={() => void refreshCodexThreads()}
-                              disabled={!currentWorkspace}
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'acceptForWorkspace'
+                                )
+                              }
                             >
-                              Refresh threads
+                              Allow in workspace
                             </button>
-                          ) : (
+                          )}
+                          {(pendingAgentApproval.actions || ['acceptForSession']).includes(
+                            'acceptForSession'
+                          ) && (
+                            <button
+                              className="btn btn-sm btn-ghost"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'acceptForSession'
+                                )
+                              }
+                            >
+                              Allow for session
+                            </button>
+                          )}
+                          {/* Phase J3: "Trust this run" — accept the current modal AND enable
+                            session-wide YOLO so every subsequent approval auto-allows for
+                            the rest of the process lifetime. Never persisted to disk.
+                            Global `deny` policies still win. */}
+                          {!isNativeSubAgentPreferenceApproval(pendingAgentApproval) && (
+                            <button
+                              className="btn btn-sm btn-ghost"
+                              type="button"
+                              title="Auto-allow every approval prompt for the rest of this session. Restart the app to revert. Doesn't override globally-denied services."
+                              onClick={async () => {
+                                try {
+                                  await window.api.agenticYoloSet(true)
+                                } catch (error) {
+                                  console.error('Failed to enable YOLO session mode', error)
+                                }
+                                await handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'acceptForSession'
+                                )
+                              }}
+                            >
+                              Trust this session
+                            </button>
+                          )}
+                          {(pendingAgentApproval.actions || ['decline']).includes('decline') && (
+                            <button
+                              className="btn btn-sm btn-ghost"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(pendingAgentApproval.id, 'decline')
+                              }
+                            >
+                              Deny
+                            </button>
+                          )}
+                          {(pendingAgentApproval.actions || ['cancel']).includes('cancel') && (
+                            <button
+                              className="btn btn-sm btn-ghost"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(pendingAgentApproval.id, 'cancel')
+                              }
+                            >
+                              Cancel run
+                            </button>
+                          )}
+                          {/* Slice 4 external-path actions — only render when
+                            the runtime detector emitted the new action
+                            triplet. The generic accept/decline buttons
+                            above won't match those approvals' action list,
+                            so only these three appear for external-path
+                            prompts. */}
+                          {(pendingAgentApproval.actions || []).includes(
+                            'grantExternalPathRead'
+                          ) && (
+                            <button
+                              className="btn btn-sm btn-primary"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'grantExternalPathRead'
+                                )
+                              }
+                            >
+                              Grant read access
+                            </button>
+                          )}
+                          {(pendingAgentApproval.actions || []).includes(
+                            'grantExternalPathEdit'
+                          ) && (
+                            <button
+                              className="btn btn-sm"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'grantExternalPathEdit'
+                                )
+                              }
+                            >
+                              Grant edit access
+                            </button>
+                          )}
+                          {(pendingAgentApproval.actions || []).includes('declineExternalPath') && (
+                            <button
+                              className="btn btn-sm btn-ghost"
+                              type="button"
+                              onClick={() =>
+                                void handleAgentApprovalAction(
+                                  pendingAgentApproval.id,
+                                  'declineExternalPath'
+                                )
+                              }
+                            >
+                              Deny once
+                            </button>
+                          )}
+                        </div>
+                      </div>
+                    )}
+                    {isCommandPaletteOpen && (
+                      <div className="composer-discovery-card command-palette-card">
+                        <div className="composer-discovery-header">
+                          <div>
+                            <strong>
+                              {currentProvider === 'gemini'
+                                ? 'Slash command palette'
+                                : `${currentProviderLabel} command palette`}
+                            </strong>
+                            <span>
+                              {currentProvider === 'gemini'
+                                ? commandDiscoveryStatus
+                                : `App-native ${currentProviderLabel} commands and provider controls.`}
+                            </span>
+                          </div>
+                          <div className="composer-discovery-actions">
+                            {currentProvider === 'gemini' ? (
+                              <button
+                                className="btn btn-sm btn-ghost"
+                                type="button"
+                                onClick={() => void refreshCommandDiscovery()}
+                                disabled={!currentWorkspace}
+                              >
+                                Refresh
+                              </button>
+                            ) : currentProvider === 'codex' ? (
+                              <button
+                                className="btn btn-sm btn-ghost"
+                                type="button"
+                                onClick={() => void refreshCodexThreads()}
+                                disabled={!currentWorkspace}
+                              >
+                                Refresh threads
+                              </button>
+                            ) : (
+                              <button
+                                className="btn btn-sm btn-ghost"
+                                type="button"
+                                onClick={() => void refreshProviderMetadata(currentProvider)}
+                                disabled={!currentWorkspace}
+                              >
+                                Refresh status
+                              </button>
+                            )}
                             <button
                               className="btn btn-sm btn-ghost"
                               type="button"
-                              onClick={() => void refreshProviderMetadata(currentProvider)}
-                              disabled={!currentWorkspace}
+                              onClick={() => {
+                                setIsCommandPaletteOpen(false)
+                                setCommandPaletteQuery('')
+                              }}
                             >
-                              Refresh status
+                              Dismiss
                             </button>
+                          </div>
+                        </div>
+                        <input
+                          className="command-palette-search"
+                          type="search"
+                          aria-label={`Filter ${currentProviderLabel} commands`}
+                          value={commandPaletteQuery}
+                          onChange={(event) => setCommandPaletteQuery(event.target.value)}
+                          onKeyDown={(event) => {
+                            if (event.key === 'Escape') {
+                              setIsCommandPaletteOpen(false)
+                              setCommandPaletteQuery('')
+                            }
+                          }}
+                          placeholder={
+                            currentProvider === 'gemini'
+                              ? 'Filter commands, memory, hooks...'
+                              : `Filter ${currentProviderLabel} commands...`
+                          }
+                          autoFocus
+                        />
+                        <div className="command-palette-list">
+                          {commandPaletteGroups.map((group) => {
+                            const groupItems = visibleCommandPaletteItems.filter(
+                              (item) => item.group === group
+                            )
+                            if (groupItems.length === 0) return null
+                            return (
+                              <div key={group} className="command-palette-group">
+                                <div className="command-palette-group-title">{group}</div>
+                                {groupItems.map((item) => (
+                                  <button
+                                    key={item.id}
+                                    className="command-palette-item"
+                                    type="button"
+                                    onClick={() => handlePaletteCommand(item)}
+                                    disabled={!currentWorkspace || !currentChat}
+                                    title={
+                                      currentProvider === 'gemini'
+                                        ? `Send ${item.command} to Gemini CLI`
+                                        : `Run ${item.command}`
+                                    }
+                                  >
+                                    <span className="command-palette-command">{item.command}</span>
+                                    <span className="command-palette-copy">
+                                      <strong>{item.label}</strong>
+                                      <span>{item.description}</span>
+                                      {item.sourcePath && <small>{item.sourcePath}</small>}
+                                    </span>
+                                  </button>
+                                ))}
+                              </div>
+                            )
+                          })}
+                          {visibleCommandPaletteItems.length === 0 && (
+                            <div className="command-palette-empty">
+                              No commands match this filter.
+                            </div>
                           )}
+                        </div>
+                      </div>
+                    )}
+                    {currentProvider === 'gemini' && isMemoryInspectorOpen && (
+                      <div className="composer-discovery-card memory-inspector-card">
+                        <div className="composer-discovery-header">
+                          <div>
+                            <strong>GEMINI.md memory</strong>
+                            <span>{geminiMemoryStatus}</span>
+                          </div>
                           <button
                             className="btn btn-sm btn-ghost"
                             type="button"
-                            onClick={() => {
-                              setIsCommandPaletteOpen(false)
-                              setCommandPaletteQuery('')
-                            }}
+                            onClick={() => void refreshGeminiMemory()}
+                            disabled={!currentWorkspace}
                           >
-                            Dismiss
+                            Refresh
                           </button>
                         </div>
-                      </div>
-                      <input
-                        className="command-palette-search"
-                        type="search"
-                        aria-label={`Filter ${currentProviderLabel} commands`}
-                        value={commandPaletteQuery}
-                        onChange={(event) => setCommandPaletteQuery(event.target.value)}
-                        onKeyDown={(event) => {
-                          if (event.key === 'Escape') {
-                            setIsCommandPaletteOpen(false)
-                            setCommandPaletteQuery('')
-                          }
-                        }}
-                        placeholder={
-                          currentProvider === 'gemini'
-                            ? 'Filter commands, memory, hooks...'
-                            : `Filter ${currentProviderLabel} commands...`
-                        }
-                        autoFocus
-                      />
-                      <div className="command-palette-list">
-                        {commandPaletteGroups.map((group) => {
-                          const groupItems = visibleCommandPaletteItems.filter(
-                            (item) => item.group === group
-                          )
-                          if (groupItems.length === 0) return null
-                          return (
-                            <div key={group} className="command-palette-group">
-                              <div className="command-palette-group-title">{group}</div>
-                              {groupItems.map((item) => (
-                                <button
-                                  key={item.id}
-                                  className="command-palette-item"
-                                  type="button"
-                                  onClick={() => handlePaletteCommand(item)}
-                                  disabled={!currentWorkspace || !currentChat}
-                                  title={
-                                    currentProvider === 'gemini'
-                                      ? `Send ${item.command} to Gemini CLI`
-                                      : `Run ${item.command}`
-                                  }
-                                >
-                                  <span className="command-palette-command">{item.command}</span>
-                                  <span className="command-palette-copy">
-                                    <strong>{item.label}</strong>
-                                    <span>{item.description}</span>
-                                    {item.sourcePath && <small>{item.sourcePath}</small>}
+                        <div className="memory-inspector-actions">
+                          {COMMAND_PALETTE_CORE.filter((item) => item.group === 'Memory').map(
+                            (item) => (
+                              <button
+                                key={item.id}
+                                className="composer-picker-command"
+                                type="button"
+                                onClick={() => void handleBridgeCommand(item.command)}
+                                disabled={!currentWorkspace || !currentChat}
+                              >
+                                <span className="composer-picker-command-slash">
+                                  {item.command}
+                                </span>
+                              </button>
+                            )
+                          )}
+                        </div>
+                        <div className="memory-file-list">
+                          {geminiMemoryFiles.map((file) => (
+                            <details key={file.id} className="memory-file-card">
+                              <summary>
+                                <span className={`memory-file-scope scope-${file.scope}`}>
+                                  {file.scope}
+                                </span>
+                                <span className="memory-file-path">{file.displayPath}</span>
+                                {file.sizeBytes !== undefined && (
+                                  <span className="memory-file-size">
+                                    {formatBytes(file.sizeBytes)}
                                   </span>
-                                </button>
-                              ))}
+                                )}
+                              </summary>
+                              <pre
+                                className={`memory-file-content ${file.error ? 'memory-file-error' : ''}`}
+                              >
+                                {getMemoryPreviewText(file)}
+                              </pre>
+                            </details>
+                          ))}
+                          {geminiMemoryFiles.length === 0 && (
+                            <div className="memory-file-empty">
+                              No GEMINI.md files discovered yet.
                             </div>
-                          )
-                        })}
-                        {visibleCommandPaletteItems.length === 0 && (
-                          <div className="command-palette-empty">
-                            No commands match this filter.
-                          </div>
-                        )}
-                      </div>
-                    </div>
-                  )}
-                  {currentProvider === 'gemini' && isMemoryInspectorOpen && (
-                    <div className="composer-discovery-card memory-inspector-card">
-                      <div className="composer-discovery-header">
-                        <div>
-                          <strong>GEMINI.md memory</strong>
-                          <span>{geminiMemoryStatus}</span>
+                          )}
                         </div>
-                        <button
-                          className="btn btn-sm btn-ghost"
-                          type="button"
-                          onClick={() => void refreshGeminiMemory()}
-                          disabled={!currentWorkspace}
-                        >
-                          Refresh
-                        </button>
                       </div>
-                      <div className="memory-inspector-actions">
-                        {COMMAND_PALETTE_CORE.filter((item) => item.group === 'Memory').map(
-                          (item) => (
+                    )}
+                    <div className="composer-inline-pickers">
+                      <div className="composer-inline-pickers-left">
+                        {(() => {
+                          const workspaceActionDisabled = !currentWorkspace || !currentChat
+                          const plusSections: ComposerPlusPickerSection[] = [
+                            {
+                              id: 'add',
+                              title: 'Add',
+                              items: [
+                                {
+                                  id: 'attachment',
+                                  label: 'Attachment',
+                                  description: 'Add files or images',
+                                  icon: <PlusSymbolIcon />,
+                                  disabled: isCurrentComposerLocked,
+                                  onSelect: handlePickImages
+                                },
+                                {
+                                  id: 'attached-window',
+                                  label: attachedWindow ? 'Detach app' : 'Attach app',
+                                  description: attachedWindow
+                                    ? attachedWindow.streaming
+                                      ? 'Stop live capture and detach'
+                                      : 'Detach the picked window'
+                                    : 'Pick a running app window',
+                                  icon: <CommandSymbolIcon />,
+                                  disabled:
+                                    isCurrentComposerLocked ||
+                                    (!attachedWindow && isAttachingWindow),
+                                  onSelect: attachedWindow ? handleDetachWindow : handleAttachWindow
+                                }
+                              ]
+                            },
+                            {
+                              id: 'workspace',
+                              title: 'Workspace',
+                              items: isCurrentGlobalChat
+                                ? []
+                                : [
+                                    {
+                                      id: 'safety',
+                                      label: 'Status',
+                                      description: `${currentProviderLabel} safety and setup`,
+                                      icon: <TrustSymbolIcon />,
+                                      disabled: workspaceActionDisabled,
+                                      onSelect: () => setRightTab('safety')
+                                    },
+                                    {
+                                      id: 'diff',
+                                      label: 'Diff Studio',
+                                      description: `${currentProviderLabel} workspace changes`,
+                                      icon: <FileMenuSelectionIcon />,
+                                      disabled: workspaceActionDisabled,
+                                      onSelect: () => setRightTab('diff')
+                                    },
+                                    {
+                                      id: 'capabilities',
+                                      label: 'Models',
+                                      description: `${currentProviderLabel} capability state`,
+                                      icon: <ModelSymbolIcon />,
+                                      disabled: workspaceActionDisabled,
+                                      onSelect: () => setRightTab('capabilities')
+                                    }
+                                  ]
+                            },
+                            {
+                              id: 'commands',
+                              title: 'Commands',
+                              items: isCurrentGlobalChat
+                                ? []
+                                : [
+                                    {
+                                      id: 'palette',
+                                      label:
+                                        currentProvider === 'gemini'
+                                          ? 'Slash commands'
+                                          : 'Command palette',
+                                      description:
+                                        currentProvider === 'gemini'
+                                          ? 'Gemini slash command palette'
+                                          : `${currentProviderLabel} command palette`,
+                                      icon: <CommandSymbolIcon />,
+                                      active: isCommandPaletteOpen,
+                                      disabled: workspaceActionDisabled,
+                                      onSelect: () => setIsCommandPaletteOpen((current) => !current)
+                                    },
+                                    {
+                                      id: 'review',
+                                      label: isPreparingDiffReview
+                                        ? 'Preparing review'
+                                        : 'Review diff',
+                                      description: 'Read-only plan-mode review',
+                                      icon: <ReviewSymbolIcon />,
+                                      disabled: workspaceActionDisabled || isPreparingDiffReview,
+                                      onSelect: () => void handleReviewCurrentDiff()
+                                    }
+                                  ]
+                            }
+                          ]
+                          return (
+                            <ComposerPlusPicker
+                              provider={currentProvider}
+                              composerStyle={appearance.composerStyle}
+                              sections={plusSections}
+                              disabled={isCurrentComposerLocked}
+                              triggerIcon={<PlusSymbolIcon />}
+                            />
+                          )
+                        })()}
+                        {/* 1.0.4-AS3 — the old name-pill (Application × ) is gone;
+                        the attached-window affordance now lives in the
+                        composer telemetry row as a Screen Watch icon
+                        button (see further down). Removing it from this
+                        action-row position avoids visually competing with
+                        the model picker / send button. */}
+                        {isCurrentEnsembleChat && currentChat?.ensemble && (
+                          <span
+                            className="composer-ensemble-mode"
+                            role="group"
+                            aria-label="Ensemble orchestration mode"
+                            title={
+                              isCurrentEnsembleRoundRunning
+                                ? `Current round: ${activeEnsembleOrchestrationMode === 'continuous' ? 'Continuous' : 'Turn-bound'}`
+                                : 'Choose whether agents speak once per round or can hand work back and forth.'
+                            }
+                            data-composer-control="ensemble-mode"
+                          >
                             <button
-                              key={item.id}
-                              className="composer-picker-command"
                               type="button"
-                              onClick={() => void handleBridgeCommand(item.command)}
-                              disabled={!currentWorkspace || !currentChat}
+                              className={`composer-ensemble-mode-button ${currentEnsembleOrchestrationMode === 'turn_bound' ? 'is-active' : ''}`}
+                              onClick={() => updateCurrentEnsembleOrchestrationMode('turn_bound')}
                             >
-                              <span className="composer-picker-command-slash">{item.command}</span>
+                              Turn
                             </button>
-                          )
-                        )}
-                      </div>
-                      <div className="memory-file-list">
-                        {geminiMemoryFiles.map((file) => (
-                          <details key={file.id} className="memory-file-card">
-                            <summary>
-                              <span className={`memory-file-scope scope-${file.scope}`}>
-                                {file.scope}
-                              </span>
-                              <span className="memory-file-path">{file.displayPath}</span>
-                              {file.sizeBytes !== undefined && (
-                                <span className="memory-file-size">
-                                  {formatBytes(file.sizeBytes)}
-                                </span>
-                              )}
-                            </summary>
-                            <pre
-                              className={`memory-file-content ${file.error ? 'memory-file-error' : ''}`}
+                            <button
+                              type="button"
+                              className={`composer-ensemble-mode-button ${currentEnsembleOrchestrationMode === 'continuous' ? 'is-active' : ''}`}
+                              onClick={() => updateCurrentEnsembleOrchestrationMode('continuous')}
                             >
-                              {getMemoryPreviewText(file)}
-                            </pre>
-                          </details>
-                        ))}
-                        {geminiMemoryFiles.length === 0 && (
-                          <div className="memory-file-empty">
-                            No GEMINI.md files discovered yet.
-                          </div>
+                              Continuous
+                            </button>
+                            {/* 1.0.4-AK2 — Work Session entry point. Sits
+                              alongside Turn/Continuous since Work Session
+                              is a third orchestration mode (it composes
+                              ON TOP of either turn-bound or continuous
+                              rounds, but the user picks it via the same
+                              mode group for discoverability). */}
+                            <button
+                              type="button"
+                              className={`composer-ensemble-mode-button work-session-mode-button ${
+                                currentChat?.ensemble?.workSession?.status === 'active' ||
+                                currentChat?.ensemble?.workSession?.status === 'paused'
+                                  ? 'is-active'
+                                  : ''
+                              }`}
+                              onClick={() => setShowWorkSessionSheet(true)}
+                              title="Open a Work Session — supervised multi-round autonomy with an objective + acceptance criteria + budget."
+                            >
+                              Work Session
+                            </button>
+                            {activeEnsembleOrchestrationMode === 'continuous' && (
+                              <ContinuousHopsLimitChip
+                                hops={currentEnsembleContinuationHops}
+                                maxHops={currentEnsembleMaxContinuationHops}
+                                onSave={updateCurrentEnsembleMaxContinuationHops}
+                              />
+                            )}
+                          </span>
                         )}
-                      </div>
-                    </div>
-                  )}
-                  <div className="composer-inline-pickers">
-                    <div className="composer-inline-pickers-left">
-                      {(() => {
-                        const workspaceActionDisabled = !currentWorkspace || !currentChat
-                        const plusSections: ComposerPlusPickerSection[] = [
-                          {
-                            id: 'add',
-                            title: 'Add',
-                            items: [
-                              {
-                                id: 'attachment',
-                                label: 'Attachment',
-                                description: 'Add files or images',
-                                icon: <PlusSymbolIcon />,
-                                disabled: isCurrentComposerLocked,
-                                onSelect: handlePickImages
-                              },
-                              {
-                                id: 'attached-window',
-                                label: attachedWindow ? 'Detach app' : 'Attach app',
-                                description: attachedWindow
-                                  ? attachedWindow.streaming
-                                    ? 'Stop live capture and detach'
-                                    : 'Detach the picked window'
-                                  : 'Pick a running app window',
-                                icon: <CommandSymbolIcon />,
-                                disabled:
-                                  isCurrentComposerLocked || (!attachedWindow && isAttachingWindow),
-                                onSelect: attachedWindow ? handleDetachWindow : handleAttachWindow
-                              }
-                            ]
-                          },
-                          {
-                            id: 'workspace',
-                            title: 'Workspace',
-                            items: isCurrentGlobalChat
-                              ? []
-                              : [
-                                  {
-                                    id: 'safety',
-                                    label: 'Status',
-                                    description: `${currentProviderLabel} safety and setup`,
-                                    icon: <TrustSymbolIcon />,
-                                    disabled: workspaceActionDisabled,
-                                    onSelect: () => setRightTab('safety')
-                                  },
-                                  {
-                                    id: 'diff',
-                                    label: 'Diff Studio',
-                                    description: `${currentProviderLabel} workspace changes`,
-                                    icon: <FileMenuSelectionIcon />,
-                                    disabled: workspaceActionDisabled,
-                                    onSelect: () => setRightTab('diff')
-                                  },
-                                  {
-                                    id: 'capabilities',
-                                    label: 'Models',
-                                    description: `${currentProviderLabel} capability state`,
-                                    icon: <ModelSymbolIcon />,
-                                    disabled: workspaceActionDisabled,
-                                    onSelect: () => setRightTab('capabilities')
-                                  }
-                                ]
-                          },
-                          {
-                            id: 'commands',
-                            title: 'Commands',
-                            items: isCurrentGlobalChat
-                              ? []
-                              : [
-                                  {
-                                    id: 'palette',
-                                    label:
-                                      currentProvider === 'gemini'
-                                        ? 'Slash commands'
-                                        : 'Command palette',
-                                    description:
-                                      currentProvider === 'gemini'
-                                        ? 'Gemini slash command palette'
-                                        : `${currentProviderLabel} command palette`,
-                                    icon: <CommandSymbolIcon />,
-                                    active: isCommandPaletteOpen,
-                                    disabled: workspaceActionDisabled,
-                                    onSelect: () => setIsCommandPaletteOpen((current) => !current)
-                                  },
-                                  {
-                                    id: 'review',
-                                    label: isPreparingDiffReview
-                                      ? 'Preparing review'
-                                      : 'Review diff',
-                                    description: 'Read-only plan-mode review',
-                                    icon: <ReviewSymbolIcon />,
-                                    disabled: workspaceActionDisabled || isPreparingDiffReview,
-                                    onSelect: () => void handleReviewCurrentDiff()
-                                  }
-                                ]
-                          }
-                        ]
-                        return (
-                          <ComposerPlusPicker
-                            provider={currentProvider}
-                            composerStyle={appearance.composerStyle}
-                            sections={plusSections}
-                            disabled={isCurrentComposerLocked}
-                            triggerIcon={<PlusSymbolIcon />}
-                          />
-                        )
-                      })()}
-                      {/* 1.0.4-AS3 — the old name-pill (Application × ) is gone;
-                      the attached-window affordance now lives in the
-                      composer telemetry row as a Screen Watch icon
-                      button (see further down). Removing it from this
-                      action-row position avoids visually competing with
-                      the model picker / send button. */}
-                      {isCurrentEnsembleChat && currentChat?.ensemble && (
-                        <span
-                          className="composer-ensemble-mode"
-                          role="group"
-                          aria-label="Ensemble orchestration mode"
-                          title={
-                            isCurrentEnsembleRoundRunning
-                              ? `Current round: ${activeEnsembleOrchestrationMode === 'continuous' ? 'Continuous' : 'Turn-bound'}`
-                              : 'Choose whether agents speak once per round or can hand work back and forth.'
+                        {/* Provider picker. In solo chats this remains the
+                          chat-level provider switch. In Ensemble chats it
+                          retargets to the selected participant so users can
+                          build same-provider panels without leaving the
+                          composer. */}
+                        {(() => {
+                          const ensembleBinding =
+                            isCurrentEnsembleChat && selectedParticipant
+                              ? selectedParticipant
+                              : null
+                          const pickerProvider = ensembleBinding?.provider ?? currentProvider
+                          const handleComposerProviderChange = (provider: ProviderId): void => {
+                            if (ensembleBinding) {
+                              const defaults = getDefaultEnsembleParticipantConfig(provider)
+                              updateSelectedParticipant({
+                                provider,
+                                model: defaults.model,
+                                runtimeProfileId: undefined,
+                                geminiAuthProfileId: provider === 'gemini' ? null : undefined,
+                                permissionPresetId: defaults.permissionPresetId,
+                                reasoningEffort: defaults.reasoningEffort,
+                                fastModeEnabled: defaults.fastModeEnabled,
+                                thinkingEnabled: defaults.thinkingEnabled,
+                                serviceTier: defaults.serviceTier,
+                                linkedProviderSessionId: null
+                              })
+                              return
+                            }
+                            void handleProviderChange(provider)
                           }
-                          data-composer-control="ensemble-mode"
-                        >
-                          <button
-                            type="button"
-                            className={`composer-ensemble-mode-button ${currentEnsembleOrchestrationMode === 'turn_bound' ? 'is-active' : ''}`}
-                            onClick={() => updateCurrentEnsembleOrchestrationMode('turn_bound')}
-                          >
-                            Turn
-                          </button>
-                          <button
-                            type="button"
-                            className={`composer-ensemble-mode-button ${currentEnsembleOrchestrationMode === 'continuous' ? 'is-active' : ''}`}
-                            onClick={() => updateCurrentEnsembleOrchestrationMode('continuous')}
-                          >
-                            Continuous
-                          </button>
-                          {/* 1.0.4-AK2 — Work Session entry point. Sits
-                            alongside Turn/Continuous since Work Session
-                            is a third orchestration mode (it composes
-                            ON TOP of either turn-bound or continuous
-                            rounds, but the user picks it via the same
-                            mode group for discoverability). */}
-                          <button
-                            type="button"
-                            className={`composer-ensemble-mode-button work-session-mode-button ${
-                              currentChat?.ensemble?.workSession?.status === 'active' ||
-                              currentChat?.ensemble?.workSession?.status === 'paused'
-                                ? 'is-active'
-                                : ''
-                            }`}
-                            onClick={() => setShowWorkSessionSheet(true)}
-                            title="Open a Work Session — supervised multi-round autonomy with an objective + acceptance criteria + budget."
-                          >
-                            Work Session
-                          </button>
-                          {activeEnsembleOrchestrationMode === 'continuous' && (
-                            <ContinuousHopsLimitChip
-                              hops={currentEnsembleContinuationHops}
-                              maxHops={currentEnsembleMaxContinuationHops}
-                              onSave={updateCurrentEnsembleMaxContinuationHops}
+                          // Rich popover provider picker (1.0.6-CRUX24).
+                          // Replaces the old native <select> with the same
+                          // body-portaled `composer-combined-picker-popover`
+                          // pattern the model / permission / "+" pickers use.
+                          // All prior behaviour is preserved verbatim:
+                          //   - `pickerProvider` (chat-level OR the bound
+                          //     ensemble participant's provider) drives the
+                          //     trigger + the active checkmark,
+                          //   - `handleComposerProviderChange` is the same
+                          //     handler the <select>'s onChange called, so
+                          //     the ensemble retarget vs solo provider-switch
+                          //     side effects are unchanged,
+                          //   - the disabled expression + the gated grok /
+                          //     cursor visibility + the title text are passed
+                          //     through identically,
+                          //   - `shell-${composerStyle}` (inside the
+                          //     component) makes the popover theme per shell
+                          //     with no per-shell branches here.
+                          return (
+                            <ComposerProviderPicker
+                              provider={pickerProvider}
+                              composerStyle={appearance.composerStyle}
+                              grokAvailable={grokProviderAvailable}
+                              cursorAvailable={cursorProviderAvailable}
+                              onSelect={handleComposerProviderChange}
+                              disabled={
+                                isCurrentComposerLocked ||
+                                (!ensembleBinding && isCurrentChatProviderLocked) ||
+                                Boolean(ensembleBinding && isCurrentEnsembleRoundRunning)
+                              }
+                              triggerIcon={<LinkCircleSymbolIcon />}
+                              title={ensembleBinding ? 'Selected participant provider' : 'Provider'}
                             />
-                          )}
-                        </span>
-                      )}
-                      {/* Provider picker. In solo chats this remains the
-                        chat-level provider switch. In Ensemble chats it
-                        retargets to the selected participant so users can
-                        build same-provider panels without leaving the
-                        composer. */}
-                      {(() => {
-                        const ensembleBinding =
-                          isCurrentEnsembleChat && selectedParticipant ? selectedParticipant : null
-                        const pickerProvider = ensembleBinding?.provider ?? currentProvider
-                        const handleComposerProviderChange = (provider: ProviderId): void => {
-                          if (ensembleBinding) {
-                            const defaults = getDefaultEnsembleParticipantConfig(provider)
-                            updateSelectedParticipant({
-                              provider,
-                              model: defaults.model,
-                              runtimeProfileId: undefined,
-                              geminiAuthProfileId: provider === 'gemini' ? null : undefined,
-                              permissionPresetId: defaults.permissionPresetId,
-                              reasoningEffort: defaults.reasoningEffort,
-                              fastModeEnabled: defaults.fastModeEnabled,
-                              thinkingEnabled: defaults.thinkingEnabled,
-                              serviceTier: defaults.serviceTier,
-                              linkedProviderSessionId: null
-                            })
-                            return
-                          }
-                          void handleProviderChange(provider)
-                        }
-                        // Rich popover provider picker (1.0.6-CRUX24).
-                        // Replaces the old native <select> with the same
-                        // body-portaled `composer-combined-picker-popover`
-                        // pattern the model / permission / "+" pickers use.
-                        // All prior behaviour is preserved verbatim:
-                        //   - `pickerProvider` (chat-level OR the bound
-                        //     ensemble participant's provider) drives the
-                        //     trigger + the active checkmark,
-                        //   - `handleComposerProviderChange` is the same
-                        //     handler the <select>'s onChange called, so
-                        //     the ensemble retarget vs solo provider-switch
-                        //     side effects are unchanged,
-                        //   - the disabled expression + the gated grok /
-                        //     cursor visibility + the title text are passed
-                        //     through identically,
-                        //   - `shell-${composerStyle}` (inside the
-                        //     component) makes the popover theme per shell
-                        //     with no per-shell branches here.
-                        return (
-                          <ComposerProviderPicker
-                            provider={pickerProvider}
-                            composerStyle={appearance.composerStyle}
-                            grokAvailable={grokProviderAvailable}
-                            cursorAvailable={cursorProviderAvailable}
-                            onSelect={handleComposerProviderChange}
-                            disabled={
-                              isCurrentComposerLocked ||
-                              (!ensembleBinding && isCurrentChatProviderLocked) ||
-                              Boolean(ensembleBinding && isCurrentEnsembleRoundRunning)
-                            }
-                            triggerIcon={<LinkCircleSymbolIcon />}
-                            title={ensembleBinding ? 'Selected participant provider' : 'Provider'}
-                          />
-                        )
-                      })()}
-                      {/* 1.0.5-AR12c — Workspace switcher previously
-                       lived here in the top inline-pickers row but
-                       crowded the approval / provider / model
-                       controls on dense windows. Moved to the
-                       composer's bottom telemetry row (below) where
-                       it sits spaced between the timecodes / Screen
-                       Watch cluster on the left and the token tally
-                       on the right. See the
-                       `data-composer-control="workspace"` mount
-                       inside `.composer-telemetry-row` below for
-                       the new placement; the underlying
-                       `ComposerWorkspaceSwitcher` component is
-                       unchanged. */}
-                      {(() => {
-                        // CombinedModelPicker — replaces the per-provider
-                        // native <select> chain that used to live here
-                        // (Model + Codex reasoning + Codex speed + Kimi
-                        // thinking + Claude reasoning) with one chip + a
-                        // two-column popover (Model | Reasoning).
-                        //
-                        // Slice F v2 (1.0.3) — when this is an ensemble
-                        // chat AND a participant chip is selected in the
-                        // strip above the composer, this picker rebinds
-                        // to that participant: it reads the participant's
-                        // model / reasoning / fast-mode and writes via
-                        // updateSelectedParticipant() instead of the
-                        // chat-level rememberCurrentChatComposerSelection.
-                        // `effective*` values below resolve to either the
-                        // chat-level hooks (solo chat) or the participant
-                        // (ensemble + selected chip).
-                        const ensembleBinding =
-                          isCurrentEnsembleChat && selectedParticipant ? selectedParticipant : null
-                        // Resolve the participant's effective settings via the
-                        // centralized helper so the per-provider fallbacks
-                        // (`'medium'` reasoning, fast-mode→serviceTier inference,
-                        // thinking off, etc.) live in one module. See
-                        // `src/renderer/src/lib/ensembleProviderDefaults.ts`.
-                        const ensembleResolved = ensembleBinding
-                          ? resolveEnsembleParticipantSettings(ensembleBinding)
-                          : null
-                        const effectiveProvider: ProviderId =
-                          ensembleBinding?.provider ?? currentProvider
-                        const effectiveModelOptionsRaw = ensembleBinding
-                          ? getProviderModelOptions(ensembleBinding.provider)
-                          : currentProviderModelOptions
-                        const effectiveSelectedModel = ensembleResolved
-                          ? ensembleResolved.model
-                          : selectedComposerModelType
-                        const effectiveCodexReasoning =
-                          ensembleResolved?.provider === 'codex'
-                            ? ensembleResolved.reasoningEffort
-                            : codexReasoningEffort
-                        const effectiveClaudeReasoning =
-                          ensembleResolved?.provider === 'claude'
-                            ? ensembleResolved.reasoningEffort
-                            : claudeReasoningEffort
-                        const effectiveKimiThinking =
-                          ensembleResolved?.provider === 'kimi'
-                            ? ensembleResolved.thinkingEnabled
-                            : kimiThinkingEnabled
-                        const effectiveCodexServiceTier =
-                          ensembleResolved?.provider === 'codex'
-                            ? ensembleResolved.serviceTier
-                            : codexServiceTier
-                        const effectiveClaudeFastMode =
-                          ensembleResolved?.provider === 'claude'
-                            ? ensembleResolved.fastModeEnabled
-                            : claudeFastMode
-
-                        const combinedModelOptions: CombinedModelPickerModelOption[] = [
-                          ...effectiveModelOptionsRaw.map((model) => {
-                            // 1.0.7-mini — forward the optional retiresAt only
-                            // when it's actually a string. Non-Codex provider
-                            // model shapes don't carry the field; the cast
-                            // narrows safely via the runtime typeof guard so
-                            // bad data can't leak into the picker.
-                            const retiresAtRaw = (model as { retiresAt?: unknown }).retiresAt
-                            const retiresAt =
-                              typeof retiresAtRaw === 'string' ? retiresAtRaw : undefined
-                            return {
-                              id: model.id,
-                              label: model.label || model.id,
-                              ...(retiresAt ? { retiresAt } : {})
-                            }
-                          }),
-                          ...(effectiveProvider !== 'kimi'
-                            ? [{ id: 'custom', label: 'Custom…' }]
-                            : [])
-                        ]
-
-                        let combinedReasoningOptions: CombinedModelPickerReasoningOption[] = []
-                        let combinedSelectedReasoning = ''
-                        if (effectiveProvider === 'codex') {
-                          // For ensemble binding we use a stable default
-                          // reasoning list (medium/high/xhigh) because the
-                          // participant doesn't carry per-model reasoning
-                          // sets the way `codexReasoningOptions` does for
-                          // the chat-level state.
-                          const sourceOptions = ensembleBinding
-                            ? [
-                                { reasoningEffort: 'medium' },
-                                { reasoningEffort: 'high' },
-                                { reasoningEffort: 'xhigh' }
-                              ]
-                            : codexReasoningOptions
-                          combinedReasoningOptions = sourceOptions.map((option) => ({
-                            value: option.reasoningEffort,
-                            label:
-                              option.reasoningEffort === 'xhigh'
-                                ? 'Extra High'
-                                : option.reasoningEffort.charAt(0).toUpperCase() +
-                                  option.reasoningEffort.slice(1)
-                          }))
-                          combinedSelectedReasoning = effectiveCodexReasoning
-                        } else if (effectiveProvider === 'claude') {
-                          const sourceOptions = ensembleBinding
-                            ? CLAUDE_THINKING_EFFORTS
-                            : claudeReasoningOptions
-                          combinedReasoningOptions = sourceOptions.map((option) => ({
-                            value: option.reasoningEffort,
-                            label:
-                              option.reasoningEffort === 'off'
-                                ? 'Thinking off'
-                                : option.reasoningEffort === 'high'
-                                  ? 'Max'
+                          )
+                        })()}
+                        {/* 1.0.5-AR12c — Workspace switcher previously
+                         lived here in the top inline-pickers row but
+                         crowded the approval / provider / model
+                         controls on dense windows. Moved to the
+                         composer's bottom telemetry row (below) where
+                         it sits spaced between the timecodes / Screen
+                         Watch cluster on the left and the token tally
+                         on the right. See the
+                         `data-composer-control="workspace"` mount
+                         inside `.composer-telemetry-row` below for
+                         the new placement; the underlying
+                         `ComposerWorkspaceSwitcher` component is
+                         unchanged. */}
+                        {(() => {
+                          // CombinedModelPicker — replaces the per-provider
+                          // native <select> chain that used to live here
+                          // (Model + Codex reasoning + Codex speed + Kimi
+                          // thinking + Claude reasoning) with one chip + a
+                          // two-column popover (Model | Reasoning).
+                          //
+                          // Slice F v2 (1.0.3) — when this is an ensemble
+                          // chat AND a participant chip is selected in the
+                          // strip above the composer, this picker rebinds
+                          // to that participant: it reads the participant's
+                          // model / reasoning / fast-mode and writes via
+                          // updateSelectedParticipant() instead of the
+                          // chat-level rememberCurrentChatComposerSelection.
+                          // `effective*` values below resolve to either the
+                          // chat-level hooks (solo chat) or the participant
+                          // (ensemble + selected chip).
+                          const ensembleBinding =
+                            isCurrentEnsembleChat && selectedParticipant
+                              ? selectedParticipant
+                              : null
+                          // Resolve the participant's effective settings via the
+                          // centralized helper so the per-provider fallbacks
+                          // (`'medium'` reasoning, fast-mode→serviceTier inference,
+                          // thinking off, etc.) live in one module. See
+                          // `src/renderer/src/lib/ensembleProviderDefaults.ts`.
+                          const ensembleResolved = ensembleBinding
+                            ? resolveEnsembleParticipantSettings(ensembleBinding)
+                            : null
+                          const effectiveProvider: ProviderId =
+                            ensembleBinding?.provider ?? currentProvider
+                          const effectiveModelOptionsRaw = ensembleBinding
+                            ? getProviderModelOptions(ensembleBinding.provider)
+                            : currentProviderModelOptions
+                          const effectiveSelectedModel = ensembleResolved
+                            ? ensembleResolved.model
+                            : selectedComposerModelType
+                          const effectiveCodexReasoning =
+                            ensembleResolved?.provider === 'codex'
+                              ? ensembleResolved.reasoningEffort
+                              : codexReasoningEffort
+                          const effectiveClaudeReasoning =
+                            ensembleResolved?.provider === 'claude'
+                              ? ensembleResolved.reasoningEffort
+                              : claudeReasoningEffort
+                          const effectiveKimiThinking =
+                            ensembleResolved?.provider === 'kimi'
+                              ? ensembleResolved.thinkingEnabled
+                              : kimiThinkingEnabled
+                          const effectiveCodexServiceTier =
+                            ensembleResolved?.provider === 'codex'
+                              ? ensembleResolved.serviceTier
+                              : codexServiceTier
+                          const effectiveClaudeFastMode =
+                            ensembleResolved?.provider === 'claude'
+                              ? ensembleResolved.fastModeEnabled
+                              : claudeFastMode
+
+                          const combinedModelOptions: CombinedModelPickerModelOption[] = [
+                            ...effectiveModelOptionsRaw.map((model) => {
+                              // 1.0.7-mini — forward the optional retiresAt only
+                              // when it's actually a string. Non-Codex provider
+                              // model shapes don't carry the field; the cast
+                              // narrows safely via the runtime typeof guard so
+                              // bad data can't leak into the picker.
+                              const retiresAtRaw = (model as { retiresAt?: unknown }).retiresAt
+                              const retiresAt =
+                                typeof retiresAtRaw === 'string' ? retiresAtRaw : undefined
+                              return {
+                                id: model.id,
+                                label: model.label || model.id,
+                                ...(retiresAt ? { retiresAt } : {})
+                              }
+                            }),
+                            ...(effectiveProvider !== 'kimi'
+                              ? [{ id: 'custom', label: 'Custom…' }]
+                              : [])
+                          ]
+
+                          let combinedReasoningOptions: CombinedModelPickerReasoningOption[] = []
+                          let combinedSelectedReasoning = ''
+                          if (effectiveProvider === 'codex') {
+                            // For ensemble binding we use a stable default
+                            // reasoning list (medium/high/xhigh) because the
+                            // participant doesn't carry per-model reasoning
+                            // sets the way `codexReasoningOptions` does for
+                            // the chat-level state.
+                            const sourceOptions = ensembleBinding
+                              ? [
+                                  { reasoningEffort: 'medium' },
+                                  { reasoningEffort: 'high' },
+                                  { reasoningEffort: 'xhigh' }
+                                ]
+                              : codexReasoningOptions
+                            combinedReasoningOptions = sourceOptions.map((option) => ({
+                              value: option.reasoningEffort,
+                              label:
+                                option.reasoningEffort === 'xhigh'
+                                  ? 'Extra High'
                                   : option.reasoningEffort.charAt(0).toUpperCase() +
                                     option.reasoningEffort.slice(1)
-                          }))
-                          combinedSelectedReasoning = effectiveClaudeReasoning
-                        } else if (effectiveProvider === 'kimi') {
-                          combinedReasoningOptions = [
-                            { value: 'on', label: 'Thinking on' },
-                            { value: 'off', label: 'Thinking off' }
-                          ]
-                          combinedSelectedReasoning = effectiveKimiThinking ? 'on' : 'off'
-                        }
+                            }))
+                            combinedSelectedReasoning = effectiveCodexReasoning
+                          } else if (effectiveProvider === 'claude') {
+                            const sourceOptions = ensembleBinding
+                              ? CLAUDE_THINKING_EFFORTS
+                              : claudeReasoningOptions
+                            combinedReasoningOptions = sourceOptions.map((option) => ({
+                              value: option.reasoningEffort,
+                              label:
+                                option.reasoningEffort === 'off'
+                                  ? 'Thinking off'
+                                  : option.reasoningEffort === 'high'
+                                    ? 'Max'
+                                    : option.reasoningEffort.charAt(0).toUpperCase() +
+                                      option.reasoningEffort.slice(1)
+                            }))
+                            combinedSelectedReasoning = effectiveClaudeReasoning
+                          } else if (effectiveProvider === 'kimi') {
+                            combinedReasoningOptions = [
+                              { value: 'on', label: 'Thinking on' },
+                              { value: 'off', label: 'Thinking off' }
+                            ]
+                            combinedSelectedReasoning = effectiveKimiThinking ? 'on' : 'off'
+                          }
 
-                        const handleCombinedModelChange = (nextModel: string) => {
-                          if (ensembleBinding) {
-                            const patch: Partial<EnsembleParticipant> = { model: nextModel }
-                            // Drop fast-mode if the new model can't support
-                            // it, mirroring the chat-level handler below.
-                            if (effectiveProvider === 'codex') {
-                              const modelOption = codexModels.find((m) => m.id === nextModel)
-                              if (modelOption?.defaultReasoningEffort) {
-                                patch.reasoningEffort = modelOption.defaultReasoningEffort
-                              }
-                              if (!modelOption?.additionalSpeedTiers?.includes('fast')) {
-                                patch.fastModeEnabled = false
-                                patch.serviceTier = ''
+                          const handleCombinedModelChange = (nextModel: string) => {
+                            if (ensembleBinding) {
+                              const patch: Partial<EnsembleParticipant> = { model: nextModel }
+                              // Drop fast-mode if the new model can't support
+                              // it, mirroring the chat-level handler below.
+                              if (effectiveProvider === 'codex') {
+                                const modelOption = codexModels.find((m) => m.id === nextModel)
+                                if (modelOption?.defaultReasoningEffort) {
+                                  patch.reasoningEffort = modelOption.defaultReasoningEffort
+                                }
+                                if (!modelOption?.additionalSpeedTiers?.includes('fast')) {
+                                  patch.fastModeEnabled = false
+                                  patch.serviceTier = ''
+                                }
                               }
-                            }
-                            if (effectiveProvider === 'claude') {
-                              const claudeModelOption = (
-                                agentModelsByProvider.claude || CLAUDE_DEFAULT_MODELS
-                              ).find((m) => m.id === nextModel)
-                              if (!claudeModelOption?.additionalSpeedTiers?.includes('fast')) {
-                                patch.fastModeEnabled = false
+                              if (effectiveProvider === 'claude') {
+                                const claudeModelOption = (
+                                  agentModelsByProvider.claude || CLAUDE_DEFAULT_MODELS
+                                ).find((m) => m.id === nextModel)
+                                if (!claudeModelOption?.additionalSpeedTiers?.includes('fast')) {
+                                  patch.fastModeEnabled = false
+                                }
                               }
+                              updateSelectedParticipant(patch)
+                              return
                             }
-                            updateSelectedParticipant(patch)
-                            return
-                          }
-                          if (nextModel !== 'custom') {
-                            setLastNonCustomModelType(nextModel)
-                          }
-                          setSelectedModelType(nextModel)
-                          const metadataPatch: Record<string, unknown> = {
-                            selectedModelType: nextModel
-                          }
-                          if (currentProvider === 'codex') {
-                            const modelOption = codexModels.find((model) => model.id === nextModel)
-                            if (modelOption?.defaultReasoningEffort) {
-                              setCodexReasoningEffort(modelOption.defaultReasoningEffort)
-                              metadataPatch.codexReasoningEffort =
-                                modelOption.defaultReasoningEffort
-                            }
-                            if (!modelOption?.additionalSpeedTiers?.includes('fast')) {
-                              setCodexServiceTier('')
-                              metadataPatch.codexServiceTier = ''
+                            if (nextModel !== 'custom') {
+                              setLastNonCustomModelType(nextModel)
                             }
-                          }
-                          if (currentProvider === 'claude') {
-                            // Symmetric to Codex above: clear Fast when
-                            // switching to a non-capable Claude model so
-                            // the persisted flag doesn't outlive its
-                            // applicability.
-                            const claudeModelOption = (
-                              agentModelsByProvider.claude || CLAUDE_DEFAULT_MODELS
-                            ).find((model) => model.id === nextModel)
-                            if (!claudeModelOption?.additionalSpeedTiers?.includes('fast')) {
-                              setClaudeFastMode(false)
-                              metadataPatch.claudeFastMode = false
+                            setSelectedModelType(nextModel)
+                            const metadataPatch: Record<string, unknown> = {
+                              selectedModelType: nextModel
                             }
-                          }
-                          if (currentProvider === 'gemini') {
-                            syncPersistentModelSelection(nextModel)
-                          }
-                          rememberCurrentChatComposerSelection(metadataPatch)
-                        }
-
-                        /*
-                         * Fast Mode toggle inside the picker. Replaces
-                         * the standalone Codex-only speed `<select>`
-                         * that previously sat next to the chip — same
-                         * underlying state, just surfaced inside the
-                         * Model+Reasoning popover so the user finds it
-                         * where they're already adjusting reasoning.
-                         */
-                        const fastModeCapableModelIds = (() => {
-                          if (effectiveProvider === 'codex') {
-                            return new Set(
-                              codexModels
-                                .filter((model) => model.additionalSpeedTiers?.includes('fast'))
-                                .map((model) => model.id)
-                            )
-                          }
-                          if (effectiveProvider === 'claude') {
-                            return new Set(
-                              (agentModelsByProvider.claude || CLAUDE_DEFAULT_MODELS)
-                                .filter((model) => model.additionalSpeedTiers?.includes('fast'))
-                                .map((model) => model.id)
-                            )
-                          }
-                          if (effectiveProvider === 'cursor') {
-                            // Cursor's "fast" is a distinct model id
-                            // (composer-2.5-fast) rather than a tier flag, so the
-                            // toggle swaps between the two Composer 2.5 ids. Both
-                            // are "capable" so the bolt is always live for Cursor.
-                            return new Set(['composer-2.5', 'composer-2.5-fast'])
-                          }
-                          // Gemini + Kimi: no Fast tier — hide the toggle
-                          // by passing an empty set (CombinedModelPicker
-                          // skips rendering the row in that case).
-                          return new Set<string>()
-                        })()
-                        const fastModeEnabledForProvider =
-                          effectiveProvider === 'codex'
-                            ? effectiveCodexServiceTier === 'fast'
-                            : effectiveProvider === 'claude'
-                              ? effectiveClaudeFastMode
-                              : effectiveProvider === 'cursor'
-                                ? effectiveSelectedModel === 'composer-2.5-fast'
-                                : false
-                        const handleToggleFastMode =
-                          effectiveProvider === 'codex'
-                            ? () => {
-                                const nextTier = effectiveCodexServiceTier === 'fast' ? '' : 'fast'
-                                if (ensembleBinding) {
-                                  updateSelectedParticipant({
-                                    serviceTier: nextTier,
-                                    fastModeEnabled: nextTier === 'fast'
-                                  })
-                                  return
-                                }
-                                setCodexServiceTier(nextTier)
-                                rememberCurrentChatComposerSelection({
-                                  codexServiceTier: nextTier
-                                })
+                            if (currentProvider === 'codex') {
+                              const modelOption = codexModels.find(
+                                (model) => model.id === nextModel
+                              )
+                              if (modelOption?.defaultReasoningEffort) {
+                                setCodexReasoningEffort(modelOption.defaultReasoningEffort)
+                                metadataPatch.codexReasoningEffort =
+                                  modelOption.defaultReasoningEffort
+                              }
+                              if (!modelOption?.additionalSpeedTiers?.includes('fast')) {
+                                setCodexServiceTier('')
+                                metadataPatch.codexServiceTier = ''
+                              }
+                            }
+                            if (currentProvider === 'claude') {
+                              // Symmetric to Codex above: clear Fast when
+                              // switching to a non-capable Claude model so
+                              // the persisted flag doesn't outlive its
+                              // applicability.
+                              const claudeModelOption = (
+                                agentModelsByProvider.claude || CLAUDE_DEFAULT_MODELS
+                              ).find((model) => model.id === nextModel)
+                              if (!claudeModelOption?.additionalSpeedTiers?.includes('fast')) {
+                                setClaudeFastMode(false)
+                                metadataPatch.claudeFastMode = false
                               }
-                            : effectiveProvider === 'claude'
+                            }
+                            if (currentProvider === 'gemini') {
+                              syncPersistentModelSelection(nextModel)
+                            }
+                            rememberCurrentChatComposerSelection(metadataPatch)
+                          }
+
+                          /*
+                           * Fast Mode toggle inside the picker. Replaces
+                           * the standalone Codex-only speed `<select>`
+                           * that previously sat next to the chip — same
+                           * underlying state, just surfaced inside the
+                           * Model+Reasoning popover so the user finds it
+                           * where they're already adjusting reasoning.
+                           */
+                          const fastModeCapableModelIds = (() => {
+                            if (effectiveProvider === 'codex') {
+                              return new Set(
+                                codexModels
+                                  .filter((model) => model.additionalSpeedTiers?.includes('fast'))
+                                  .map((model) => model.id)
+                              )
+                            }
+                            if (effectiveProvider === 'claude') {
+                              return new Set(
+                                (agentModelsByProvider.claude || CLAUDE_DEFAULT_MODELS)
+                                  .filter((model) => model.additionalSpeedTiers?.includes('fast'))
+                                  .map((model) => model.id)
+                              )
+                            }
+                            if (effectiveProvider === 'cursor') {
+                              // Cursor's "fast" is a distinct model id
+                              // (composer-2.5-fast) rather than a tier flag, so the
+                              // toggle swaps between the two Composer 2.5 ids. Both
+                              // are "capable" so the bolt is always live for Cursor.
+                              return new Set(['composer-2.5', 'composer-2.5-fast'])
+                            }
+                            // Gemini + Kimi: no Fast tier — hide the toggle
+                            // by passing an empty set (CombinedModelPicker
+                            // skips rendering the row in that case).
+                            return new Set<string>()
+                          })()
+                          const fastModeEnabledForProvider =
+                            effectiveProvider === 'codex'
+                              ? effectiveCodexServiceTier === 'fast'
+                              : effectiveProvider === 'claude'
+                                ? effectiveClaudeFastMode
+                                : effectiveProvider === 'cursor'
+                                  ? effectiveSelectedModel === 'composer-2.5-fast'
+                                  : false
+                          const handleToggleFastMode =
+                            effectiveProvider === 'codex'
                               ? () => {
-                                  const nextFast = !effectiveClaudeFastMode
+                                  const nextTier =
+                                    effectiveCodexServiceTier === 'fast' ? '' : 'fast'
                                   if (ensembleBinding) {
-                                    updateSelectedParticipant({ fastModeEnabled: nextFast })
+                                    updateSelectedParticipant({
+                                      serviceTier: nextTier,
+                                      fastModeEnabled: nextTier === 'fast'
+                                    })
                                     return
                                   }
-                                  setClaudeFastMode(nextFast)
+                                  setCodexServiceTier(nextTier)
                                   rememberCurrentChatComposerSelection({
-                                    claudeFastMode: nextFast
+                                    codexServiceTier: nextTier
                                   })
                                 }
-                              : effectiveProvider === 'cursor'
+                              : effectiveProvider === 'claude'
                                 ? () => {
-                                    // Cursor fast = the composer-2.5-fast model id;
-                                    // swap the selected model (handleCombinedModelChange
-                                    // handles both chat-level + ensemble-participant
-                                    // persistence). No separate fast flag needed.
-                                    const nextModel =
-                                      effectiveSelectedModel === 'composer-2.5-fast'
-                                        ? 'composer-2.5'
-                                        : 'composer-2.5-fast'
-                                    handleCombinedModelChange(nextModel)
+                                    const nextFast = !effectiveClaudeFastMode
+                                    if (ensembleBinding) {
+                                      updateSelectedParticipant({ fastModeEnabled: nextFast })
+                                      return
+                                    }
+                                    setClaudeFastMode(nextFast)
+                                    rememberCurrentChatComposerSelection({
+                                      claudeFastMode: nextFast
+                                    })
                                   }
-                                : undefined
-
-                        const handleCombinedReasoningChange = (value: string) => {
-                          if (ensembleBinding) {
-                            if (ensembleBinding.provider === 'kimi') {
-                              updateSelectedParticipant({ thinkingEnabled: value !== 'off' })
-                            } else {
-                              updateSelectedParticipant({ reasoningEffort: value })
+                                : effectiveProvider === 'cursor'
+                                  ? () => {
+                                      // Cursor fast = the composer-2.5-fast model id;
+                                      // swap the selected model (handleCombinedModelChange
+                                      // handles both chat-level + ensemble-participant
+                                      // persistence). No separate fast flag needed.
+                                      const nextModel =
+                                        effectiveSelectedModel === 'composer-2.5-fast'
+                                          ? 'composer-2.5'
+                                          : 'composer-2.5-fast'
+                                      handleCombinedModelChange(nextModel)
+                                    }
+                                  : undefined
+
+                          const handleCombinedReasoningChange = (value: string) => {
+                            if (ensembleBinding) {
+                              if (ensembleBinding.provider === 'kimi') {
+                                updateSelectedParticipant({ thinkingEnabled: value !== 'off' })
+                              } else {
+                                updateSelectedParticipant({ reasoningEffort: value })
+                              }
+                              return
+                            }
+                            if (currentProvider === 'codex') {
+                              setCodexReasoningEffort(value)
+                              rememberCurrentChatComposerSelection({
+                                codexReasoningEffort: value
+                              })
+                            } else if (currentProvider === 'claude') {
+                              setClaudeReasoningEffort(value)
+                              rememberCurrentChatComposerSelection({
+                                claudeReasoningEffort: value
+                              })
+                            } else if (currentProvider === 'kimi') {
+                              const enabled = value !== 'off'
+                              setKimiThinkingEnabled(enabled)
+                              rememberCurrentChatComposerSelection({
+                                kimiThinkingEnabled: enabled
+                              })
                             }
-                            return
-                          }
-                          if (currentProvider === 'codex') {
-                            setCodexReasoningEffort(value)
-                            rememberCurrentChatComposerSelection({
-                              codexReasoningEffort: value
-                            })
-                          } else if (currentProvider === 'claude') {
-                            setClaudeReasoningEffort(value)
-                            rememberCurrentChatComposerSelection({
-                              claudeReasoningEffort: value
-                            })
-                          } else if (currentProvider === 'kimi') {
-                            const enabled = value !== 'off'
-                            setKimiThinkingEnabled(enabled)
-                            rememberCurrentChatComposerSelection({
-                              kimiThinkingEnabled: enabled
-                            })
                           }
-                        }
 
-                        return (
-                          <>
-                            <CombinedModelPicker
+                          return (
+                            <>
+                              <CombinedModelPicker
+                                provider={effectiveProvider}
+                                composerStyle={appearance.composerStyle}
+                                modelOptions={combinedModelOptions}
+                                selectedModelId={effectiveSelectedModel}
+                                onSelectModel={handleCombinedModelChange}
+                                reasoningOptions={combinedReasoningOptions}
+                                selectedReasoning={combinedSelectedReasoning}
+                                onSelectReasoning={handleCombinedReasoningChange}
+                                codexReasoningEffort={effectiveCodexReasoning}
+                                claudeReasoningEffort={effectiveClaudeReasoning}
+                                kimiThinkingEnabled={effectiveKimiThinking}
+                                fastModeCapableModelIds={fastModeCapableModelIds}
+                                fastModeEnabled={fastModeEnabledForProvider}
+                                onToggleFastMode={handleToggleFastMode}
+                                disabled={isCurrentComposerLocked}
+                              />
+                              {!ensembleBinding &&
+                                selectedModelType === 'custom' &&
+                                currentProvider !== 'kimi' && (
+                                  <span className="composer-inline-custom-model">
+                                    <input
+                                      className="composer-inline-input"
+                                      type="text"
+                                      value={customModel}
+                                      onChange={(e) => {
+                                        setCustomModel(e.target.value)
+                                        rememberCurrentChatComposerSelection({
+                                          customModel: e.target.value
+                                        })
+                                        if (currentProvider === 'gemini') {
+                                          markPersistentSessionRestartNeeded(
+                                            'Gemini custom model changed. Restart the persistent session to apply the new model.'
+                                          )
+                                        }
+                                      }}
+                                      placeholder="Model ID"
+                                      disabled={isCurrentComposerLocked}
+                                    />
+                                    <button
+                                      className="composer-inline-clear"
+                                      type="button"
+                                      onClick={() => {
+                                        setCustomModel('')
+                                        setSelectedModelType(lastNonCustomModelType)
+                                        rememberCurrentChatComposerSelection({
+                                          customModel: '',
+                                          selectedModelType: lastNonCustomModelType
+                                        })
+                                        if (currentProvider === 'gemini') {
+                                          syncPersistentModelSelection(lastNonCustomModelType)
+                                        }
+                                      }}
+                                      disabled={isCurrentComposerLocked}
+                                      title="Cancel custom model"
+                                      aria-label="Cancel custom model"
+                                    >
+                                      <XSymbolIcon />
+                                    </button>
+                                  </span>
+                                )}
+                            </>
+                          )
+                        })()}
+
+                        {/*
+                        Codex speed-tier `<select>` removed — Fast mode
+                        now lives inside CombinedModelPicker as a toggle
+                        beneath the Reasoning column, gated by each
+                        model's `additionalSpeedTiers`. Same underlying
+                        `codexServiceTier` state, surfaced in the same
+                        popover the user already opens to tweak
+                        reasoning effort.
+                      */}
+
+                        {(() => {
+                          // CombinedPermissionsPicker — replaces the
+                          // native <select> permission picker AND
+                          // absorbs the old "Tool Grants" pill from the
+                          // above-bar. Single chip, two-column popover
+                          // (Permissions | Tool Grants).
+                          //
+                          // Slice F v2 (1.0.3) — when ensemble + a
+                          // participant chip is selected, the picker
+                          // reads/writes the participant's
+                          // `permissionPresetId` instead of the chat's
+                          // `approvalMode`. The user-facing 3-mode UI
+                          // stays the same (Plan / Default / Full
+                          // Workspace Access) but we translate
+                          // bidirectionally to the preset vocabulary
+                          // (`read_only` / `default` / `workspace_write`).
+                          // Slice A3 — in Ensemble Mode, Tool Grants are
+                          // participant-scoped overrides. Solo chats keep
+                          // using provider+workspace grants.
+                          const ensembleBinding =
+                            isCurrentEnsembleChat && selectedParticipant
+                              ? selectedParticipant
+                              : null
+                          const effectiveProvider: ProviderId =
+                            ensembleBinding?.provider ?? currentProvider
+                          const presetToMode = (preset: string | undefined): string => {
+                            if (preset === 'read_only') return 'plan'
+                            if (preset === 'workspace_write') return 'auto_edit'
+                            if (preset === 'full_access') return 'auto_edit'
+                            return 'default'
+                          }
+                          const modeToPreset = (mode: string): PermissionPresetId => {
+                            if (mode === 'plan') return 'read_only'
+                            if (mode === 'auto_edit') return 'workspace_write'
+                            return 'default'
+                          }
+                          const effectiveSelectedPermission = ensembleBinding
+                            ? presetToMode(ensembleBinding.permissionPresetId)
+                            : approvalMode
+                          const permissionPickerOptions: PermissionOption[] = [
+                            { value: 'plan', label: 'Plan / Read-only' },
+                            { value: 'default', label: 'Default Approval' },
+                            { value: 'auto_edit', label: 'Full Workspace Access' }
+                          ]
+                          const normalizedWorkspacePath = (currentWorkspace?.path || '').replace(
+                            /\/+$/,
+                            ''
+                          )
+                          const enabledGrantIds = ensembleBinding
+                            ? getParticipantToolGrantIds(ensembleBinding)
+                            : new Set(
+                                agenticWorkspaceGrants
+                                  .filter((grant) => {
+                                    if (
+                                      !grant ||
+                                      grant.provider !== effectiveProvider ||
+                                      !grant.workspacePath
+                                    )
+                                      return false
+                                    return (
+                                      grant.workspacePath.replace(/\/+$/, '') ===
+                                      normalizedWorkspacePath
+                                    )
+                                  })
+                                  .map((grant) => grant.service)
+                              )
+                          // Hide the Tool-Grants column when there's no
+                          // workspace path to scope grants to (global
+                          // chats or pre-workspace state).
+                          const grantServicesForPicker =
+                            currentWorkspace && !isCurrentGlobalChat
+                              ? WORKSPACE_POLICY_SERVICES
+                              : []
+                          return (
+                            <CombinedPermissionsPicker
                               provider={effectiveProvider}
                               composerStyle={appearance.composerStyle}
-                              modelOptions={combinedModelOptions}
-                              selectedModelId={effectiveSelectedModel}
-                              onSelectModel={handleCombinedModelChange}
-                              reasoningOptions={combinedReasoningOptions}
-                              selectedReasoning={combinedSelectedReasoning}
-                              onSelectReasoning={handleCombinedReasoningChange}
-                              codexReasoningEffort={effectiveCodexReasoning}
-                              claudeReasoningEffort={effectiveClaudeReasoning}
-                              kimiThinkingEnabled={effectiveKimiThinking}
-                              fastModeCapableModelIds={fastModeCapableModelIds}
-                              fastModeEnabled={fastModeEnabledForProvider}
-                              onToggleFastMode={handleToggleFastMode}
-                              disabled={isCurrentComposerLocked}
-                            />
-                            {!ensembleBinding &&
-                              selectedModelType === 'custom' &&
-                              currentProvider !== 'kimi' && (
-                                <span className="composer-inline-custom-model">
-                                  <input
-                                    className="composer-inline-input"
-                                    type="text"
-                                    value={customModel}
-                                    onChange={(e) => {
-                                      setCustomModel(e.target.value)
-                                      rememberCurrentChatComposerSelection({
-                                        customModel: e.target.value
-                                      })
-                                      if (currentProvider === 'gemini') {
-                                        markPersistentSessionRestartNeeded(
-                                          'Gemini custom model changed. Restart the persistent session to apply the new model.'
-                                        )
-                                      }
-                                    }}
-                                    placeholder="Model ID"
-                                    disabled={isCurrentComposerLocked}
-                                  />
-                                  <button
-                                    className="composer-inline-clear"
-                                    type="button"
-                                    onClick={() => {
-                                      setCustomModel('')
-                                      setSelectedModelType(lastNonCustomModelType)
-                                      rememberCurrentChatComposerSelection({
-                                        customModel: '',
-                                        selectedModelType: lastNonCustomModelType
-                                      })
-                                      if (currentProvider === 'gemini') {
-                                        syncPersistentModelSelection(lastNonCustomModelType)
-                                      }
-                                    }}
-                                    disabled={isCurrentComposerLocked}
-                                    title="Cancel custom model"
-                                    aria-label="Cancel custom model"
-                                  >
-                                    <XSymbolIcon />
-                                  </button>
-                                </span>
-                              )}
-                          </>
-                        )
-                      })()}
-
-                      {/*
-                      Codex speed-tier `<select>` removed — Fast mode
-                      now lives inside CombinedModelPicker as a toggle
-                      beneath the Reasoning column, gated by each
-                      model's `additionalSpeedTiers`. Same underlying
-                      `codexServiceTier` state, surfaced in the same
-                      popover the user already opens to tweak
-                      reasoning effort.
-                    */}
-
-                      {(() => {
-                        // CombinedPermissionsPicker — replaces the
-                        // native <select> permission picker AND
-                        // absorbs the old "Tool Grants" pill from the
-                        // above-bar. Single chip, two-column popover
-                        // (Permissions | Tool Grants).
-                        //
-                        // Slice F v2 (1.0.3) — when ensemble + a
-                        // participant chip is selected, the picker
-                        // reads/writes the participant's
-                        // `permissionPresetId` instead of the chat's
-                        // `approvalMode`. The user-facing 3-mode UI
-                        // stays the same (Plan / Default / Full
-                        // Workspace Access) but we translate
-                        // bidirectionally to the preset vocabulary
-                        // (`read_only` / `default` / `workspace_write`).
-                        // Slice A3 — in Ensemble Mode, Tool Grants are
-                        // participant-scoped overrides. Solo chats keep
-                        // using provider+workspace grants.
-                        const ensembleBinding =
-                          isCurrentEnsembleChat && selectedParticipant ? selectedParticipant : null
-                        const effectiveProvider: ProviderId =
-                          ensembleBinding?.provider ?? currentProvider
-                        const presetToMode = (preset: string | undefined): string => {
-                          if (preset === 'read_only') return 'plan'
-                          if (preset === 'workspace_write') return 'auto_edit'
-                          if (preset === 'full_access') return 'auto_edit'
-                          return 'default'
-                        }
-                        const modeToPreset = (mode: string): PermissionPresetId => {
-                          if (mode === 'plan') return 'read_only'
-                          if (mode === 'auto_edit') return 'workspace_write'
-                          return 'default'
-                        }
-                        const effectiveSelectedPermission = ensembleBinding
-                          ? presetToMode(ensembleBinding.permissionPresetId)
-                          : approvalMode
-                        const permissionPickerOptions: PermissionOption[] = [
-                          { value: 'plan', label: 'Plan / Read-only' },
-                          { value: 'default', label: 'Default Approval' },
-                          { value: 'auto_edit', label: 'Full Workspace Access' }
-                        ]
-                        const normalizedWorkspacePath = (currentWorkspace?.path || '').replace(
-                          /\/+$/,
-                          ''
-                        )
-                        const enabledGrantIds = ensembleBinding
-                          ? getParticipantToolGrantIds(ensembleBinding)
-                          : new Set(
-                              agenticWorkspaceGrants
-                                .filter((grant) => {
-                                  if (
-                                    !grant ||
-                                    grant.provider !== effectiveProvider ||
-                                    !grant.workspacePath
+                              permissionOptions={permissionPickerOptions}
+                              selectedPermission={effectiveSelectedPermission}
+                              onSelectPermission={(nextApprovalMode) => {
+                                if (ensembleBinding) {
+                                  updateSelectedParticipant({
+                                    permissionPresetId: modeToPreset(nextApprovalMode)
+                                  })
+                                  return
+                                }
+                                setApprovalMode(nextApprovalMode)
+                                rememberCurrentChatComposerSelection({
+                                  approvalMode: nextApprovalMode
+                                })
+                                if (
+                                  currentProvider === 'gemini' &&
+                                  nextApprovalMode !== approvalMode
+                                ) {
+                                  markPersistentSessionRestartNeeded(
+                                    'Gemini approval mode changed. Restart the persistent session to apply the correct tool permissions.'
                                   )
-                                    return false
-                                  return (
-                                    grant.workspacePath.replace(/\/+$/, '') ===
-                                    normalizedWorkspacePath
+                                }
+                              }}
+                              grantServices={grantServicesForPicker}
+                              enabledGrantIds={enabledGrantIds}
+                              agenticServices={agenticServices}
+                              onToggleGrant={(service, enabled) => {
+                                if (ensembleBinding) {
+                                  updateSelectedParticipant(
+                                    buildParticipantToolGrantPatch(
+                                      ensembleBinding,
+                                      service,
+                                      enabled
+                                    )
                                   )
-                                })
-                                .map((grant) => grant.service)
-                            )
-                        // Hide the Tool-Grants column when there's no
-                        // workspace path to scope grants to (global
-                        // chats or pre-workspace state).
-                        const grantServicesForPicker =
-                          currentWorkspace && !isCurrentGlobalChat ? WORKSPACE_POLICY_SERVICES : []
-                        return (
-                          <CombinedPermissionsPicker
-                            provider={effectiveProvider}
-                            composerStyle={appearance.composerStyle}
-                            permissionOptions={permissionPickerOptions}
-                            selectedPermission={effectiveSelectedPermission}
-                            onSelectPermission={(nextApprovalMode) => {
-                              if (ensembleBinding) {
-                                updateSelectedParticipant({
-                                  permissionPresetId: modeToPreset(nextApprovalMode)
-                                })
-                                return
-                              }
-                              setApprovalMode(nextApprovalMode)
-                              rememberCurrentChatComposerSelection({
-                                approvalMode: nextApprovalMode
-                              })
-                              if (
-                                currentProvider === 'gemini' &&
-                                nextApprovalMode !== approvalMode
-                              ) {
-                                markPersistentSessionRestartNeeded(
-                                  'Gemini approval mode changed. Restart the persistent session to apply the correct tool permissions.'
-                                )
-                              }
-                            }}
-                            grantServices={grantServicesForPicker}
-                            enabledGrantIds={enabledGrantIds}
-                            agenticServices={agenticServices}
-                            onToggleGrant={(service, enabled) => {
-                              if (ensembleBinding) {
-                                updateSelectedParticipant(
-                                  buildParticipantToolGrantPatch(ensembleBinding, service, enabled)
+                                  return
+                                }
+                                void handleSetAgenticWorkspaceGrant(
+                                  service,
+                                  enabled,
+                                  effectiveProvider
                                 )
-                                return
+                              }}
+                              grantScopeLabel={ensembleBinding ? 'participant' : 'workspace'}
+                              disabled={
+                                isCurrentComposerLocked ||
+                                (effectiveProvider === 'gemini' && !geminiWorkspaceTrustReady)
                               }
-                              void handleSetAgenticWorkspaceGrant(
-                                service,
-                                enabled,
-                                effectiveProvider
-                              )
-                            }}
-                            grantScopeLabel={ensembleBinding ? 'participant' : 'workspace'}
-                            disabled={
-                              isCurrentComposerLocked ||
-                              (effectiveProvider === 'gemini' && !geminiWorkspaceTrustReady)
-                            }
-                          />
-                        )
-                      })()}
-
-                      {/* Slice A: collapsed-state chip for the dismissed
-                        YOLO banner. Sits adjacent to the permissions
-                        picker because YOLO is conceptually a permission
-                        override. Clicking re-summons the full banner. */}
-                      {sessionYoloMode.enabled && yoloBannerDismissed && (
-                        <button
-                          type="button"
-                          className="composer-yolo-chip"
-                          onClick={() => setYoloBannerDismissed(false)}
-                          title="Trust mode is active — every approval auto-allowed. Click to show details."
-                          aria-label="Trust mode active — show details"
-                        >
-                          <span className="composer-yolo-chip-icon" aria-hidden>
-                            ⚠
-                          </span>
-                          <span className="composer-yolo-chip-label">YOLO</span>
-                        </button>
-                      )}
+                            />
+                          )
+                        })()}
 
-                      {currentProvider === 'gemini' && !isCurrentGlobalChat && (
-                        <label className="composer-picker-label" title="Workspace trust">
-                          <TrustSymbolIcon />
-                          <select
-                            className="composer-inline-picker"
-                            aria-label="Workspace trust"
-                            value={trustSelectValue}
-                            onChange={(e) => {
-                              const nextValue = e.target.value
-                              if (
-                                nextValue === 'trusted' &&
-                                !sessionTrust &&
-                                trustResult?.status !== 'trusted' &&
-                                trustResult?.status !== 'inherited'
-                              ) {
-                                setSessionTrust(true)
-                                void handleBridgeCommand('/permissions trust')
-                              } else if (nextValue === 'untrusted') {
-                                setSessionTrust(false)
-                                markPersistentSessionRestartNeeded(
-                                  'Gemini workspace trust changed. Restart the persistent session to apply the trust setting.'
-                                )
-                              }
-                            }}
-                            disabled={isCurrentComposerLocked}
-                            title="Workspace trust"
+                        {/* Slice A: collapsed-state chip for the dismissed
+                          YOLO banner. Sits adjacent to the permissions
+                          picker because YOLO is conceptually a permission
+                          override. Clicking re-summons the full banner. */}
+                        {sessionYoloMode.enabled && yoloBannerDismissed && (
+                          <button
+                            type="button"
+                            className="composer-yolo-chip"
+                            onClick={() => setYoloBannerDismissed(false)}
+                            title="Trust mode is active — every approval auto-allowed. Click to show details."
+                            aria-label="Trust mode active — show details"
                           >
-                            <option value="trusted">Trusted</option>
-                            <option value="untrusted">Untrusted</option>
-                          </select>
-                        </label>
-                      )}
-                    </div>
-                    <div className="composer-inline-actions">
-                      <ContextWheel percent={contextUsedPercent} label={contextLabel} />
-                      {steerIndicatorMessage && (
-                        <span className="composer-steer-indicator" role="status" aria-live="polite">
-                          <span className="composer-steer-indicator-dot" aria-hidden />
-                          <span>{steerIndicatorMessage}</span>
-                        </span>
-                      )}
-                      {/*
-                      1.0.6-EW70 — the run/queue/steer/stop buttons are
-                      wrapped in `.composer-send-cluster` (display:contents
-                      by default, so the nine other shells are unchanged).
-                      Obsidian/Alabaster lift this cluster up into the
-                      textarea rect's bottom-right corner; the ContextWheel
-                      ("context") stays here at the right of the control row.
-                    */}
-                      <span className="composer-send-cluster">
-                        {isCurrentChatRunning ? (
-                          <>
-                            <button
-                              className={`composer-action-btn run-btn queue ${isSendConfirming ? 'send-confirming' : ''}`}
-                              onClick={() => {
-                                triggerSendConfirmation()
-                                handleRun()
+                            <span className="composer-yolo-chip-icon" aria-hidden>
+                              ⚠
+                            </span>
+                            <span className="composer-yolo-chip-label">YOLO</span>
+                          </button>
+                        )}
+
+                        {currentProvider === 'gemini' && !isCurrentGlobalChat && (
+                          <label className="composer-picker-label" title="Workspace trust">
+                            <TrustSymbolIcon />
+                            <select
+                              className="composer-inline-picker"
+                              aria-label="Workspace trust"
+                              value={trustSelectValue}
+                              onChange={(e) => {
+                                const nextValue = e.target.value
+                                if (
+                                  nextValue === 'trusted' &&
+                                  !sessionTrust &&
+                                  trustResult?.status !== 'trusted' &&
+                                  trustResult?.status !== 'inherited'
+                                ) {
+                                  setSessionTrust(true)
+                                  void handleBridgeCommand('/permissions trust')
+                                } else if (nextValue === 'untrusted') {
+                                  setSessionTrust(false)
+                                  markPersistentSessionRestartNeeded(
+                                    'Gemini workspace trust changed. Restart the persistent session to apply the trust setting.'
+                                  )
+                                }
                               }}
-                              disabled={
-                                !currentChat ||
-                                (!isCurrentGlobalChat && !currentWorkspace) ||
-                                !prompt.trim() ||
-                                (currentProvider === 'gemini' && !geminiWorkspaceTrustReady) ||
-                                isSteerBusyForCurrentChat
-                              }
-                              title="Queue next run"
-                              aria-label="Queue next run"
-                              type="button"
+                              disabled={isCurrentComposerLocked}
+                              title="Workspace trust"
                             >
-                              <QueueSymbolIcon />
-                            </button>
-                            {/* Phase J3 (steer): sit Steer between Queue and Stop
-                             *   - Queue waits passively for the chat's run to finish.
-                             *   - Steer interrupts and dispatches immediately.
-                             *   - Stop only interrupts (no follow-up dispatch).
-                             * Only render when THIS chat is busy (per-chat busy
-                             * predicate), so multi-chat parallel runs don't get a
-                             * misleading Steer button in idle chats. */}
-                            {isCurrentChatBusyForSteer && (
+                              <option value="trusted">Trusted</option>
+                              <option value="untrusted">Untrusted</option>
+                            </select>
+                          </label>
+                        )}
+                      </div>
+                      <div className="composer-inline-actions">
+                        <ContextWheel percent={contextUsedPercent} label={contextLabel} />
+                        {steerIndicatorMessage && (
+                          <span
+                            className="composer-steer-indicator"
+                            role="status"
+                            aria-live="polite"
+                          >
+                            <span className="composer-steer-indicator-dot" aria-hidden />
+                            <span>{steerIndicatorMessage}</span>
+                          </span>
+                        )}
+                        {/*
+                        1.0.6-EW70 — the run/queue/steer/stop buttons are
+                        wrapped in `.composer-send-cluster` (display:contents
+                        by default, so the nine other shells are unchanged).
+                        Obsidian/Alabaster lift this cluster up into the
+                        textarea rect's bottom-right corner; the ContextWheel
+                        ("context") stays here at the right of the control row.
+                      */}
+                        <span className="composer-send-cluster">
+                          {isCurrentChatRunning ? (
+                            <>
                               <button
-                                className={`composer-action-btn steer-btn ${isSteerBusyForCurrentChat ? 'is-busy' : ''}`}
-                                onClick={() => void handleSteer()}
+                                className={`composer-action-btn run-btn queue ${isSendConfirming ? 'send-confirming' : ''}`}
+                                onClick={() => {
+                                  triggerSendConfirmation()
+                                  handleRun()
+                                }}
                                 disabled={
                                   !currentChat ||
                                   (!isCurrentGlobalChat && !currentWorkspace) ||
@@ -18916,246 +19172,272 @@ function App(): React.JSX.Element {
                                   (currentProvider === 'gemini' && !geminiWorkspaceTrustReady) ||
                                   isSteerBusyForCurrentChat
                                 }
-                                title="Interrupt the active turn and dispatch this prompt immediately."
-                                aria-label="Steer: interrupt and dispatch this prompt"
-                                type="button"
-                              >
-                                <SteerSymbolIcon />
-                              </button>
-                            )}
-                            {isCurrentChatRunning && (
-                              <button
-                                className="composer-action-btn stop-btn"
-                                onClick={handleCancel}
-                                title="Stop run"
-                                aria-label="Stop run"
+                                title="Queue next run"
+                                aria-label="Queue next run"
                                 type="button"
-                                disabled={isSteerBusyForCurrentChat}
                               >
-                                <StopSymbolIcon />
+                                <QueueSymbolIcon />
                               </button>
-                            )}
-                          </>
-                        ) : (
-                          <button
-                            className={`composer-action-btn run-btn ${isSendConfirming ? 'send-confirming' : ''}`}
-                            onClick={(event) => {
-                              triggerSendConfirmation()
-                              // DM target resolution (same precedence as
-                              // the Enter handler above): explicit
-                              // `@participant` mention wins; falls back
-                              // to legacy Cmd/Ctrl-click on a selected
-                              // chip; plain click = full round.
-                              const dmFromMention = isCurrentEnsembleChat
-                                ? extractFirstEnsembleDmTarget(
-                                    prompt,
-                                    currentChat?.ensemble?.participants
-                                  )
-                                : null
-                              const dmTarget =
-                                dmFromMention ||
-                                (isCurrentEnsembleChat &&
-                                effectiveSelectedParticipantId &&
-                                (event.metaKey || event.ctrlKey)
-                                  ? effectiveSelectedParticipantId
-                                  : undefined)
-                              handleRun(undefined, undefined, dmTarget || undefined)
-                            }}
-                            disabled={
-                              !currentChat ||
-                              (!isCurrentGlobalChat && !currentWorkspace) ||
-                              !prompt.trim() ||
-                              (currentProvider === 'gemini' && !geminiWorkspaceTrustReady)
-                            }
-                            title={
-                              !currentChat
-                                ? 'Open or start a chat first'
-                                : !isCurrentGlobalChat && !currentWorkspace
-                                  ? 'Pick a workspace folder first'
-                                  : !prompt.trim()
-                                    ? 'Type a prompt first'
-                                    : currentProvider === 'gemini' && !geminiWorkspaceTrustReady
-                                      ? 'Trust this workspace for Gemini first'
-                                      : isCurrentEnsembleChat && effectiveSelectedParticipantId
-                                        ? 'Run full ensemble round  ·  ⌘ click = DM the selected chip'
-                                        : 'Run'
-                            }
-                            aria-label="Run prompt"
-                            aria-keyshortcuts="Enter Meta+Enter Control+Enter"
-                            type="button"
-                          >
-                            {appearance.composerStyle === 'claude' ? (
-                              <ClaudeReturnSymbolIcon />
-                            ) : appearance.composerStyle === 'codex' ||
-                              appearance.composerStyle === 'gemini' ||
-                              appearance.composerStyle === 'cursor' ||
-                              appearance.composerStyle === 'grok' ||
-                              appearance.composerStyle === 'kimi' ? (
-                              <ArrowUpSendIcon />
-                            ) : (
-                              <RunSymbolIcon />
-                            )}
-                          </button>
-                        )}
-                      </span>
+                              {/* Phase J3 (steer): sit Steer between Queue and Stop
+                               *   - Queue waits passively for the chat's run to finish.
+                               *   - Steer interrupts and dispatches immediately.
+                               *   - Stop only interrupts (no follow-up dispatch).
+                               * Only render when THIS chat is busy (per-chat busy
+                               * predicate), so multi-chat parallel runs don't get a
+                               * misleading Steer button in idle chats. */}
+                              {isCurrentChatBusyForSteer && (
+                                <button
+                                  className={`composer-action-btn steer-btn ${isSteerBusyForCurrentChat ? 'is-busy' : ''}`}
+                                  onClick={() => void handleSteer()}
+                                  disabled={
+                                    !currentChat ||
+                                    (!isCurrentGlobalChat && !currentWorkspace) ||
+                                    !prompt.trim() ||
+                                    (currentProvider === 'gemini' && !geminiWorkspaceTrustReady) ||
+                                    isSteerBusyForCurrentChat
+                                  }
+                                  title="Interrupt the active turn and dispatch this prompt immediately."
+                                  aria-label="Steer: interrupt and dispatch this prompt"
+                                  type="button"
+                                >
+                                  <SteerSymbolIcon />
+                                </button>
+                              )}
+                              {isCurrentChatRunning && (
+                                <button
+                                  className="composer-action-btn stop-btn"
+                                  onClick={handleCancel}
+                                  title="Stop run"
+                                  aria-label="Stop run"
+                                  type="button"
+                                  disabled={isSteerBusyForCurrentChat}
+                                >
+                                  <StopSymbolIcon />
+                                </button>
+                              )}
+                            </>
+                          ) : (
+                            <button
+                              className={`composer-action-btn run-btn ${isSendConfirming ? 'send-confirming' : ''}`}
+                              onClick={(event) => {
+                                triggerSendConfirmation()
+                                // DM target resolution (same precedence as
+                                // the Enter handler above): explicit
+                                // `@participant` mention wins; falls back
+                                // to legacy Cmd/Ctrl-click on a selected
+                                // chip; plain click = full round.
+                                const dmFromMention = isCurrentEnsembleChat
+                                  ? extractFirstEnsembleDmTarget(
+                                      prompt,
+                                      currentChat?.ensemble?.participants
+                                    )
+                                  : null
+                                const dmTarget =
+                                  dmFromMention ||
+                                  (isCurrentEnsembleChat &&
+                                  effectiveSelectedParticipantId &&
+                                  (event.metaKey || event.ctrlKey)
+                                    ? effectiveSelectedParticipantId
+                                    : undefined)
+                                handleRun(undefined, undefined, dmTarget || undefined)
+                              }}
+                              disabled={
+                                !currentChat ||
+                                (!isCurrentGlobalChat && !currentWorkspace) ||
+                                !prompt.trim() ||
+                                (currentProvider === 'gemini' && !geminiWorkspaceTrustReady)
+                              }
+                              title={
+                                !currentChat
+                                  ? 'Open or start a chat first'
+                                  : !isCurrentGlobalChat && !currentWorkspace
+                                    ? 'Pick a workspace folder first'
+                                    : !prompt.trim()
+                                      ? 'Type a prompt first'
+                                      : currentProvider === 'gemini' && !geminiWorkspaceTrustReady
+                                        ? 'Trust this workspace for Gemini first'
+                                        : isCurrentEnsembleChat && effectiveSelectedParticipantId
+                                          ? 'Run full ensemble round  ·  ⌘ click = DM the selected chip'
+                                          : 'Run'
+                              }
+                              aria-label="Run prompt"
+                              aria-keyshortcuts="Enter Meta+Enter Control+Enter"
+                              type="button"
+                            >
+                              {appearance.composerStyle === 'claude' ? (
+                                <ClaudeReturnSymbolIcon />
+                              ) : appearance.composerStyle === 'codex' ||
+                                appearance.composerStyle === 'gemini' ||
+                                appearance.composerStyle === 'cursor' ||
+                                appearance.composerStyle === 'grok' ||
+                                appearance.composerStyle === 'kimi' ? (
+                                <ArrowUpSendIcon />
+                              ) : (
+                                <RunSymbolIcon />
+                              )}
+                            </button>
+                          )}
+                        </span>
+                      </div>
                     </div>
+                    {currentProvider === 'gemini' && !geminiWorkspaceTrustReady && (
+                      <div
+                        className="composer-inline-warning"
+                        style={{
+                          fontSize: 'var(--font-size-xs)',
+                          color: 'var(--warning)',
+                          display: 'flex',
+                          alignItems: 'center',
+                          gap: '8px',
+                          flexWrap: 'wrap'
+                        }}
+                      >
+                        <span>
+                          Workspace trust is not established.
+                          {geminiTrustWriteError ? ` ${geminiTrustWriteError}` : ''}
+                        </span>
+                        {currentWorkspace?.path &&
+                          typeof window.api.trustWorkspace === 'function' && (
+                            <button
+                              type="button"
+                              onClick={() => void handleTrustWorkspaceClick()}
+                              disabled={geminiTrustWriteBusy || isCurrentComposerLocked}
+                              title={`Trust ${currentWorkspace.path} for Gemini — writes ~/.gemini/trustedFolders.json`}
+                              style={{
+                                display: 'inline-flex',
+                                alignItems: 'center',
+                                gap: '5px',
+                                padding: '3px 9px',
+                                fontSize: 'var(--font-size-xs)',
+                                fontWeight: 600,
+                                color: 'var(--text-primary)',
+                                background: 'color-mix(in srgb, var(--warning) 18%, transparent)',
+                                border:
+                                  '1px solid color-mix(in srgb, var(--warning) 45%, transparent)',
+                                borderRadius: '6px',
+                                cursor: geminiTrustWriteBusy ? 'default' : 'pointer',
+                                opacity: geminiTrustWriteBusy ? 0.7 : 1
+                              }}
+                            >
+                              <TrustSymbolIcon />
+                              {geminiTrustWriteBusy ? 'Trusting…' : 'Trust this folder'}
+                            </button>
+                          )}
+                        <span style={{ opacity: 0.75 }}>or enable session trust above.</span>
+                      </div>
+                    )}
                   </div>
-                  {currentProvider === 'gemini' && !geminiWorkspaceTrustReady && (
-                    <div
-                      className="composer-inline-warning"
-                      style={{
-                        fontSize: 'var(--font-size-xs)',
-                        color: 'var(--warning)',
-                        display: 'flex',
-                        alignItems: 'center',
-                        gap: '8px',
-                        flexWrap: 'wrap'
-                      }}
-                    >
-                      <span>
-                        Workspace trust is not established.
-                        {geminiTrustWriteError ? ` ${geminiTrustWriteError}` : ''}
-                      </span>
-                      {currentWorkspace?.path &&
-                        typeof window.api.trustWorkspace === 'function' && (
-                          <button
-                            type="button"
-                            onClick={() => void handleTrustWorkspaceClick()}
-                            disabled={geminiTrustWriteBusy || isCurrentComposerLocked}
-                            title={`Trust ${currentWorkspace.path} for Gemini — writes ~/.gemini/trustedFolders.json`}
-                            style={{
-                              display: 'inline-flex',
-                              alignItems: 'center',
-                              gap: '5px',
-                              padding: '3px 9px',
-                              fontSize: 'var(--font-size-xs)',
-                              fontWeight: 600,
-                              color: 'var(--text-primary)',
-                              background: 'color-mix(in srgb, var(--warning) 18%, transparent)',
-                              border:
-                                '1px solid color-mix(in srgb, var(--warning) 45%, transparent)',
-                              borderRadius: '6px',
-                              cursor: geminiTrustWriteBusy ? 'default' : 'pointer',
-                              opacity: geminiTrustWriteBusy ? 0.7 : 1
-                            }}
-                          >
-                            <TrustSymbolIcon />
-                            {geminiTrustWriteBusy ? 'Trusting…' : 'Trust this folder'}
-                          </button>
-                        )}
-                      <span style={{ opacity: 0.75 }}>or enable session trust above.</span>
-                    </div>
-                  )}
+                  {/* 1.0.6-EW68 — close .composer-bottom-controls */}
                 </div>
-                <div
-                  className="composer-telemetry-row"
-                  data-has-token-tally={threadTokenTallyLabel ? 'true' : 'false'}
+              </div>
+              {/* Console redesign — close .composer-inner-module (the readable input/controls surface) */}
+              <div
+                className="composer-telemetry-row"
+                data-has-token-tally={threadTokenTallyLabel ? 'true' : 'false'}
+              >
+                <ComposerRunTimecode
+                  running={isCurrentChatRunning}
+                  startedAt={composerRunTimecodeStartedAt}
+                />
+                <ComposerCumulativeTimecode
+                  running={isCurrentChatRunning}
+                  startedAt={composerRunTimecodeStartedAt}
+                  cumulativeBaseMs={cumulativeRunBaseMs}
+                />
+                {/* 1.0.4-AS3 — Screen Watch (Appwatch/Appshots) button.
+                    Pre-AS3 the attached-window UX was an inline pill in the
+                    action row that took ~120px and showed the app name +
+                    title + close glyph. the maintainer asked for a single themed
+                    SVG icon button here in the telemetry row instead,
+                    with the picker behind a click rather than a visible
+                    name pill. Click toggles attach/detach; the tooltip
+                    surfaces the attached app name; a small pulse dot
+                    signals an active SCStream (kept the at-a-glance
+                    "live capture" cue from the old pill). */}
+                <button
+                  type="button"
+                  className={`composer-screen-watch-button${attachedWindow ? ' is-attached' : ''}${attachedWindow?.streaming ? ' is-streaming' : ''}${!attachedWindow && resumeAppWatchSnapshot ? ' is-resumable' : ''}`}
+                  onClick={() => {
+                    // M11 — both "attach fresh" and "resume" route through the
+                    // picker (macOS requires a gesture to re-grant a window);
+                    // handleAttachWindow clears the stash on success.
+                    if (attachedWindow) void handleDetachWindow()
+                    else void handleAttachWindow()
+                  }}
+                  title={
+                    attachedWindow
+                      ? attachedWindow.streaming
+                        ? `Watching ${attachedWindow.windowMeta.applicationName || 'window'} · live capture · click to detach`
+                        : `Watching ${attachedWindow.windowMeta.applicationName || 'window'}${attachedWindow.windowMeta.title ? ` — ${attachedWindow.windowMeta.title}` : ''} · click to detach`
+                      : resumeAppWatchSnapshot
+                        ? `Resume watching ${resumeAppWatchSnapshot.windowMeta.applicationName || 'window'}${resumeAppWatchSnapshot.windowMeta.title ? ` — ${resumeAppWatchSnapshot.windowMeta.title}` : ''} · click to re-pick`
+                        : 'Screen Watch — click to pick a window for the AI to see'
+                  }
+                  aria-label={
+                    attachedWindow
+                      ? `Detach ${attachedWindow.windowMeta.applicationName || 'window'}`
+                      : resumeAppWatchSnapshot
+                        ? `Resume watching ${resumeAppWatchSnapshot.windowMeta.applicationName || 'window'}`
+                        : 'Open Screen Watch picker'
+                  }
+                  data-streaming={attachedWindow?.streaming ? 'true' : 'false'}
+                  data-resumable={!attachedWindow && resumeAppWatchSnapshot ? 'true' : 'false'}
                 >
-                  <ComposerRunTimecode
-                    running={isCurrentChatRunning}
-                    startedAt={composerRunTimecodeStartedAt}
-                  />
-                  <ComposerCumulativeTimecode
-                    running={isCurrentChatRunning}
-                    startedAt={composerRunTimecodeStartedAt}
-                    cumulativeBaseMs={cumulativeRunBaseMs}
-                  />
-                  {/* 1.0.4-AS3 — Screen Watch (Appwatch/Appshots) button.
-                  Pre-AS3 the attached-window UX was an inline pill in the
-                  action row that took ~120px and showed the app name +
-                  title + close glyph. the maintainer asked for a single themed
-                  SVG icon button here in the telemetry row instead,
-                  with the picker behind a click rather than a visible
-                  name pill. Click toggles attach/detach; the tooltip
-                  surfaces the attached app name; a small pulse dot
-                  signals an active SCStream (kept the at-a-glance
-                  "live capture" cue from the old pill). */}
-                  <button
-                    type="button"
-                    className={`composer-screen-watch-button${attachedWindow ? ' is-attached' : ''}${attachedWindow?.streaming ? ' is-streaming' : ''}${!attachedWindow && resumeAppWatchSnapshot ? ' is-resumable' : ''}`}
-                    onClick={() => {
-                      // M11 — both "attach fresh" and "resume" route through the
-                      // picker (macOS requires a gesture to re-grant a window);
-                      // handleAttachWindow clears the stash on success.
-                      if (attachedWindow) void handleDetachWindow()
-                      else void handleAttachWindow()
-                    }}
-                    title={
-                      attachedWindow
-                        ? attachedWindow.streaming
-                          ? `Watching ${attachedWindow.windowMeta.applicationName || 'window'} · live capture · click to detach`
-                          : `Watching ${attachedWindow.windowMeta.applicationName || 'window'}${attachedWindow.windowMeta.title ? ` — ${attachedWindow.windowMeta.title}` : ''} · click to detach`
-                        : resumeAppWatchSnapshot
-                          ? `Resume watching ${resumeAppWatchSnapshot.windowMeta.applicationName || 'window'}${resumeAppWatchSnapshot.windowMeta.title ? ` — ${resumeAppWatchSnapshot.windowMeta.title}` : ''} · click to re-pick`
-                          : 'Screen Watch — click to pick a window for the AI to see'
-                    }
-                    aria-label={
-                      attachedWindow
-                        ? `Detach ${attachedWindow.windowMeta.applicationName || 'window'}`
-                        : resumeAppWatchSnapshot
-                          ? `Resume watching ${resumeAppWatchSnapshot.windowMeta.applicationName || 'window'}`
-                          : 'Open Screen Watch picker'
-                    }
-                    data-streaming={attachedWindow?.streaming ? 'true' : 'false'}
-                    data-resumable={!attachedWindow && resumeAppWatchSnapshot ? 'true' : 'false'}
-                  >
-                    <ScreenWatchSymbolIcon />
-                    {attachedWindow?.streaming && (
-                      <span className="composer-screen-watch-button-dot" aria-hidden="true" />
-                    )}
-                    {!attachedWindow && resumeAppWatchSnapshot && (
-                      <span
-                        className="composer-screen-watch-button-dot composer-screen-watch-button-dot--resume"
-                        aria-hidden="true"
-                      />
-                    )}
-                  </button>
-                  {/* 1.0.5-AR12c — Workspace switcher in its new home.
-                   Sits between the timecodes / Screen Watch cluster
-                   on the left and the token tally on the right. The
-                   `composer-workspace-button` class gets a
-                   telemetry-row scoped CSS override (`margin-left:
-                   auto`) so the two auto-margins (this + the tally)
-                   split the free space. Hidden in global chats —
-                   same gating as the previous top-row mount. */}
-                  {!isCurrentGlobalChat && (
-                    <ComposerWorkspaceSwitcher
-                      workspaces={workspaces}
-                      currentWorkspace={currentWorkspace}
-                      onPickExisting={handleSelectExistingWorkspace}
-                      onAddNewWorkspace={handleSelectWorkspace}
-                      onSelectNoWorkspace={handleNewGlobalChat}
-                      /*
-                      1.0.6-EW66 — multi-workspace manager. The
-                      additional-workspace grants + their repo
-                      metadata drive the "Current workspaces" list;
-                      reorder / remove / add-folder are only wired
-                      when the chat has a saved record to attach
-                      grants to (welcome-state chats get the picker
-                      without those affordances).
-                    */
-                      additionalGrants={externalPathGrants}
-                      repoMetadata={externalPathRepoMetadata}
-                      composerStyle={appearance.composerStyle}
-                      onReorderWorkspaces={
-                        currentChat?.appChatId ? handleReorderExternalPathGrants : undefined
-                      }
-                      onRemoveWorkspacePath={
-                        currentChat?.appChatId ? handleRemoveExternalPathGrantsByPath : undefined
-                      }
-                      onAddFolder={currentChat?.appChatId ? handleAddWorkspaceFolder : undefined}
-                      onAddKnownWorkspace={
-                        currentChat?.appChatId ? handleAddKnownWorkspaceAsSecondary : undefined
-                      }
-                    />
+                  <ScreenWatchSymbolIcon />
+                  {attachedWindow?.streaming && (
+                    <span className="composer-screen-watch-button-dot" aria-hidden="true" />
                   )}
-                  {threadTokenTallyLabel && (
-                    <span className="composer-thread-token-tally" title={threadTokenTallyTooltip}>
-                      {threadTokenTallyLabel}
-                    </span>
+                  {!attachedWindow && resumeAppWatchSnapshot && (
+                    <span
+                      className="composer-screen-watch-button-dot composer-screen-watch-button-dot--resume"
+                      aria-hidden="true"
+                    />
                   )}
-                </div>
-                {/* 1.0.6-EW68 — close .composer-bottom-controls */}
+                </button>
+                {/* 1.0.5-AR12c — Workspace switcher in its new home.
+                     Sits between the timecodes / Screen Watch cluster
+                     on the left and the token tally on the right. The
+                     `composer-workspace-button` class gets a
+                     telemetry-row scoped CSS override (`margin-left:
+                     auto`) so the two auto-margins (this + the tally)
+                     split the free space. Hidden in global chats —
+                     same gating as the previous top-row mount. */}
+                {!isCurrentGlobalChat && (
+                  <ComposerWorkspaceSwitcher
+                    workspaces={workspaces}
+                    currentWorkspace={currentWorkspace}
+                    onPickExisting={handleSelectExistingWorkspace}
+                    onAddNewWorkspace={handleSelectWorkspace}
+                    onSelectNoWorkspace={handleNewGlobalChat}
+                    /*
+                        1.0.6-EW66 — multi-workspace manager. The
+                        additional-workspace grants + their repo
+                        metadata drive the "Current workspaces" list;
+                        reorder / remove / add-folder are only wired
+                        when the chat has a saved record to attach
+                        grants to (welcome-state chats get the picker
+                        without those affordances).
+                      */
+                    additionalGrants={externalPathGrants}
+                    repoMetadata={externalPathRepoMetadata}
+                    composerStyle={appearance.composerStyle}
+                    onReorderWorkspaces={
+                      currentChat?.appChatId ? handleReorderExternalPathGrants : undefined
+                    }
+                    onRemoveWorkspacePath={
+                      currentChat?.appChatId ? handleRemoveExternalPathGrantsByPath : undefined
+                    }
+                    onAddFolder={currentChat?.appChatId ? handleAddWorkspaceFolder : undefined}
+                    onAddKnownWorkspace={
+                      currentChat?.appChatId ? handleAddKnownWorkspaceAsSecondary : undefined
+                    }
+                  />
+                )}
+                {threadTokenTallyLabel && (
+                  <span className="composer-thread-token-tally" title={threadTokenTallyTooltip}>
+                    {threadTokenTallyLabel}
+                  </span>
+                )}
               </div>
               {/*
                 Composer-unification (Phase J1): removed the codex-style
@@ -19411,6 +19693,16 @@ function App(): React.JSX.Element {
         promptBubble={appearance.userBubbleColor || 'system'}
         ensembleSummary={bugReportEnsembleSummary}
       />
+      <ChangelogSheet
+        open={showChangelogSheet}
+        onDismiss={handleDismissChangelogSheet}
+        changelogSnapshot={changelogSnapshot}
+        updateSnapshot={updateStatus.snapshot}
+        busy={updateStatus.busy}
+        onCheckForUpdates={updateStatus.checkForUpdates}
+        onDownloadUpdate={updateStatus.downloadUpdate}
+        onInstallUpdateNow={updateStatus.installUpdateNow}
+      />
       {/* 1.0.4-AK2 — Work Session setup sheet. z-index 9130 sits
           above BugReportSheet (9120) since opening a Work Session
           is a deliberate intent action and shouldn't be obscured
diff --git a/src/renderer/src/assets/css/01-sidebar.css b/src/renderer/src/assets/css/01-sidebar.css
index 225b64b1..d89b7a1f 100644
--- a/src/renderer/src/assets/css/01-sidebar.css
+++ b/src/renderer/src/assets/css/01-sidebar.css
@@ -106,10 +106,17 @@
 /* Quiet empty-state when the persistent Active runs section has nothing
  * running — keeps the section anchored under Search without shouting. */
 .sidebar-active-runs-empty {
+  display: flex;
+  align-items: center;
+  gap: 6px;
   padding: 3px var(--space-sm, 8px);
   font-size: var(--font-size-xs);
   color: color-mix(in srgb, var(--sidebar-text-secondary, var(--text-secondary)) 62%, transparent);
 }
+.sidebar-active-runs-empty .mascot-ghost {
+  flex: none;
+  opacity: 0.65;
+}
 
 /*
  * 1.0.5-SB5 — Drag-and-drop pin affordances.
diff --git a/src/renderer/src/assets/css/02-transcript-messages-fx.css b/src/renderer/src/assets/css/02-transcript-messages-fx.css
index 7afc4304..efa48348 100644
--- a/src/renderer/src/assets/css/02-transcript-messages-fx.css
+++ b/src/renderer/src/assets/css/02-transcript-messages-fx.css
@@ -2824,6 +2824,34 @@
   opacity: 0.6;
 }
 
+/* 1.0.7 — participant-rename continuity note. Sits after the speaker
+ * label (and model badge, when present) as a quiet "renamed from
+ * Planner" aside so a reader can tell a renamed seat's earlier
+ * frozen-role messages belong to the participant now under a new
+ * name. Deliberately understated: it reads as muted meta-text
+ * (NOT the bold provider tint — `--text-muted` rather than the
+ * `color: inherit` the model badge uses) and italic so it never
+ * competes with the identity label it annotates. The leading `·`
+ * mirrors the model-badge separator so the row stays one coherent
+ * typographic line, and it respects the maintainer's rim-highlight
+ * direction by adding no border/background of its own. */
+.message-meta-renamed-from {
+  display: inline-flex;
+  align-items: center;
+  color: var(--text-muted);
+  opacity: 0.85;
+  font-weight: 400;
+  font-style: italic;
+  position: relative;
+}
+.message-meta-renamed-from::before {
+  content: '·';
+  display: inline-block;
+  margin-right: var(--space-sm);
+  font-style: normal;
+  opacity: 0.6;
+}
+
 /* Provider-tinted assistant message labels. Each assistant message
  * gets a `.provider-{name}` class hook on its `.message-meta`
  * element so the per-message speaker label ("Codex" / "Claude /
@@ -3185,12 +3213,14 @@
 
 /* Ensemble round-status / handback chrome (round opened/closed, @-mention
  * routing, "control returned to you"). Orchestration STATE CHANGES, not
- * participant prose — a left accent bar + faint tint marks them as system
+ * participant prose — a rim highlight + faint tint marks them as system
  * authority instead of the muted system-note styling. Box-shadow + background
  * only (no padding/border added) so the row's measured height is unchanged. */
 .message-bubble.system.system-round-status {
   background: color-mix(in srgb, var(--accent) 7%, transparent);
-  box-shadow: inset 3px 0 0 color-mix(in srgb, var(--accent) 70%, transparent);
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--accent) 42%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--accent) 9%, transparent);
   border-radius: 8px;
 }
 
@@ -3204,12 +3234,14 @@
  * strip mirrors the chip layouts in `.ensemble-above-row-chips`
  * so the visual vocabulary stays consistent across the app. */
 .participant-health-card {
+  --participant-health-rim: color-mix(in srgb, var(--panel-border) 60%, transparent);
   width: min(100%, 900px);
   margin: 6px 0;
   padding: 10px 12px;
   border-radius: 12px;
-  border: 1px solid color-mix(in srgb, var(--panel-border) 60%, transparent);
+  border: 1px solid var(--participant-health-rim);
   background: color-mix(in srgb, var(--surface-elevated) 50%, transparent);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--text-primary) 3%, transparent);
   display: flex;
   flex-direction: column;
   gap: 8px;
@@ -3217,15 +3249,21 @@
   color: var(--text-secondary);
 }
 .participant-health-card.all-ok {
-  /* Subtle green-tinted left rail when every participant is
+  /* Subtle green-tinted rim when every participant is
    * reachable. Helps the user skim a long transcript and see
    * "yep, the panel was healthy here" without parsing chips. */
-  border-left: 3px solid color-mix(in srgb, #2ea043 55%, transparent);
+  --participant-health-rim: color-mix(in srgb, #2ea043 42%, var(--panel-border));
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, #2ea043 9%, transparent),
+    0 0 0 1px color-mix(in srgb, #2ea043 8%, transparent);
 }
 .participant-health-card.has-failures {
-  /* Amber rail when any participant came back unreachable. The
+  /* Amber rim when any participant came back unreachable. The
    * chip strip below shows WHICH one(s). */
-  border-left: 3px solid color-mix(in srgb, #f0a93f 65%, transparent);
+  --participant-health-rim: color-mix(in srgb, #f0a93f 50%, var(--panel-border));
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, #f0a93f 10%, transparent),
+    0 0 0 1px color-mix(in srgb, #f0a93f 8%, transparent);
 }
 .participant-health-card-header {
   display: flex;
@@ -3318,14 +3356,13 @@
 
 .subthread-return-card {
   width: min(100%, 860px);
-  border: 1px solid rgb(var(--agent-accent-rgb) / 0.2);
-  border-left: 3px solid rgb(var(--agent-accent-rgb) / 0.62);
+  border: 1px solid rgb(var(--agent-accent-rgb) / 0.28);
   border-radius: 8px;
   background:
     linear-gradient(135deg, rgb(var(--agent-accent-rgb) / 0.12), transparent 58%),
     rgb(255 255 255 / 0.035);
   box-shadow:
-    inset 0 0 0 1px rgb(255 255 255 / 0.024),
+    inset 0 0 0 1px rgb(var(--agent-accent-rgb) / 0.08),
     0 14px 34px rgb(0 0 0 / 0.16);
   color: var(--text-primary);
   padding: 0.78rem 0.9rem 0.9rem;
@@ -3800,25 +3837,35 @@
 /* QMOD (1.0.3) — `ask_user_question` MCP tool surface. Extends the
  * existing .plan-choice-card visual; only adds the bits that diverge:
  *   - Context sub-paragraph beneath the question.
- *   - Provider-tinted left border so the user sees who's asking.
+ *   - Provider-tinted rim so the user sees who's asking.
  *   - Free-text textarea path (Cmd/Ctrl+Enter submits, Esc dismisses).
  *   - Dismiss × in the top-right that cancels the parked tool call.
  */
 .agent-question-card {
   position: relative;
-  border-left-width: 3px;
+  --agent-question-rim: rgb(var(--agent-accent-rgb) / 0.24);
+  border-color: var(--agent-question-rim);
+  box-shadow:
+    inset 0 0 0 1px rgb(var(--agent-accent-rgb) / 0.06),
+    0 0 18px rgb(var(--agent-accent-rgb) / 0.07);
 }
 .agent-question-card.provider-codex {
-  border-left-color: var(--provider-codex-color);
+  --agent-question-rim: color-mix(in srgb, var(--provider-codex-color) 58%, transparent);
 }
 .agent-question-card.provider-claude {
-  border-left-color: var(--provider-claude-color);
+  --agent-question-rim: color-mix(in srgb, var(--provider-claude-color) 58%, transparent);
 }
 .agent-question-card.provider-gemini {
-  border-left-color: var(--provider-gemini-color);
+  --agent-question-rim: color-mix(in srgb, var(--provider-gemini-color) 58%, transparent);
 }
 .agent-question-card.provider-kimi {
-  border-left-color: var(--provider-kimi-color);
+  --agent-question-rim: color-mix(in srgb, var(--provider-kimi-color) 58%, transparent);
+}
+.agent-question-card.provider-grok {
+  --agent-question-rim: color-mix(in srgb, var(--provider-grok-color) 58%, transparent);
+}
+.agent-question-card.provider-cursor {
+  --agent-question-rim: color-mix(in srgb, var(--provider-cursor-color) 58%, transparent);
 }
 .agent-question-card-question {
   font-weight: 600;
diff --git a/src/renderer/src/assets/css/03-composer-welcome-activity.css b/src/renderer/src/assets/css/03-composer-welcome-activity.css
index b2019ca1..eab7fd29 100644
--- a/src/renderer/src/assets/css/03-composer-welcome-activity.css
+++ b/src/renderer/src/assets/css/03-composer-welcome-activity.css
@@ -803,16 +803,16 @@
   min-width: 78px;
 }
 .ensemble-hierarchy-tile.provider-claude {
-  border-color: color-mix(in srgb, var(--provider-claude, #d68a4d) 48%, var(--panel-border));
+  border-color: color-mix(in srgb, var(--provider-claude-color, #d97706) 48%, var(--panel-border));
 }
 .ensemble-hierarchy-tile.provider-codex {
-  border-color: color-mix(in srgb, var(--provider-codex, #3b82f6) 48%, var(--panel-border));
+  border-color: color-mix(in srgb, var(--provider-codex-color, #6366f1) 48%, var(--panel-border));
 }
 .ensemble-hierarchy-tile.provider-gemini {
-  border-color: color-mix(in srgb, var(--provider-gemini, #4d8edb) 48%, var(--panel-border));
+  border-color: color-mix(in srgb, var(--provider-gemini-color, #2563eb) 48%, var(--panel-border));
 }
 .ensemble-hierarchy-tile.provider-kimi {
-  border-color: color-mix(in srgb, var(--provider-kimi, #6fb04a) 48%, var(--panel-border));
+  border-color: color-mix(in srgb, var(--provider-kimi-color, #84a33b) 48%, var(--panel-border));
 }
 .ensemble-hierarchy-tile.provider-grok {
   border-color: color-mix(in srgb, var(--provider-grok-color) 48%, var(--panel-border));
@@ -1124,6 +1124,19 @@
 .welcome-usage-tab.active::after {
   background: var(--accent);
 }
+/* Welcome L9 polish — the underline now previews faintly on hover (was
+ * colour-only) and the tab is keyboard-focusable with a visible accent
+ * underline, so the tab strip reads as crisp under both pointer + keyboard. */
+.welcome-usage-tab:hover:not(.active)::after {
+  background: color-mix(in srgb, var(--accent) 34%, transparent);
+}
+.welcome-usage-tab:focus-visible {
+  outline: none;
+  color: var(--text-primary);
+}
+.welcome-usage-tab:focus-visible::after {
+  background: color-mix(in srgb, var(--accent) 58%, transparent);
+}
 
 /* Range toggle (elsewhere in the app) keeps its historical pill style. */
 .welcome-usage-range {
@@ -2096,6 +2109,10 @@
   font-weight: 600;
   color: color-mix(in srgb, var(--accent) 80%, var(--text-primary) 20%);
 }
+.welcome-usage-empty--range .mascot-ghost {
+  color: color-mix(in srgb, var(--text-primary) 32%, transparent);
+  margin-bottom: 4px;
+}
 
 /* 1.0.6-CRUX43 — the model-meter FILL also reads its provider brand colour via
  * `currentColor` (see .welcome-usage-model-meter-fill), so it's added to each
@@ -2426,6 +2443,470 @@
   background: color-mix(in srgb, var(--composer-bg) 78%, var(--accent) 22%);
 }
 
+/* ============================================================
+ * NATIVE-SHELL COMPOSER CONSOLE RIM (CSS-only)
+ * --------------------------------------------------------------
+ * Gives the AGBench *native* composer (`data-composer-style=
+ * "default"`) the maintainer's "rim highlight" identity — the
+ * same idiom committed in a9d5482 for `.participant-health-card`
+ * / `.agent-question-card` / `.compact-tool-trace`: a whole-
+ * perimeter rim (NOT a left rail) drawn as an `inset 0 0 0 1px`
+ * glow, optionally tinted by state/provider, with a faint tint.
+ *
+ * WHY a `::after` (and not the host border/box-shadow):
+ *   - The host `.composer-surface` already owns `border` +
+ *     `box-shadow` across THREE prompt-surface variants (glass /
+ *     classic / solid, lines ~2409-2439) plus the focus-within +
+ *     per-provider focus glows above. Restating box-shadow on the
+ *     host at equal specificity would clobber the glass backdrop
+ *     shadow. Drawing the rim on a dedicated `::after` layers the
+ *     instrument rim ON TOP without disturbing any of that, so it
+ *     reads identically across every surface/theme.
+ *   - `::before` is already taken (the side-vignette gradient),
+ *     so the rim uses `::after`. For the native shell `::after`
+ *     is otherwise free (themed shells terminal/stub/modular/
+ *     satellite use their own `::after`, but those are scoped to
+ *     their own `data-composer-style`, never `default`).
+ *
+ * SCOPE — native shell ONLY. The codex / claude hat-tip shells
+ * set their own `.composer-surface` chrome (shard 07) and must
+ * keep their identity, so every rule here is prefixed with
+ * `[data-composer-style="default"]`.
+ *
+ * HAND-OFF to Agent-Aura FX — when the Advanced-FX "Agent Aura"
+ * is enabled the surface carries `.fx-agent-aura` and shard 05
+ * already paints a richer running/approval/failed treatment
+ * (incl. its own `.composer-surface::after`). We therefore EXIT
+ * via `:not(.fx-agent-aura)` so the two never fight: idle rim
+ * when FX-aura is off, full aura when it's on.
+ *
+ * The rim line colour adapts to light + dark automatically: it
+ * is a `color-mix` against `--text-primary` / the provider token,
+ * never a fixed rgba, so it stays subtle on both.
+ * ============================================================ */
+
+/* Calm idle rim — neutral, always-on. A single faint perimeter
+ * line that gives the console a defined edge without a glow. */
+[data-composer-style="default"] .composer-surface:not(.fx-agent-aura)::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  pointer-events: none;
+  /* Sits above the ::before vignette (z-index:0) and the surface
+   * fill, but below the actual composer controls (z-index:2). */
+  z-index: 1;
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--text-primary) 5%, transparent);
+  transition: box-shadow 160ms ease;
+}
+
+/* Provider-tinted idle rim. `.app-transcript.provider-<id>` is an
+ * EXISTING always-on hook (App.tsx:16259) and is an ancestor of
+ * the composer-surface — the same hook the per-provider focus
+ * glows above already use. The rim warms toward the provider's
+ * brand token (a faint inner line + an even fainter outer halo +
+ * a whisper of background tint), so the native console quietly
+ * signals which agent it's wired to. Kept well under the focus
+ * glow's intensity so focus still reads as the louder state. */
+[data-composer-style="default"]
+  .app-transcript.provider-gemini
+  .composer-surface:not(.fx-agent-aura)::after {
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--provider-gemini-color) 16%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--provider-gemini-color) 7%, transparent);
+  background: color-mix(in srgb, var(--provider-gemini-color) 4%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-codex
+  .composer-surface:not(.fx-agent-aura)::after {
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--provider-codex-color) 16%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--provider-codex-color) 7%, transparent);
+  background: color-mix(in srgb, var(--provider-codex-color) 4%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-claude
+  .composer-surface:not(.fx-agent-aura)::after {
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--provider-claude-color) 16%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--provider-claude-color) 7%, transparent);
+  background: color-mix(in srgb, var(--provider-claude-color) 4%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-kimi
+  .composer-surface:not(.fx-agent-aura)::after {
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--provider-kimi-color) 16%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--provider-kimi-color) 7%, transparent);
+  background: color-mix(in srgb, var(--provider-kimi-color) 4%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-grok
+  .composer-surface:not(.fx-agent-aura)::after {
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--provider-grok-color) 16%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--provider-grok-color) 7%, transparent);
+  background: color-mix(in srgb, var(--provider-grok-color) 4%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-cursor
+  .composer-surface:not(.fx-agent-aura)::after {
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--provider-cursor-color) 16%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--provider-cursor-color) 7%, transparent);
+  background: color-mix(in srgb, var(--provider-cursor-color) 4%, transparent);
+}
+
+/*
+ * TODO(App.tsx phase): RUNNING / agent-active rim is intentionally
+ * NOT added here. The only running/approval hook on the surface
+ * today is `.fx-agent-aura.fx-status-{running,approval,failed}`,
+ * which (a) is present ONLY when Advanced-FX "Agent Aura" is
+ * enabled and (b) is already fully painted by shard 05. An
+ * always-on running rim needs a dedicated, FX-independent class on
+ * `.composer-surface` (e.g. `is-running` driven by
+ * `isCurrentChatRunning` / `runFxStatus`) which lands in the
+ * App.tsx slice. When it does, mirror the rim idiom here:
+ *   --composer-rim: color-mix(in srgb, var(--accent) 42%, var(--panel-border));
+ * on `[data-composer-style="default"] .composer-surface.is-running::after`.
+ *
+ * TODO(App.tsx phase): ENSEMBLE vs SINGLE rim is also deferred.
+ * `.app-transcript.chat-kind-ensemble` IS an existing ancestor
+ * hook (App.tsx:16259), but an ensemble has no single provider
+ * brand colour, so a tasteful ensemble rim needs a deliberate
+ * neutral/multi tone chosen in the App.tsx slice rather than
+ * invented here.
+ */
+
+/* Reduce-motion: the rim itself is static (no pulse/animation),
+ * but kill the colour-cross-fade transition so provider/focus
+ * changes snap instead of easing. */
+[data-reduce-motion="true"]
+  [data-composer-style="default"]
+  .composer-surface:not(.fx-agent-aura)::after {
+  transition: none;
+}
+
+/* ============================================================
+ * NATIVE-SHELL COMPOSER "CONSOLE" REDESIGN — POLARITY FRAME
+ * --------------------------------------------------------------
+ * The maintainer's vision: turn the native composer
+ * (`data-composer-style="default"`) into an *instrument*. Two
+ * nested surfaces:
+ *
+ *   OUTER  `.composer-surface`       → a translucent glass shown as
+ *          the FRAME around the input (via the surface's perimeter
+ *          padding) AND as the bed under the relocated telemetry
+ *          row. REFINEMENT (flips slice 2): it now follows theme
+ *          POLARITY rather than contrast — a near-BLACK glass on
+ *          DARK themes, a near-WHITE glass on the five LIGHT themes.
+ *          So on dark the frame is darker/blacker than the theme-
+ *          tone module (the module pops against a black frame); on
+ *          light it is a clean white frame. Carries the slice-1
+ *          provider rim on its ::after.
+ *
+ *   INNER  `.composer-inner-module`  → the actual INPUT (textarea
+ *          + slash/mention menus + the control-footer), on a NORMAL
+ *          THEME-TONE surface so text + controls stay perfectly
+ *          readable. Rendered FULL-WIDTH with HARD corners as an
+ *          edge-to-edge instrument panel, carrying the provider rim
+ *          on its own perimeter.
+ *
+ * READABILITY — the input always sits on the theme-tone module, so
+ * text stays theme-correct (light-on-dark / dark-on-light). The
+ * relocated `.composer-telemetry-row` now sits on the outer frame;
+ * it uses theme text colours (light-on-black on dark, dark-on-white
+ * on light), which stays readable against the polarity glass.
+ *
+ * SURFACE VARIANTS — `.composer-surface` has three prompt-surface
+ * variants (glass / classic / solid, lines ~2409-2439), each
+ * setting its own `background` + `backdrop-filter` + `box-shadow`.
+ * We override ONLY `background` here (leaving every variant's
+ * backdrop-filter + box-shadow untouched, so glass stays glassy,
+ * classic stays classic, solid stays opaque). The polarity tint is
+ * a `color-mix` toward near-black (dark themes) / near-white (light
+ * themes); the SOLID variant gets a firmer mix (no blur to lean
+ * on). The base rule below covers the default/dark case; the
+ * light-theme `:is(...)` block flips the polarity to a white glass.
+ *
+ * SCOPE — native shell only. Codex / claude / grok shells own
+ * their `.composer-surface` chrome (shard 07/10) and are never
+ * `default`, so they are untouched.
+ * ============================================================ */
+
+/* OUTER frame — DARK themes (default): a near-BLACK glass tint so
+ * the frame reads darker/blacker than the theme-tone module, which
+ * pops against it. Background only; the variant's blur/shadow
+ * survive. */
+[data-composer-style="default"] .composer-surface {
+  /* Pure black frame — NO theme tint (per maintainer: black, not "dark"). */
+  background: rgba(0, 0, 0, 0.95);
+}
+[data-composer-style="default"][data-prompt-surface="liquid_glass"] .composer-surface,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="liquid_glass"] .composer-surface,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="thin_material"] .composer-surface,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="auto"] .composer-surface,
+[data-composer-style="default"][data-prompt-surface="classic"] .composer-surface,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="classic"] .composer-surface {
+  /* Glassy variants blur what's behind them; a pure-black veil (no theme
+   * tint) reads as a smoked black pane while the blur still breathes. */
+  background: rgba(0, 0, 0, 0.9);
+}
+[data-composer-style="default"][data-prompt-surface="solid"] .composer-surface,
+[data-composer-style="default"][data-reduce-transparency="true"] .composer-surface {
+  /* No blur to lean on — pure opaque black (no theme tint). */
+  background: #000000;
+}
+
+/* OUTER frame — the five LIGHT themes: PURE WHITE (no theme tint, per
+ * maintainer: white, not "light") so the frame reads as a clean white
+ * pane around the theme-tone module. Same variant split. */
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"]
+  .composer-surface {
+  background: rgba(255, 255, 255, 0.96);
+}
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="liquid_glass"]
+  .composer-surface,
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="liquid_glass"]
+  .composer-surface,
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="thin_material"]
+  .composer-surface,
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="auto"]
+  .composer-surface,
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="classic"]
+  .composer-surface,
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="classic"]
+  .composer-surface {
+  background: rgba(255, 255, 255, 0.91);
+}
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-prompt-surface="solid"]
+  .composer-surface,
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"][data-reduce-transparency="true"]
+  .composer-surface {
+  background: #ffffff;
+}
+
+/* ── Console refinement: SOLID outer frame (chat composers) ──────────
+ * The maintainer wants the native composer's OUTER frame to read as a
+ * pure black/white bezel with NO themed gradient — the theme tone lives
+ * on the INNER module instead. Kill the surface side-vignette (::before:
+ * base + per-provider tints in this shard + the ensemble tints in shard
+ * 09) for the default shell's CHAT composers. The provider RIM (::after)
+ * is untouched. !important lets one rule beat the per-provider + ensemble
+ * ::before variants without specificity gymnastics; scoped to
+ * `.app-transcript` so the separately-polished welcome surface keeps its
+ * own look. */
+[data-composer-style="default"] .app-transcript .composer-surface::before {
+  background: none !important;
+  box-shadow: none !important;
+}
+
+/* ── Console alignment: ABOVE-ROWS match the solid frame ─────────────
+ * The Ensemble row, the Create-PR / Review row, and the Steer/Queue row
+ * used the OLD composer look — `var(--composer-bg)` theme tone + a themed
+ * side-vignette (::before) — the very treatment the console redesign
+ * replaced on the surface. That left them clashing with the new solid
+ * black/white frame below. Re-skin them to match the frame: solid pure
+ * black (dark) / white (light) fill, vignette killed, with a neutral
+ * hairline rim for definition. Provider colour stays on the chips, so the
+ * whole stack (rows + composer) reads as one cohesive instrument. Native
+ * chat composers only (single + ensemble); other shells untouched. */
+[data-composer-style="default"]
+  .app-transcript
+  :is(.composer-above-bar, .ensemble-above-row, .queued-messages-above-row, .composer-create-pr-row) {
+  background: rgba(0, 0, 0, 0.95);
+  border-color: color-mix(in srgb, var(--text-primary) 17%, transparent);
+}
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"]
+  .app-transcript
+  :is(.composer-above-bar, .ensemble-above-row, .queued-messages-above-row, .composer-create-pr-row) {
+  background: rgba(255, 255, 255, 0.96);
+  border-color: color-mix(in srgb, var(--text-primary) 12%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript
+  :is(.composer-above-bar, .ensemble-above-row, .queued-messages-above-row, .composer-create-pr-row)::before {
+  background: none !important;
+  box-shadow: none !important;
+}
+
+/* INNER module — the readable input. NORMAL theme-tone surface so
+ * the textarea + controls always sit on theme tone (light-on-dark
+ * / dark-on-light), NEVER on the inverted contrast glass. Seated
+ * into the frame with a subtle inset seam (hairline + faint inner
+ * shadow) and a matching radius. Provider rim is carried in shard
+ * 07. Only active on the native shell; on the other shells the
+ * wrapper is layout-transparent (`display: contents`) so their
+ * own composer chrome is unaffected.
+ *
+ * DEFAULT (every NON-native shell) — `display: contents`: the
+ * wrapper vanishes from layout and its children (textarea + the
+ * two control rows) stay *effective* children of `.composer-
+ * surface` exactly as before this redesign. This mirrors the
+ * existing `.composer-bottom-controls` contract and is what keeps
+ * codex / claude / grok / kimi / cursor untouched. */
+.composer-inner-module {
+  display: contents;
+}
+
+[data-composer-style="default"] .composer-inner-module {
+  position: relative;
+  z-index: 2; /* above the surface ::before vignette (0) + ::after rim (1) */
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-sm);
+  background: var(--composer-bg);
+  /* Refinement — FULL WIDTH + HARD CORNERS. The maintainer wants the
+   * module as a crisp edge-to-edge instrument panel rather than a
+   * rounded inset card. Bleed across the surface's 14px horizontal
+   * frame padding with matching negative margins so the module spans
+   * the full surface width; square the corners. The surface keeps
+   * `overflow: hidden`, so the panel's edges clip cleanly to the
+   * frame's rounded outer corners. The theme-tone fill, provider rim
+   * (shard 07), and inset seam all survive. */
+  /* Full-bleed: width must be 100% PLUS the surface's 2×14px frame
+   * padding, or `width:100%` (content-box) + a negative margin only
+   * reaches the LEFT edge and falls ~28px short on the RIGHT. */
+  width: calc(100% + 28px);
+  max-width: none;
+  margin-left: -14px;
+  margin-right: -14px;
+  border-radius: 0;
+  /* Seat into the contrast frame: a hairline ring + a soft inner
+   * seam so the module reads as a panel dropped into the glass. */
+  box-shadow:
+    inset 0 0 0 1px color-mix(in srgb, var(--panel-border) 60%, transparent),
+    inset 0 1px 0 color-mix(in srgb, var(--text-primary) 6%, transparent),
+    0 1px 2px rgba(0, 0, 0, 0.18);
+  padding: 10px 10px 6px;
+  transition: box-shadow 160ms ease;
+}
+
+/* The inner module owns the theme-tone fill, so neutralise the
+ * outer surface's side-vignette in the central area — let the
+ * vignette read only in the frame (where the glass is). We do
+ * this by keeping the module opaque-enough; on the glass variants
+ * the theme `--composer-bg` is itself translucent, so nudge it
+ * toward solid so the input never shows the inverted glass behind
+ * it (HARD readability rule). */
+[data-composer-style="default"][data-prompt-surface="liquid_glass"] .composer-inner-module,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="liquid_glass"] .composer-inner-module,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="thin_material"] .composer-inner-module,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="auto"] .composer-inner-module,
+[data-composer-style="default"][data-prompt-surface="classic"] .composer-inner-module,
+[data-composer-style="default"][data-prompt-surface="theme"][data-visual-effect="classic"] .composer-inner-module {
+  background: color-mix(in srgb, var(--composer-bg) 86%, var(--composer-bg-solid) 14%);
+  backdrop-filter: blur(6px);
+  -webkit-backdrop-filter: blur(6px);
+}
+[data-composer-style="default"][data-prompt-surface="solid"] .composer-inner-module,
+[data-composer-style="default"][data-reduce-transparency="true"] .composer-inner-module {
+  background: var(--composer-bg-solid);
+}
+
+/* Welcome mode keeps the hard-cornered full-width panel; only the
+ * horizontal bleed changes because the welcome surface uses a wider
+ * 16px frame padding (vs 14px), so match the negative margins. */
+.welcome-mode[data-composer-style="default"] .composer-inner-module,
+[data-composer-style="default"] .welcome-mode .composer-inner-module {
+  border-radius: 0;
+  width: calc(100% + 32px); /* welcome's 2×16px frame padding */
+  margin-left: -16px;
+  margin-right: -16px;
+}
+
+/* ── Console refinement: themed INNER in LIGHT (chat composers) ──────
+ * The outer is now pure white in light themes, so the inner module's
+ * near-white `--composer-bg` blended into it and the theme stopped
+ * reading on the panel. Give the LIGHT inner a distinct themed surface:
+ * a subtle vertical gradient nudged off pure-white toward the text
+ * colour, so it reads as a themed panel the way the dark inner's tone
+ * reads against black. Theme-relative (no per-theme values) so it holds
+ * across light / citrus / mist / sage / alabaster; the extra
+ * `.app-transcript` class beats the glass/solid inner variants. The DARK
+ * inner is deliberately left as the flat `--composer-bg` tone (the
+ * maintainer confirmed dark reads correctly). */
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )[data-composer-style="default"]
+  .app-transcript
+  .composer-inner-module {
+  background: linear-gradient(
+    180deg,
+    color-mix(in srgb, var(--composer-bg) 93%, var(--text-primary) 7%),
+    color-mix(in srgb, var(--composer-bg) 87%, var(--text-primary) 13%)
+  );
+}
+
+/* Reduce-motion: snap the inner-module seam transition. */
+[data-reduce-motion="true"] [data-composer-style="default"] .composer-inner-module {
+  transition: none;
+}
+
 .composer-control-footer {
   margin-top: auto;
   display: flex;
@@ -4001,6 +4482,30 @@
   color: var(--text-secondary);
 }
 
+/* Order-4 — optional one-line "why" note for an approval decision.
+ * Low-friction: a quiet single-line field that sits between the
+ * request preview and the action buttons. Never required; persisted
+ * onto the approval-ledger row's metadata when filled. */
+.composer-permission-note {
+  width: 100%;
+  box-sizing: border-box;
+  font-size: var(--font-size-xs);
+  color: var(--text-primary);
+  background: var(--surface-input, rgba(0, 0, 0, 0.12));
+  border: 1px solid var(--border-subtle, rgba(255, 255, 255, 0.12));
+  border-radius: var(--radius-xs, 4px);
+  padding: var(--space-2xs, 4px) var(--space-xs, 8px);
+}
+
+.composer-permission-note::placeholder {
+  color: var(--text-muted);
+}
+
+.composer-permission-note:focus-visible {
+  outline: none;
+  border-color: var(--accent, rgba(255, 165, 0, 0.5));
+}
+
 .composer-permission-paths {
   display: flex;
   flex-direction: column;
@@ -4143,6 +4648,25 @@
   min-width: 0;
 }
 
+/* ── Console refinement: schedule/runtime row ABOVE the input ────────
+ * In single-provider native chats the schedule + runtime-profile row
+ * was absolutely positioned (top:10px) and so got painted BEHIND the
+ * console redesign's inner module (z-index:2, full-bleed) — the row
+ * shared the same z-index but lost the paint order. Lift it into normal
+ * flow ABOVE the inner module (it precedes it in the DOM) and above it
+ * on the z-axis, so it reads as a clean right-aligned row over the
+ * textarea instead of a hidden float. Native chat composers only; the
+ * ensemble composer doesn't render this row, and the other shells keep
+ * the original floating placement. */
+[data-composer-style="default"] .app-transcript .composer-top-toggles {
+  position: relative;
+  top: auto;
+  right: auto;
+  z-index: 3;
+  max-width: none;
+  margin-bottom: 6px;
+}
+
 @container (max-width: 560px) {
   .composer-top-toggles {
     position: static;
@@ -5144,15 +5668,18 @@
 }
 
 .diff-file-row:nth-child(odd) {
-  background: rgba(255, 255, 255, 0.02);
+  background: color-mix(in srgb, var(--text-primary) 2%, transparent);
 }
 
 .diff-file-row + .diff-file-row {
-  border-top: 1px solid rgba(255, 255, 255, 0.06);
+  border-top: 1px solid color-mix(in srgb, var(--text-primary) 6%, transparent);
 }
 
-.diff-file-row:hover { background: rgba(255,255,255,0.04); }
-.diff-file-row.selected { background: rgba(255,255,255,0.06); border-left-color: var(--accent); }
+.diff-file-row:hover { background: color-mix(in srgb, var(--text-primary) 5%, transparent); }
+.diff-file-row.selected {
+  background: color-mix(in srgb, var(--text-primary) 8%, transparent);
+  border-left-color: var(--accent);
+}
 
 button.diff-file-row {
   appearance: none;
@@ -5176,7 +5703,7 @@ button.diff-file-row {
 .diff-file-name { flex: 1; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 
 .diff-file-type-icon {
-  border: 1px solid rgba(255,255,255,0.12);
+  border: 1px solid color-mix(in srgb, var(--text-primary) 12%, transparent);
   flex-shrink: 0;
 }
 
@@ -5208,7 +5735,7 @@ button.diff-file-row {
 .diff-file-badge.modified { background: rgba(90,140,255,0.12); color: var(--accent); }
 .diff-file-badge.deleted { background: rgba(229,77,77,0.12); color: var(--danger); }
 .diff-file-badge.untracked { background: rgba(245,166,35,0.12); color: var(--warning); }
-.diff-file-badge.noise { background: rgba(255,255,255,0.06); color: var(--text-muted); }
+.diff-file-badge.noise { background: color-mix(in srgb, var(--text-primary) 6%, transparent); color: var(--text-muted); }
 
 .diff-detail {
   flex: 1;
@@ -5225,7 +5752,7 @@ button.diff-file-row {
 }
 
 .diff-lines-section {
-  border-top: 1px solid rgba(255, 255, 255, 0.06);
+  border-top: 1px solid color-mix(in srgb, var(--text-primary) 6%, transparent);
   background: color-mix(in srgb, var(--app-bg-sunken) 70%, transparent);
 }
 
@@ -5237,8 +5764,8 @@ button.diff-file-row {
   padding: 3px var(--space-md);
   font-size: var(--font-size-xs);
   color: var(--text-muted);
-  background: rgba(255, 255, 255, 0.04);
-  border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+  background: color-mix(in srgb, var(--text-primary) 4%, transparent);
+  border-bottom: 1px solid color-mix(in srgb, var(--text-primary) 6%, transparent);
 }
 
 .diff-detail-header {
@@ -5269,8 +5796,8 @@ button.diff-file-row {
   color: var(--text-tertiary);
   text-align: right;
   user-select: none;
-  border-right: 1px solid rgba(255, 255, 255, 0.05);
-  background: rgba(0, 0, 0, 0.10);
+  border-right: 1px solid color-mix(in srgb, var(--text-primary) 5%, transparent);
+  background: color-mix(in srgb, var(--text-primary) 6%, transparent);
 }
 
 .diff-line-code {
@@ -5279,7 +5806,7 @@ button.diff-file-row {
 
 .diff-line.meta {
   color: var(--text-muted);
-  background: rgba(255, 255, 255, 0.025);
+  background: color-mix(in srgb, var(--text-primary) 2.5%, transparent);
 }
 
 .diff-line.add .diff-line-code,
@@ -5295,7 +5822,7 @@ button.diff-file-row {
 }
 
 .diff-line + .diff-line {
-  border-top: 1px solid rgba(255, 255, 255, 0.05);
+  border-top: 1px solid color-mix(in srgb, var(--text-primary) 5%, transparent);
 }
 
 .diff-line.add { background: var(--diff-add-bg); color: var(--diff-add-text); }
diff --git a/src/renderer/src/assets/css/04-settings-controls.css b/src/renderer/src/assets/css/04-settings-controls.css
index 535524ab..1633ddd6 100644
--- a/src/renderer/src/assets/css/04-settings-controls.css
+++ b/src/renderer/src/assets/css/04-settings-controls.css
@@ -349,6 +349,97 @@
   border-color: color-mix(in srgb, var(--surface-border, var(--panel-border)) 78%, transparent);
 }
 
+/* ── DEFAULT preview — mirror the console redesign ───────────────────
+ * The AGBench-native ("default") composer was reskinned to the console
+ * look in shards 03 + 07: a SOLID black/white OUTER frame (vignette
+ * killed) with a theme-tone INNER module sitting inside it. Those real
+ * rules are scoped to `.app-transcript`, so they never reach these
+ * static preview cards (no `.app-transcript` ancestor) — the previews
+ * kept rendering the OLD theme-tinted look. Re-create the console look
+ * HERE, scoped strictly to the `default` style so the codex / claude /
+ * gemini / kimi / grok / cursor / obsidian / alabaster previews are
+ * untouched. The card carries both `data-composer-style` and
+ * `data-theme`, so the light-theme split keys off the same card. */
+
+/* OUTER frame — solid pure black (dark), pure white (the 5 light
+ * themes); no themed gradient (the tone lives on the inner module). */
+.settings-composer-preview-card[data-composer-style="default"] .composer-surface {
+  background: rgba(0, 0, 0, 0.95);
+}
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )
+  .settings-composer-preview-card[data-composer-style="default"]
+  .composer-surface {
+  background: rgba(255, 255, 255, 0.96);
+}
+/* Kill the surface side-vignette so the frame reads as a clean bezel. */
+.settings-composer-preview-card[data-composer-style="default"] .composer-surface::before {
+  background: none !important;
+  box-shadow: none !important;
+}
+
+/* ABOVE-BAR — match the solid frame + kill its own side-vignette. */
+.settings-composer-preview-card[data-composer-style="default"] .composer-above-bar {
+  background: rgba(0, 0, 0, 0.95);
+  border-color: color-mix(in srgb, var(--text-primary) 17%, transparent);
+}
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )
+  .settings-composer-preview-card[data-composer-style="default"]
+  .composer-above-bar {
+  background: rgba(255, 255, 255, 0.96);
+  border-color: color-mix(in srgb, var(--text-primary) 12%, transparent);
+}
+.settings-composer-preview-card[data-composer-style="default"] .composer-above-bar::before {
+  background: none !important;
+  box-shadow: none !important;
+}
+
+/* INNER module — the theme-tone inset panel inside the solid frame.
+ * The real `[data-composer-style="default"] .composer-inner-module`
+ * rule (shard 03) reaches the preview and would make it FULL-BLEED
+ * (width calc(100% + 28px) + negative margins) to bleed across the
+ * surface's frame padding; in the cramped preview that overflows, so
+ * pin it to the surface (width:100%; max-width:none; margin:0) with a
+ * rounded inset look. The flex column + gap are restated so the layout
+ * holds regardless of cascade order. */
+.settings-composer-preview-card[data-composer-style="default"] .composer-inner-module {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-sm);
+  width: 100%;
+  max-width: none;
+  margin: 0;
+  padding: 8px;
+  border-radius: var(--radius-sm);
+  background: var(--composer-bg);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--text-primary) 10%, transparent);
+}
+/* The 5 LIGHT themes — the outer is now pure white, so a near-white
+ * `--composer-bg` inner would vanish into the frame. Nudge the inner
+ * tone toward the text colour so it reads as a distinct themed panel. */
+:is(
+    [data-theme="light"],
+    [data-theme="citrus"],
+    [data-theme="mist"],
+    [data-theme="sage"],
+    [data-theme="alabaster"]
+  )
+  .settings-composer-preview-card[data-composer-style="default"]
+  .composer-inner-module {
+  background: color-mix(in srgb, var(--composer-bg) 90%, var(--text-primary) 10%);
+}
+
 /* Model usage tab — cross-provider quota dashboard.
  *
  * Headline-tile strip up top (Total tokens / Runs / Providers), then
@@ -755,14 +846,20 @@
 .settings-workspaces-empty {
   display: flex;
   flex-direction: column;
+  align-items: center;
+  text-align: center;
   gap: 6px;
-  padding: 16px 18px;
+  padding: 18px;
   border: 1px dashed color-mix(in srgb, var(--text-primary) 14%, transparent);
   border-radius: 10px;
   background: color-mix(in srgb, var(--text-primary) 3%, transparent);
   color: var(--text-secondary);
   font-size: var(--font-size-sm, 13px);
 }
+.settings-workspaces-empty .mascot-ghost {
+  color: color-mix(in srgb, var(--text-primary) 34%, transparent);
+  margin-bottom: 2px;
+}
 
 .settings-workspaces-empty strong {
   color: var(--text-primary);
diff --git a/src/renderer/src/assets/css/05-polish-fx-layouts.css b/src/renderer/src/assets/css/05-polish-fx-layouts.css
index 79e81f46..fe5c102c 100644
--- a/src/renderer/src/assets/css/05-polish-fx-layouts.css
+++ b/src/renderer/src/assets/css/05-polish-fx-layouts.css
@@ -1982,6 +1982,16 @@
   font-size: var(--font-size-xs);
 }
 
+/* Friendlier empty states — a centred brand ghost above the copy. */
+.app-sidebar .sidebar-empty-state--ghost {
+  justify-items: center;
+  text-align: center;
+  gap: 6px;
+}
+.app-sidebar .sidebar-empty-state--ghost .mascot-ghost {
+  color: color-mix(in srgb, var(--text-primary) 34%, transparent);
+}
+
 .app-sidebar .run-summary {
   margin: 0 var(--space-md) var(--space-sm);
   border-radius: 14px;
diff --git a/src/renderer/src/assets/css/06-component-panels-modals.css b/src/renderer/src/assets/css/06-component-panels-modals.css
index 8911f253..d43ca323 100644
--- a/src/renderer/src/assets/css/06-component-panels-modals.css
+++ b/src/renderer/src/assets/css/06-component-panels-modals.css
@@ -55,8 +55,9 @@
   margin: 3px 0 5px;
   padding: 6px 10px;
   color: color-mix(in srgb, var(--text-primary) 88%, transparent);
-  border-left: 1px solid color-mix(in srgb, var(--accent-primary) 35%, transparent);
-  background: linear-gradient(90deg, color-mix(in srgb, var(--accent-primary) 8%, transparent), transparent 70%);
+  border: 1px solid color-mix(in srgb, var(--accent-primary) 24%, transparent);
+  background: color-mix(in srgb, var(--accent-primary) 5%, transparent);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--accent-primary) 5%, transparent);
   border-radius: 10px;
 }
 
@@ -212,29 +213,31 @@
  * `{ input, result, timeline }` view — kept distinct from the line so
  * the transcript stays scannable even with multiple traces expanded.
  *
- * Status comes through the line's left-edge accent (data-status) and
+ * Status comes through the line's rim highlight (data-status) and
  * the status pill colour. Provider attribution comes through the
  * provider-tinted name chip (.compact-tool-trace-provider).
  */
 .compact-tool-trace {
+  --compact-tool-rim: color-mix(in srgb, var(--border-subtle) 60%, transparent);
   width: min(760px, 100%);
   margin: 2px 0;
-  border-left: 2px solid color-mix(in srgb, var(--border-subtle) 60%, transparent);
-  border-radius: 0 4px 4px 0;
+  border: 1px solid var(--compact-tool-rim);
+  border-radius: 7px;
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--text-primary) 3%, transparent);
 }
 
 .compact-tool-trace[data-status="success"] {
-  border-left-color: color-mix(in srgb, var(--tool-success) 60%, transparent);
+  --compact-tool-rim: color-mix(in srgb, var(--tool-success) 42%, transparent);
 }
 .compact-tool-trace[data-status="error"] {
-  border-left-color: color-mix(in srgb, var(--tool-error) 70%, transparent);
+  --compact-tool-rim: color-mix(in srgb, var(--tool-error) 48%, transparent);
 }
 .compact-tool-trace[data-status="warning"] {
-  border-left-color: color-mix(in srgb, var(--tool-warning) 65%, transparent);
+  --compact-tool-rim: color-mix(in srgb, var(--tool-warning) 46%, transparent);
 }
 .compact-tool-trace[data-status="running"],
 .compact-tool-trace[data-status="pending"] {
-  border-left-color: color-mix(in srgb, var(--accent) 60%, transparent);
+  --compact-tool-rim: color-mix(in srgb, var(--accent) 42%, transparent);
 }
 
 .compact-tool-trace-line {
@@ -760,4 +763,3 @@
 [data-appearance="native_glass"][data-reduce-transparency="false"] .app-transcript {
   background: color-mix(in srgb, var(--content-bg) 60%, transparent);
 }
-
diff --git a/src/renderer/src/assets/css/07-composer-shells.css b/src/renderer/src/assets/css/07-composer-shells.css
index 914cf421..adbcca5b 100644
--- a/src/renderer/src/assets/css/07-composer-shells.css
+++ b/src/renderer/src/assets/css/07-composer-shells.css
@@ -66,6 +66,20 @@
 [data-composer-style="codex"] .composer-inline-pickers {
   margin-top: 0;
 }
+/* AGBench native (default) shell — adopt the standard control order the
+ * other shells use: the permission / tool-grants picker sits right after
+ * the + attach button instead of trailing at the very end. The default
+ * shell was the only one without an order block, so it fell back to DOM
+ * order (permission last). Mirrors the codex order below; the base
+ * .composer-inline-pickers-left (shard 03) is already flex, so only
+ * `order` is needed. Model right-aligns so it sits beside the send cluster. */
+[data-composer-style="default"] [data-composer-control="attach"] { order: 0; }
+[data-composer-style="default"] [data-composer-control="permission"] { order: 1; }
+[data-composer-style="default"] [data-composer-control="ensemble-mode"] { order: 2; }
+[data-composer-style="default"] [data-composer-control="provider"] { order: 3; }
+[data-composer-style="default"] [data-composer-control="workspace"] { order: 4; }
+[data-composer-style="default"] [data-composer-control="model"] { order: 5; margin-left: auto; }
+
 [data-composer-style="codex"] .composer-inline-pickers-left {
   display: flex;
   align-items: center;
@@ -1259,6 +1273,227 @@
 :is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-diff-action-menu button:disabled {
   color: rgba(29, 29, 31, 0.38);
 }
+
+/* ============================================================
+ * Git controls (Phase Git-U1) — the real user-driven commit flow
+ * (gitSnapshot → review → stage/commit → gated PR) rendered inside the
+ * above-bar's diff-action menu. Inherits the menu's surface/typography;
+ * these rules add the status block, the commit message input, and the
+ * gated PR affordance, matching the existing `.composer-above-bar-*`
+ * look. The menu items reuse the menu-button visuals already defined on
+ * `.composer-diff-action-menu button`.
+ * ============================================================ */
+.composer-git-controls {
+  display: grid;
+  gap: 6px;
+  min-width: 232px;
+}
+.composer-git-status {
+  display: grid;
+  gap: 2px;
+  padding: 2px 9px 6px;
+  border-bottom: 1px solid color-mix(in srgb, var(--text-primary) 9%, transparent);
+  margin-bottom: 1px;
+}
+.composer-git-status-line {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 6px;
+  font-size: var(--font-size-xs);
+  line-height: 1.35;
+}
+.composer-git-status-line.is-muted {
+  color: color-mix(in srgb, var(--text-secondary) 64%, transparent);
+}
+.composer-git-status-line.is-error {
+  color: #f08080;
+}
+.composer-git-branch {
+  font-weight: 600;
+  font-feature-settings: 'tnum';
+  color: color-mix(in srgb, #ffffff 92%, transparent);
+}
+.composer-git-status-clean {
+  color: #6ddfa8;
+}
+.composer-git-status-counts {
+  color: color-mix(in srgb, var(--text-secondary) 78%, transparent);
+  font-feature-settings: 'tnum';
+}
+
+/* The Review-changes / Create-PR rows reuse the menu-button shape so they
+ * sit flush with the rest of the menu. */
+.composer-git-menu-item {
+  appearance: none;
+  -webkit-appearance: none;
+  width: 100%;
+  border: 0;
+  border-radius: 8px;
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+  font: inherit;
+  font-size: var(--font-size-xs);
+  text-align: left;
+  padding: 7px 9px;
+  transition: background 0.16s, color 0.16s;
+}
+.composer-git-menu-item:hover:not(:disabled),
+.composer-git-menu-item:focus-visible:not(:disabled) {
+  background: color-mix(in srgb, var(--text-primary) 9%, transparent);
+  outline: none;
+}
+.composer-git-menu-item:disabled {
+  color: color-mix(in srgb, var(--text-secondary) 52%, transparent);
+  cursor: not-allowed;
+}
+.composer-git-menu-item.is-pending {
+  opacity: 0.7;
+  cursor: progress;
+}
+.composer-git-menu-item.is-success {
+  color: #6ddfa8;
+}
+.composer-git-menu-item.is-error {
+  color: #f08080;
+}
+
+/* Commit row — message input + a primary-styled commit button. The input
+ * borrows the above-bar action's pill chrome so it reads as part of the
+ * same control family. */
+.composer-git-commit {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+  padding: 1px 4px 0;
+}
+.composer-git-commit-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  appearance: none;
+  -webkit-appearance: none;
+  border: 1px solid color-mix(in srgb, var(--text-primary) 13%, transparent);
+  background: color-mix(in srgb, var(--composer-bg-solid) 38%, transparent);
+  color: color-mix(in srgb, #ffffff 88%, transparent);
+  font: inherit;
+  font-size: var(--font-size-xs);
+  padding: 5px 9px;
+  border-radius: 8px;
+  transition: border-color 0.16s, background 0.16s;
+}
+.composer-git-commit-input::placeholder {
+  color: color-mix(in srgb, var(--text-secondary) 56%, transparent);
+}
+.composer-git-commit-input:focus-visible {
+  outline: none;
+  border-color: color-mix(in srgb, var(--accent) 52%, var(--text-primary) 18%);
+  background: color-mix(in srgb, var(--composer-bg-solid) 52%, transparent);
+}
+.composer-git-commit-input:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+.composer-git-commit-button {
+  flex: 0 0 auto;
+  margin-left: 0;
+  white-space: nowrap;
+}
+.composer-git-feedback {
+  padding: 0 9px 1px;
+  font-size: var(--font-size-xs);
+  line-height: 1.3;
+}
+.composer-git-feedback.is-error {
+  color: #f08080;
+}
+.composer-git-feedback.is-success {
+  color: #6ddfa8;
+}
+.composer-git-feedback.is-muted {
+  color: color-mix(in srgb, var(--text-secondary) 64%, transparent);
+}
+/* When PR is gated off, surface the reason on its own muted line under
+ * the (disabled) label rather than only in the tooltip. */
+.composer-git-pr {
+  display: grid;
+  gap: 1px;
+}
+.composer-git-pr-reason {
+  font-size: calc(var(--font-size-xs) - 1px);
+  color: color-mix(in srgb, var(--text-secondary) 58%, transparent);
+  font-weight: 400;
+}
+
+/* Light themes — mirror the diff-action-menu / above-bar light overrides. */
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-branch {
+  color: rgba(29, 29, 31, 0.92);
+}
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-status {
+  border-bottom-color: var(--surface-border);
+}
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-menu-item:hover:not(:disabled),
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-menu-item:focus-visible:not(:disabled) {
+  background: color-mix(in srgb, var(--text-primary) 7%, transparent);
+}
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-menu-item:disabled {
+  color: rgba(29, 29, 31, 0.38);
+}
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-commit-input {
+  color: rgba(29, 29, 31, 0.88);
+  border-color: var(--surface-border);
+  background: color-mix(in srgb, var(--surface-1) 72%, transparent);
+}
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-commit-input::placeholder {
+  color: rgba(29, 29, 31, 0.45);
+}
+
+/* Header git-state pill (above-bar) — sits next to the files-changed pill.
+ * Compact staged/unstaged + push/PR-ready signal sourced from gitSnapshot. */
+.composer-git-state-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  font-size: var(--font-size-xs);
+  white-space: nowrap;
+}
+.composer-git-state-clean {
+  color: #6ddfa8;
+}
+.composer-git-state-staged {
+  color: color-mix(in srgb, #ffffff 82%, transparent);
+  font-feature-settings: 'tnum';
+}
+.composer-git-state-unstaged {
+  color: color-mix(in srgb, var(--text-secondary) 78%, transparent);
+}
+.composer-git-state-flag {
+  display: inline-flex;
+  align-items: center;
+  padding: 1px 7px;
+  border-radius: 999px;
+  font-size: calc(var(--font-size-xs) - 1px);
+  border: 1px solid transparent;
+}
+.composer-git-state-flag.is-push {
+  color: #f0c674;
+  border-color: color-mix(in srgb, #f0c674 36%, transparent);
+}
+.composer-git-state-flag.is-pr {
+  color: #6ddfa8;
+  border-color: color-mix(in srgb, #6ddfa8 36%, transparent);
+}
+:is([data-theme="light"], [data-theme="mist"], [data-theme="sage"]) .composer-git-state-staged {
+  color: rgba(29, 29, 31, 0.82);
+}
+
+/* Respect reduce-motion — drop the control transitions entirely. */
+[data-reduce-motion="true"] .composer-git-menu-item,
+[data-reduce-motion="true"] .composer-git-commit-input,
+[data-reduce-motion="true"] .composer-git-commit-button {
+  transition: none;
+}
+
 /* (Previously the default style hid the above-bar entirely; we now show it
  * with the `.style-default` shape so workspace branch + diff + Create-PR
  * are visible regardless of composer style.) */
@@ -2938,3 +3173,161 @@
   background: color-mix(in srgb, #ffffff 5%, transparent);
 }
 
+/* ============================================================
+ * NATIVE-SHELL POSTURE PILL — "Full Workspace Access" (auto_edit)
+ * RED → AMBER, via the maintainer's rim-highlight idiom (a9d5482)
+ * --------------------------------------------------------------
+ * The permission chip is a POSTURE indicator, not an error: it
+ * tells the user the agent currently has workspace-write power.
+ * The shell-agnostic default (shard 08, lines ~7138-7145 dark /
+ * ~8030-8035 light) paints `auto_edit` alarm-RED (#ef4444 dark /
+ * #b91c1c light). For the AGBench *native* shell we recolour it to
+ * a calmer AMBER posture pill — amber rim + faint amber tint +
+ * readable amber text — matching the `has-failures` / attention
+ * rim the maintainer uses elsewhere (`#f0a93f` amber). The codex
+ * shell keeps its authentic orange and the other shells keep the
+ * shared red; this override is native-only.
+ *
+ * CASCADE — shard 07 loads BEFORE shard 08, so at equal
+ * specificity shard 08's rules (some `!important`) would still
+ * win on source order. We out-specific them with a REPEATED-
+ * attribute prefix — the same trick the maintainer uses for
+ * obsidian/alabaster, here tripled so we clear shard 08's
+ * deepest competitor (the LIGHT-theme `.is-selected` checkmark
+ * at 0,5,0) too:
+ * `[data-composer-style="default"]×3`:
+ *   - trigger          → 0,5,0  (beats 0,2,0 dark / 0,3,0 light !important)
+ *   - -primary span    → 0,6,0  (beats 0,3,0 dark / 0,4,0 light !important)
+ *   - popover row label → 0,5,0  (beats 0,3,0 dark / 0,4,0 light)
+ *   - selected check    → 0,6,0  (beats 0,4,0 dark / 0,5,0 light)
+ * so it wins regardless of source order, in EVERY theme. (The
+ * popover-row rules in shard 08 are not `!important`, so winning
+ * the cascade by specificity alone is enough there.)
+ *
+ * LIGHT + DARK readability — the text colour is
+ * `color-mix(#f0a93f, var(--text-primary))`, NOT a fixed amber.
+ * `--text-primary` is ~white on dark themes (→ amber brightens,
+ * vivid on the dark chip) and ~near-black on light themes (→ amber
+ * darkens to a deep ochre, readable on the light chip). One rule
+ * adapts to all themes (incl. citrus/alabaster/paper that the
+ * 3-theme `:is()` light list omits). The amber rim + tint reinforce
+ * the signal so the chip reads as "posture" even where text
+ * contrast is gentlest. NOT a red fill, NOT alarm-red.
+ * ============================================================ */
+
+/* Closed-state chip — rim + faint amber tint + amber border. */
+[data-composer-style="default"][data-composer-style="default"][data-composer-style="default"]
+  .composer-combined-picker-trigger[data-permission-value="auto_edit"] {
+  color: color-mix(in srgb, #f0a93f 72%, var(--text-primary)) !important;
+  border-color: color-mix(in srgb, #f0a93f 50%, var(--composer-border)) !important;
+  background: color-mix(in srgb, #f0a93f 8%, transparent);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, #f0a93f 10%, transparent);
+}
+
+/* The label span carries its own `color` (+ `!important` in shard
+ * 08), so tint it directly — one class deeper than the trigger
+ * selector above to clear shard 08's `-primary !important` rule. */
+[data-composer-style="default"][data-composer-style="default"][data-composer-style="default"]
+  .composer-combined-picker-trigger[data-permission-value="auto_edit"]
+  .composer-combined-picker-trigger-primary {
+  color: color-mix(in srgb, #f0a93f 72%, var(--text-primary)) !important;
+}
+
+/* Hover — slightly firmer amber rim, still calm. */
+[data-composer-style="default"][data-composer-style="default"][data-composer-style="default"]
+  .composer-combined-picker-trigger[data-permission-value="auto_edit"]:hover:not(:disabled) {
+  border-color: color-mix(in srgb, #f0a93f 62%, var(--composer-border)) !important;
+  background: color-mix(in srgb, #f0a93f 12%, transparent);
+}
+
+/* Open-state popover — row label + selected check pick up the same
+ * amber so the dropdown legend matches the chip the user just saw.
+ * The popover is portaled to <body> but `[data-composer-style]`
+ * lives on <html>, so the descendant selector still scopes it to
+ * the native shell. */
+[data-composer-style="default"][data-composer-style="default"][data-composer-style="default"]
+  .composer-combined-picker-row[data-permission-value="auto_edit"]
+  .composer-combined-picker-row-label {
+  color: color-mix(in srgb, #f0a93f 72%, var(--text-primary));
+}
+[data-composer-style="default"][data-composer-style="default"][data-composer-style="default"]
+  .composer-combined-picker-row[data-permission-value="auto_edit"].is-selected
+  .composer-combined-picker-check {
+  color: color-mix(in srgb, #f0a93f 72%, var(--text-primary));
+}
+
+/* ============================================================
+ * CONSOLE REDESIGN — PROVIDER RIM ON THE INNER MODULE
+ * --------------------------------------------------------------
+ * Slice 1 (shard 03) carries the provider rim on the OUTER frame
+ * (`.composer-surface::after`). The console redesign adds a second
+ * nested surface, `.composer-inner-module` (the readable input),
+ * and the maintainer wants the provider highlight on the rims of
+ * BOTH. The module's own `box-shadow` is spent on the inset seam
+ * (shard 03), so — exactly like slice 1 did for the surface — the
+ * provider rim is drawn on a dedicated `::after` overlay so it
+ * layers on top of the seam without disturbing it.
+ *
+ * Same hooks + discipline as slice 1: per-provider via the always-
+ * on `.app-transcript.provider-<id>` ancestor, native shell only,
+ * steps aside for the FX agent-aura (`:not(.fx-agent-aura)` on the
+ * surface), reduce-motion snaps the cross-fade. Kept a touch
+ * softer than the outer rim so the frame stays the louder edge and
+ * the two rims read as one continuous highlight rather than two
+ * competing lines.
+ * ============================================================ */
+[data-composer-style="default"]
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  pointer-events: none;
+  z-index: 1; /* above the module fill, below its controls (z 2) */
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--text-primary) 4%, transparent);
+  transition: box-shadow 160ms ease;
+}
+[data-composer-style="default"]
+  .app-transcript.provider-gemini
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--provider-gemini-color) 13%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-codex
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--provider-codex-color) 13%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-claude
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--provider-claude-color) 13%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-kimi
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--provider-kimi-color) 13%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-grok
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--provider-grok-color) 13%, transparent);
+}
+[data-composer-style="default"]
+  .app-transcript.provider-cursor
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--provider-cursor-color) 13%, transparent);
+}
+[data-reduce-motion="true"]
+  [data-composer-style="default"]
+  .composer-surface:not(.fx-agent-aura)
+  .composer-inner-module::after {
+  transition: none;
+}
+
diff --git a/src/renderer/src/assets/css/08-theme-picker-overrides.css b/src/renderer/src/assets/css/08-theme-picker-overrides.css
index c1d1255b..9c4adac0 100644
--- a/src/renderer/src/assets/css/08-theme-picker-overrides.css
+++ b/src/renderer/src/assets/css/08-theme-picker-overrides.css
@@ -2427,6 +2427,21 @@
 .bug-report-sheet-required {
   color: #f0b050;
 }
+.bug-report-sheet-label-row {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+}
+.bug-report-sheet-char-counter {
+  font-size: 0.72em;
+  font-variant-numeric: tabular-nums;
+  color: var(--text-tertiary);
+  transition: color 140ms ease;
+}
+.bug-report-sheet-char-counter-warn {
+  color: #f0b050;
+}
 .bug-report-sheet-input,
 .bug-report-sheet-textarea {
   width: 100%;
@@ -2471,7 +2486,8 @@
   border: 1px solid rgba(255, 255, 255, 0.1);
   background: rgba(255, 255, 255, 0.03);
   cursor: pointer;
-  transition: border-color 140ms ease, background 140ms ease;
+  transition: border-color 140ms ease, background 140ms ease, transform 140ms ease,
+    box-shadow 140ms ease;
 }
 .bug-report-sheet-severity-chip:hover {
   border-color: rgba(255, 255, 255, 0.2);
@@ -2511,6 +2527,15 @@
   border-color: color-mix(in srgb, #f85149 55%, transparent);
   background: color-mix(in srgb, #f85149 10%, rgba(255, 255, 255, 0.02));
 }
+/* Selected severity reads crisper: a subtle lift + soft shadow + bolder
+ * label, layered on top of the per-severity tint above. */
+.bug-report-sheet-severity-chip-checked {
+  transform: translateY(-1px);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.16);
+}
+.bug-report-sheet-severity-chip-checked .bug-report-sheet-severity-chip-label {
+  font-weight: 700;
+}
 .bug-report-sheet-context {
   display: flex;
   flex-direction: column;
@@ -2580,14 +2605,62 @@
   border-radius: 4px;
 }
 .bug-report-sheet-confirmation {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
   font-size: 0.86em;
   font-weight: 600;
   color: #7fdc9a;
+  animation: bug-report-confirm-in 240ms ease;
+}
+.bug-report-sheet-confirmation-check {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  background: color-mix(in srgb, #3fb950 24%, transparent);
+  color: #8ef0a8;
+  font-size: 0.72em;
+  line-height: 1;
+  animation: bug-report-check-pop 320ms cubic-bezier(0.2, 0.8, 0.2, 1.4);
+}
+@keyframes bug-report-confirm-in {
+  from {
+    opacity: 0;
+    transform: translateY(2px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+@keyframes bug-report-check-pop {
+  0% {
+    transform: scale(0);
+  }
+  60% {
+    transform: scale(1.15);
+  }
+  100% {
+    transform: scale(1);
+  }
 }
 .bug-report-sheet-footer-actions {
   display: flex;
   gap: 8px;
 }
+/* Honour the in-app reduce-motion setting — no pop/slide for the saved
+ * confirmation, its check, or the selected-chip lift. */
+[data-reduce-motion='true'] .bug-report-sheet-confirmation,
+[data-reduce-motion='true'] .bug-report-sheet-confirmation-check,
+[data-reduce-motion='true'] .bug-report-sheet-severity-chip,
+[data-reduce-motion='true'] .bug-report-sheet-severity-chip-checked {
+  animation: none;
+  transition: none;
+  transform: none;
+}
 
 /* Light-mode tweaks. Mirrors the same pattern as FirstLaunchSheet —
  * keep the surface-1 opaque white and tone down the rgba-baked edges
@@ -2725,6 +2798,168 @@
   font-size: 0.85em;
 }
 
+/* ── Changelog + Update Pill ───────────────────────────────────────── */
+.chat-corner-controls .chat-corner-update-pill {
+  width: auto;
+  min-width: 44px;
+  padding: 3px 9px;
+  color: rgba(245, 250, 255, 0.98);
+  background:
+    linear-gradient(135deg, color-mix(in srgb, var(--accent, #5a8cff) 58%, transparent), rgba(255, 255, 255, 0.12)),
+    rgba(255, 255, 255, 0.1);
+  border: 1px solid color-mix(in srgb, var(--accent, #5a8cff) 48%, transparent);
+}
+.chat-corner-update-pill-label {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  white-space: nowrap;
+  font-size: 0.72rem;
+  font-weight: 700;
+  line-height: 1;
+}
+.chat-corner-controls .chat-corner-update-pill-downloading {
+  min-width: 36px;
+}
+.chat-corner-controls .chat-corner-update-pill-error {
+  background:
+    linear-gradient(135deg, rgba(220, 80, 80, 0.4), rgba(255, 255, 255, 0.1)),
+    rgba(255, 255, 255, 0.08);
+  border-color: rgba(255, 150, 150, 0.35);
+}
+.changelog-sheet-backdrop {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(8px);
+  -webkit-backdrop-filter: blur(8px);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 9140;
+  padding: 32px 24px;
+}
+.changelog-sheet {
+  width: min(680px, 100%);
+  max-height: 90vh;
+  overflow: hidden;
+  background: var(--surface-1);
+  border: 1px solid var(--surface-border, rgba(255, 255, 255, 0.08));
+  border-radius: 16px;
+  box-shadow: 0 32px 80px rgba(0, 0, 0, 0.42);
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  padding: 24px 26px 20px;
+}
+.changelog-sheet-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 12px;
+}
+.changelog-sheet-header-text {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  min-width: 0;
+}
+.changelog-sheet-glyph {
+  flex-shrink: 0;
+  width: 40px;
+  height: 40px;
+  border-radius: 50%;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 1.1em;
+  font-weight: 800;
+  font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
+  background: color-mix(in srgb, var(--accent, #5a8cff) 16%, transparent);
+  color: color-mix(in srgb, var(--accent, #5a8cff) 78%, white);
+  border: 1px solid color-mix(in srgb, var(--accent, #5a8cff) 36%, transparent);
+}
+.changelog-sheet-header h2 {
+  margin: 0 0 4px;
+  font-size: 1.18em;
+  font-weight: 650;
+}
+.changelog-sheet-subtitle {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 0.86em;
+}
+.changelog-sheet-close {
+  width: 30px;
+  height: 30px;
+  border-radius: 8px;
+  border: 0;
+  background: transparent;
+  color: var(--text-secondary);
+  cursor: pointer;
+  font-size: 1.25em;
+  line-height: 1;
+}
+.changelog-sheet-close:hover {
+  background: rgba(255, 255, 255, 0.08);
+  color: var(--text-primary);
+}
+.changelog-sheet-progress {
+  position: relative;
+  height: 18px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: rgba(255, 255, 255, 0.06);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+}
+.changelog-sheet-progress-fill {
+  position: absolute;
+  inset: 0 auto 0 0;
+  background: color-mix(in srgb, var(--accent, #5a8cff) 68%, transparent);
+  transition: width 180ms ease;
+}
+.changelog-sheet-progress span {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  font-size: 0.76em;
+  font-weight: 700;
+}
+.changelog-sheet-error {
+  padding: 8px 10px;
+  border-radius: 8px;
+  background: rgba(220, 80, 80, 0.12);
+  color: rgba(255, 200, 200, 0.94);
+  font-size: 0.86em;
+}
+.changelog-sheet-notes {
+  min-height: 180px;
+  max-height: min(52vh, 520px);
+  overflow: auto;
+  border-radius: 10px;
+  border: 1px solid rgba(255, 255, 255, 0.07);
+  background: rgba(255, 255, 255, 0.03);
+  padding: 14px;
+}
+.changelog-sheet-notes pre {
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: var(--text-primary);
+  font: inherit;
+  line-height: 1.48;
+}
+.changelog-sheet-actions {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
 /* User-message collapse — long pasted briefs are truncated by default with a
  * "Show more" affordance under the bubble. Styling reuses the existing user
  * bubble; we only need the inner content wrapper, the gradient fade, and the
diff --git a/src/renderer/src/assets/css/09-ensemble-work-session.css b/src/renderer/src/assets/css/09-ensemble-work-session.css
index 457adf68..bded722f 100644
--- a/src/renderer/src/assets/css/09-ensemble-work-session.css
+++ b/src/renderer/src/assets/css/09-ensemble-work-session.css
@@ -2056,3 +2056,83 @@
   box-shadow: none;
 }
 
+/* ============================================================
+ * ENSEMBLE ESCALATION ADVISORY CHIPS — 1.0.7 (M5 surfacing)
+ * --------------------------------------------------------------
+ * The orchestrator's complexity-escalation heuristic computes a
+ * signal at each round's close (stuck / looping /
+ * disagreement-unresolved / tool-error-cluster) and persists it on
+ * `chat.ensemble.escalationSignals`. These were dark-shipped —
+ * computed + broadcast but rendered nowhere. This surfaces them as
+ * a low-key advisory row tucked inside the run-complete card,
+ * right under "Run details".
+ *
+ * Advisory ONLY: nothing here acts on a signal. The copy makes a
+ * tradeoff VISIBLE so the user decides; it never frames a
+ * multi-seat panel as waste. Tones are deliberately gentle —
+ * `attention` for failure-shaped signals, `info` for advisories —
+ * so the chip informs without alarming.
+ * ============================================================ */
+
+.ensemble-escalation-advisory {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-xs);
+  margin-top: var(--space-sm);
+}
+
+.ensemble-escalation-chip {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 4px 8px;
+  padding: 8px 12px;
+  border-radius: var(--radius-md);
+  border: 1px solid color-mix(in srgb, var(--accent) 22%, transparent);
+  background: color-mix(in srgb, var(--accent) 8%, transparent);
+  transition:
+    border-color 160ms ease,
+    background-color 160ms ease;
+}
+
+.ensemble-escalation-chip.tone-attention {
+  border-color: color-mix(in srgb, var(--warning, #d98324) 34%, transparent);
+  background: color-mix(in srgb, var(--warning, #d98324) 10%, transparent);
+}
+
+.ensemble-escalation-chip-label {
+  position: relative;
+  padding-left: 14px;
+  color: var(--text-primary);
+  font-size: var(--font-size-xs);
+  font-weight: 650;
+}
+
+/* Leading dot keeps the label scannable without an icon dependency. */
+.ensemble-escalation-chip-label::before {
+  content: "";
+  position: absolute;
+  left: 0;
+  top: 0.45em;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: color-mix(in srgb, var(--accent) 70%, var(--text-primary));
+}
+
+.ensemble-escalation-chip.tone-attention .ensemble-escalation-chip-label::before {
+  background: color-mix(in srgb, var(--warning, #d98324) 78%, var(--text-primary));
+}
+
+.ensemble-escalation-chip-action {
+  color: var(--text-secondary);
+  font-size: var(--font-size-xs);
+  font-weight: 500;
+}
+
+/* Respect the reduce-motion preference — drop the hover/state
+ * transition so the chip never animates when the user opted out. */
+[data-reduce-motion="true"] .ensemble-escalation-chip {
+  transition: none;
+}
+
diff --git a/src/renderer/src/components/ActiveRunsSection.tsx b/src/renderer/src/components/ActiveRunsSection.tsx
index 024c1b3c..c6b6e492 100644
--- a/src/renderer/src/components/ActiveRunsSection.tsx
+++ b/src/renderer/src/components/ActiveRunsSection.tsx
@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useMemo, useState, type JSX } from 'react'
+import { MascotGhost } from './AppChromeSymbols'
 import type {
   ChatRecord,
   ProviderId,
@@ -117,7 +118,10 @@ export function ActiveRunsSection({
       {!collapsed && (
         <div className="sidebar-active-runs-list">
           {visibleJobs.length === 0 && (
-            <div className="sidebar-active-runs-empty">No active runs</div>
+            <div className="sidebar-active-runs-empty">
+              <MascotGhost size={13} />
+              <span>No active runs</span>
+            </div>
           )}
           {visibleJobs.map((job) => {
             const chat = job.chatId ? chatById.get(job.chatId) || null : null
diff --git a/src/renderer/src/components/AppChromeSymbols.tsx b/src/renderer/src/components/AppChromeSymbols.tsx
index 433542ca..6e947a0f 100644
--- a/src/renderer/src/components/AppChromeSymbols.tsx
+++ b/src/renderer/src/components/AppChromeSymbols.tsx
@@ -131,6 +131,34 @@ export function GhostCompanionIcon() {
   )
 }
 
+/**
+ * Standalone brand-ghost glyph for empty states — same silhouette as
+ * GhostCompanionIcon but without the corner-symbol wrapper, so it can be
+ * sized via the `size` prop and tinted by the parent's `color`
+ * (currentColor stroke). Used by the friendlier sidebar / settings
+ * empty states.
+ */
+export function MascotGhost({ size = 32 }: { size?: number }) {
+  return (
+    <svg
+      className="mascot-ghost"
+      width={size}
+      height={size}
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden
+    >
+      <path d="M3.2 13.2V6.5a4.8 4.8 0 0 1 9.6 0v6.7l-1.7-1.1-1.6 1.1-1.5-1.1-1.5 1.1-1.6-1.1-1.7 1.1z" />
+      <path d="M5.8 6.4h.1M10.1 6.4h.1" />
+      <path d="M6.5 9.2c.8.5 2.2.5 3 0" />
+    </svg>
+  )
+}
+
 export function SkyWeatherIcon() {
   return (
     <span className="chat-corner-symbol">
diff --git a/src/renderer/src/components/ApprovalLedgerPanel.tsx b/src/renderer/src/components/ApprovalLedgerPanel.tsx
index 8861dd90..6455dda1 100644
--- a/src/renderer/src/components/ApprovalLedgerPanel.tsx
+++ b/src/renderer/src/components/ApprovalLedgerPanel.tsx
@@ -516,6 +516,11 @@ function ApprovalLedgerRow({
   )
   const outcomeLabel = formatOutcome(record)
   const outcomeKind = outcomeKindFor(record)
+  // Order-4 — optional one-line "why" note the user attached at
+  // decision time. Stored on the ledger row's metadata as `intentNote`
+  // (no schema migration). Surfaced read-only as a dedicated detail
+  // line; only shown when present.
+  const intentNote = intentNoteFor(record)
 
   return (
     <li className={`approval-ledger-row approval-ledger-row-${outcomeKind}`}>
@@ -556,6 +561,7 @@ function ApprovalLedgerRow({
             <DetailLine label="Decision source" value={record.decisionSource} />
           )}
           {record.grantedScope && <DetailLine label="Granted scope" value={record.grantedScope} />}
+          {intentNote && <DetailLine label="Note" value={intentNote} />}
           <DetailLine label="Requested" value={requestedAt} />
           {respondedAt && <DetailLine label="Responded" value={respondedAt} />}
           {record.expiration && (
@@ -615,6 +621,16 @@ function formatTimestamp(iso: string): string {
   }
 }
 
+/** Order-4 — the optional one-line "why" note the user attached when
+ * making this decision. Lives on the ledger metadata channel as
+ * `intentNote` (no schema migration). Returns undefined when absent or
+ * not a non-empty string. */
+function intentNoteFor(record: ApprovalLedgerRecord): string | undefined {
+  const note = record.metadata?.intentNote
+  if (typeof note === 'string' && note.trim().length > 0) return note.trim()
+  return undefined
+}
+
 /** True when the record was auto-denied by the Phase E1 timer (vs
  * auto-denied by policy). Detected by the metadata flag the timeout
  * path attaches in `index.ts`. */
diff --git a/src/renderer/src/components/BugReportSheet.test.tsx b/src/renderer/src/components/BugReportSheet.test.tsx
index c4aa751e..00e3bb9f 100644
--- a/src/renderer/src/components/BugReportSheet.test.tsx
+++ b/src/renderer/src/components/BugReportSheet.test.tsx
@@ -61,6 +61,9 @@ describe('BugReportSheet', () => {
     // is empty — that's the strongest signal that the field is
     // required (the form refuses to submit until it's populated).
     expect(html).toMatch(/<button[^>]*type="submit"[^>]*disabled/)
+    // Live character counter for the 140-char title cap (starts at 0/140).
+    expect(html).toContain('bug-report-sheet-char-counter')
+    expect(html).toContain('0/140')
   })
 
   it('renders all four severity options with "minor" pre-selected', () => {
@@ -153,7 +156,10 @@ describe('BugReportSheet', () => {
     // Values render verbatim — these are the auto-captured strings.
     expect(html).toContain('1.0.1')
     expect(html).toContain('codex')
-    expect(html).toContain('/Users/dev/projects/agbench')
+    // Workspace path is home-abbreviated (~/) so a reporter's OS username
+    // never appears in the preview or the pre-filled (public) GitHub issue.
+    expect(html).toContain('~/projects/agbench')
+    expect(html).not.toContain('/Users/dev/projects/agbench')
     expect(html).toContain('default')
     expect(html).toContain('4 participants')
   })
diff --git a/src/renderer/src/components/BugReportSheet.tsx b/src/renderer/src/components/BugReportSheet.tsx
index c8e3b8c4..1c6ae128 100644
--- a/src/renderer/src/components/BugReportSheet.tsx
+++ b/src/renderer/src/components/BugReportSheet.tsx
@@ -1,5 +1,6 @@
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { buildGitHubIssueUrl } from '../lib/githubIssueUrl'
+import { tildifyHomePath } from '../lib/ActivityPathDisplay'
 
 /**
  * BugReportSheet — inline bug-report capture for AGBench testers.
@@ -240,8 +241,12 @@ export function BugReportSheet({
     return () => window.cancelAnimationFrame(frame)
   }, [open, initialSurface])
 
+  // Home-abbreviate the workspace path (`/Users/<name>/…` → `~/…`) so a
+  // reporter's OS username never lands in the read-only preview, the local
+  // bug-reports.md, or the pre-filled PUBLIC GitHub issue. The project folder
+  // stays visible for triage; only the home/user prefix is stripped.
   const workspaceLabel = useMemo(
-    () => currentWorkspacePath || '(global chat)',
+    () => (currentWorkspacePath ? tildifyHomePath(currentWorkspacePath) : '(global chat)'),
     [currentWorkspacePath]
   )
 
@@ -408,9 +413,19 @@ export function BugReportSheet({
 
         <form className="bug-report-sheet-form" onSubmit={handleSubmit}>
           <div className="bug-report-sheet-field">
-            <label className="bug-report-sheet-label" htmlFor="bug-report-title">
-              Title <span className="bug-report-sheet-required">*</span>
-            </label>
+            <div className="bug-report-sheet-label-row">
+              <label className="bug-report-sheet-label" htmlFor="bug-report-title">
+                Title <span className="bug-report-sheet-required">*</span>
+              </label>
+              <span
+                className={`bug-report-sheet-char-counter${
+                  title.length > 120 ? ' bug-report-sheet-char-counter-warn' : ''
+                }`}
+                aria-hidden
+              >
+                {title.length}/140
+              </span>
+            </div>
             <input
               ref={titleInputRef}
               id="bug-report-title"
@@ -596,6 +611,9 @@ export function BugReportSheet({
           <footer className="bug-report-sheet-footer">
             {confirmation ? (
               <span className="bug-report-sheet-confirmation" role="status">
+                <span className="bug-report-sheet-confirmation-check" aria-hidden>
+                  ✓
+                </span>
                 {confirmation}
               </span>
             ) : (
diff --git a/src/renderer/src/components/ChangelogSheet.test.tsx b/src/renderer/src/components/ChangelogSheet.test.tsx
new file mode 100644
index 00000000..0c997321
--- /dev/null
+++ b/src/renderer/src/components/ChangelogSheet.test.tsx
@@ -0,0 +1,165 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { ChangelogSheet, formatReleaseNotes, resolveChangelogEntry } from './ChangelogSheet'
+import { UpdatePill } from './UpdatePill'
+import type { ProductChangelogSnapshot } from '../../../main/store/types'
+import type { UpdateStateSnapshot } from '../../../main/UpdateService'
+
+const changelogSnapshot: ProductChangelogSnapshot = {
+  currentVersion: '1.0.72',
+  lastSeenChangelogVersion: '1.0.71'
+}
+
+describe('UpdatePill', () => {
+  it('stays hidden for quiet update states', () => {
+    const html = renderToStaticMarkup(
+      <UpdatePill
+        snapshot={{ status: 'idle', enabled: true, channel: 'stable' }}
+        onOpen={() => {}}
+      />
+    )
+    expect(html).toBe('')
+  })
+
+  it('renders an accent pill for available updates', () => {
+    const html = renderToStaticMarkup(
+      <UpdatePill
+        snapshot={{
+          status: 'available',
+          enabled: true,
+          channel: 'stable',
+          latestVersion: '1.0.73'
+        }}
+        onOpen={() => {}}
+      />
+    )
+    expect(html).toContain('chat-corner-update-pill-available')
+    expect(html).toContain('Update 1.0.73')
+  })
+
+  it('renders download progress for downloading updates', () => {
+    const html = renderToStaticMarkup(
+      <UpdatePill
+        snapshot={{
+          status: 'downloading',
+          enabled: true,
+          channel: 'stable',
+          latestVersion: '1.0.73',
+          downloadProgress: {
+            bytesPerSecond: 10,
+            delta: 1,
+            percent: 42.4,
+            transferred: 42,
+            total: 100
+          }
+        }}
+        onOpen={() => {}}
+      />
+    )
+    expect(html).toContain('chat-corner-update-pill-downloading')
+    expect(html).toContain('42%')
+  })
+})
+
+describe('ChangelogSheet', () => {
+  it('returns null when closed', () => {
+    const html = renderToStaticMarkup(
+      <ChangelogSheet
+        open={false}
+        onDismiss={() => {}}
+        changelogSnapshot={changelogSnapshot}
+        updateSnapshot={null}
+      />
+    )
+    expect(html).toBe('')
+  })
+
+  it('shows release notes and download action for available updates', () => {
+    const updateSnapshot: UpdateStateSnapshot = {
+      status: 'available',
+      enabled: true,
+      channel: 'stable',
+      latestVersion: '1.0.73',
+      releaseName: 'AGBench 1.0.73',
+      releaseDate: '2026-06-04T12:00:00.000Z',
+      releaseNotes: 'Updater pill and changelog sheet.'
+    }
+    const html = renderToStaticMarkup(
+      <ChangelogSheet
+        open
+        onDismiss={() => {}}
+        changelogSnapshot={changelogSnapshot}
+        updateSnapshot={updateSnapshot}
+        onDownloadUpdate={() => {}}
+      />
+    )
+    expect(html).toContain('changelog-sheet-backdrop')
+    expect(html).toContain('AGBench 1.0.73')
+    expect(html).toContain('Updater pill and changelog sheet.')
+    expect(html).toContain('Download update')
+  })
+
+  it('shows restart action for downloaded updates', () => {
+    const html = renderToStaticMarkup(
+      <ChangelogSheet
+        open
+        onDismiss={() => {}}
+        changelogSnapshot={changelogSnapshot}
+        updateSnapshot={{
+          status: 'downloaded',
+          enabled: true,
+          channel: 'stable',
+          latestVersion: '1.0.73',
+          releaseNotes: 'Ready.'
+        }}
+        onInstallUpdateNow={() => {}}
+      />
+    )
+    expect(html).toContain('Restart to install')
+  })
+
+  it('falls back to the bundled changelog when release notes are missing', () => {
+    const html = renderToStaticMarkup(
+      <ChangelogSheet
+        open
+        onDismiss={() => {}}
+        changelogSnapshot={changelogSnapshot}
+        updateSnapshot={null}
+      />
+    )
+    expect(html).toContain('Bundled changelog')
+    expect(html).toContain('AGBench')
+  })
+
+  it('formats full changelog arrays from electron-updater metadata', () => {
+    expect(
+      formatReleaseNotes([
+        { version: '1.0.73', note: 'New update UI.' },
+        { version: '1.0.72', note: null }
+      ])
+    ).toBe('## 1.0.73\nNew update UI.')
+  })
+
+  it('prefers live update metadata over pending changelog snapshots', () => {
+    const entry = resolveChangelogEntry(
+      {
+        currentVersion: '1.0.72',
+        pendingUpdateChangelog: {
+          version: '1.0.72',
+          releaseNotes: 'Current app.'
+        }
+      },
+      {
+        status: 'available',
+        enabled: true,
+        channel: 'stable',
+        latestVersion: '1.0.73',
+        releaseNotes: 'Available app.'
+      }
+    )
+    expect(entry).toMatchObject({
+      version: '1.0.73',
+      releaseNotes: 'Available app.'
+    })
+  })
+})
diff --git a/src/renderer/src/components/ChangelogSheet.tsx b/src/renderer/src/components/ChangelogSheet.tsx
new file mode 100644
index 00000000..3e494d6f
--- /dev/null
+++ b/src/renderer/src/components/ChangelogSheet.tsx
@@ -0,0 +1,220 @@
+import React, { useCallback, useEffect, useMemo, useRef } from 'react'
+import bundledChangelog from '../../../../CHANGELOG.md?raw'
+import type {
+  ProductChangelogSnapshot,
+  ProductUpdateChangelog,
+  ProductUpdateReleaseNotes
+} from '../../../main/store/types'
+import type { UpdateStateSnapshot } from '../../../main/UpdateService'
+
+interface ChangelogSheetProps {
+  open: boolean
+  onDismiss: () => void
+  changelogSnapshot: ProductChangelogSnapshot | null
+  updateSnapshot: UpdateStateSnapshot | null
+  busy?: boolean
+  onCheckForUpdates?: () => Promise<unknown> | unknown
+  onDownloadUpdate?: () => Promise<unknown> | unknown
+  onInstallUpdateNow?: () => Promise<unknown> | unknown
+}
+
+const SHEET_TITLE_ID = 'changelog-sheet-title'
+
+export function ChangelogSheet({
+  open,
+  onDismiss,
+  changelogSnapshot,
+  updateSnapshot,
+  busy = false,
+  onCheckForUpdates,
+  onDownloadUpdate,
+  onInstallUpdateNow
+}: ChangelogSheetProps): React.JSX.Element | null {
+  const dismissRef = useRef(onDismiss)
+  useEffect(() => {
+    dismissRef.current = onDismiss
+  }, [onDismiss])
+
+  useEffect(() => {
+    if (!open) return
+    const onKeyDown = (event: KeyboardEvent): void => {
+      if (event.key === 'Escape') {
+        event.stopPropagation()
+        dismissRef.current()
+      }
+    }
+    window.addEventListener('keydown', onKeyDown, true)
+    return () => window.removeEventListener('keydown', onKeyDown, true)
+  }, [open])
+
+  const entry = useMemo(
+    () => resolveChangelogEntry(changelogSnapshot, updateSnapshot),
+    [changelogSnapshot, updateSnapshot]
+  )
+  const releaseNotes = formatReleaseNotes(entry.releaseNotes)
+  const displayNotes = releaseNotes || bundledChangelog.trim() || 'No changelog is available yet.'
+  const notesSource = releaseNotes ? 'Release notes' : 'Bundled changelog'
+  const releasePageUrl = updateSnapshot?.releasePageUrl
+  const updateStatus = updateSnapshot?.status || 'idle'
+  const canAct = !busy && updateStatus !== 'checking' && updateStatus !== 'downloading'
+
+  const handleInstall = useCallback(() => {
+    if (!onInstallUpdateNow) return
+    if (!confirm('Install update and restart AGBench now?')) return
+    void onInstallUpdateNow()
+  }, [onInstallUpdateNow])
+
+  const handleOpenRelease = useCallback(() => {
+    if (!releasePageUrl || typeof window.api.openExternalOrPath !== 'function') return
+    void window.api.openExternalOrPath(releasePageUrl)
+  }, [releasePageUrl])
+
+  if (!open) return null
+
+  return (
+    <div
+      className="changelog-sheet-backdrop"
+      role="presentation"
+      onMouseDown={(event) => {
+        if (event.target === event.currentTarget) onDismiss()
+      }}
+    >
+      <section
+        className="changelog-sheet"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={SHEET_TITLE_ID}
+      >
+        <header className="changelog-sheet-header">
+          <div className="changelog-sheet-header-text">
+            <span className="changelog-sheet-glyph" aria-hidden="true">
+              i
+            </span>
+            <div>
+              <h2 id={SHEET_TITLE_ID}>{entry.releaseName || `AGBench ${entry.version}`}</h2>
+              <p className="changelog-sheet-subtitle">
+                v{entry.version}
+                {entry.releaseDate ? ` - ${formatDate(entry.releaseDate)}` : ''} - {notesSource}
+              </p>
+            </div>
+          </div>
+          <button
+            type="button"
+            className="changelog-sheet-close"
+            onClick={onDismiss}
+            aria-label="Close changelog sheet"
+          >
+            x
+          </button>
+        </header>
+
+        {updateStatus === 'downloading' && updateSnapshot?.downloadProgress && (
+          <div className="changelog-sheet-progress" role="status">
+            <div
+              className="changelog-sheet-progress-fill"
+              style={{
+                width: `${Math.max(0, Math.min(100, updateSnapshot.downloadProgress.percent))}%`
+              }}
+            />
+            <span>{updateSnapshot.downloadProgress.percent.toFixed(1)}%</span>
+          </div>
+        )}
+
+        {updateStatus === 'error' && updateSnapshot?.errorMessage && (
+          <div className="changelog-sheet-error" role="status">
+            {updateSnapshot.errorMessage}
+          </div>
+        )}
+
+        <div className="changelog-sheet-notes">
+          <pre>{displayNotes}</pre>
+        </div>
+
+        <footer className="changelog-sheet-actions">
+          {releasePageUrl && (
+            <button type="button" className="btn btn-sm btn-ghost" onClick={handleOpenRelease}>
+              Open release
+            </button>
+          )}
+          {updateStatus === 'available' && onDownloadUpdate && (
+            <button
+              type="button"
+              className="btn btn-sm btn-primary"
+              disabled={!canAct}
+              onClick={() => void onDownloadUpdate()}
+            >
+              Download update
+            </button>
+          )}
+          {updateStatus === 'downloaded' && onInstallUpdateNow && (
+            <button
+              type="button"
+              className="btn btn-sm btn-primary"
+              disabled={busy}
+              onClick={handleInstall}
+            >
+              Restart to install
+            </button>
+          )}
+          {(updateStatus === 'error' ||
+            updateStatus === 'idle' ||
+            updateStatus === 'not-available' ||
+            updateStatus === 'disabled') &&
+            onCheckForUpdates && (
+              <button
+                type="button"
+                className="btn btn-sm"
+                disabled={busy || updateStatus === 'disabled'}
+                onClick={() => void onCheckForUpdates()}
+              >
+                {updateStatus === 'error' ? 'Check again' : 'Check for updates'}
+              </button>
+            )}
+          <button type="button" className="btn btn-sm btn-ghost" onClick={onDismiss}>
+            Close
+          </button>
+        </footer>
+      </section>
+    </div>
+  )
+}
+
+export function resolveChangelogEntry(
+  changelogSnapshot: ProductChangelogSnapshot | null,
+  updateSnapshot: UpdateStateSnapshot | null
+): ProductUpdateChangelog {
+  if (updateSnapshot?.latestVersion) {
+    return {
+      version: updateSnapshot.latestVersion,
+      ...(updateSnapshot.releaseName ? { releaseName: updateSnapshot.releaseName } : {}),
+      ...(updateSnapshot.releaseDate ? { releaseDate: updateSnapshot.releaseDate } : {}),
+      ...(updateSnapshot.releaseNotes ? { releaseNotes: updateSnapshot.releaseNotes } : {})
+    }
+  }
+  if (changelogSnapshot?.pendingUpdateChangelog) return changelogSnapshot.pendingUpdateChangelog
+  return {
+    version: changelogSnapshot?.currentVersion || 'unknown'
+  }
+}
+
+export function formatReleaseNotes(notes: ProductUpdateReleaseNotes | undefined): string {
+  if (typeof notes === 'string') return notes.trim()
+  if (!Array.isArray(notes)) return ''
+  return notes
+    .map((note) => {
+      const body = note.note?.trim()
+      return body ? `## ${note.version}\n${body}` : ''
+    })
+    .filter(Boolean)
+    .join('\n\n')
+}
+
+function formatDate(value: string): string {
+  const time = Date.parse(value)
+  if (!Number.isFinite(time)) return value
+  return new Date(time).toLocaleDateString(undefined, {
+    year: 'numeric',
+    month: 'short',
+    day: '2-digit'
+  })
+}
diff --git a/src/renderer/src/components/FileEditorPanel.tsx b/src/renderer/src/components/FileEditorPanel.tsx
index 747f7801..39f352bf 100644
--- a/src/renderer/src/components/FileEditorPanel.tsx
+++ b/src/renderer/src/components/FileEditorPanel.tsx
@@ -58,22 +58,22 @@ const codeEditorTheme = EditorView.theme(
       whiteSpace: 'pre'
     },
     '.cm-gutters': {
-      background: 'rgba(0,0,0,0.18)',
+      background: 'var(--cm-gutter-bg)',
       color: 'var(--text-muted)',
-      borderRight: '1px solid rgba(255,255,255,0.06)'
+      borderRight: '1px solid var(--cm-gutter-border)'
     },
     '.cm-activeLine': {
-      background: 'rgba(255,255,255,0.045)'
+      background: 'var(--cm-active-line)'
     },
     '.cm-activeLineGutter': {
-      background: 'rgba(255,255,255,0.045)',
+      background: 'var(--cm-active-line)',
       color: 'var(--text-secondary)'
     },
     '.cm-selectionBackground, &.cm-focused .cm-selectionBackground': {
       background: 'color-mix(in srgb, var(--accent) 34%, transparent)'
     },
     '.cm-matchingBracket, .cm-nonmatchingBracket': {
-      background: 'rgba(255,255,255,0.12)',
+      background: 'var(--cm-bracket-match)',
       outline: '1px solid var(--accent)'
     },
     '.cm-line ::selection, .cm-content ::selection': {
@@ -84,23 +84,26 @@ const codeEditorTheme = EditorView.theme(
 )
 
 const codeHighlightStyle = HighlightStyle.define([
-  { tag: tags.keyword, color: '#ff8fb3', fontWeight: '600' },
-  { tag: [tags.name, tags.deleted, tags.character, tags.macroName], color: '#f6f0ff' },
-  { tag: [tags.propertyName, tags.variableName, tags.labelName], color: '#b9d7ff' },
-  { tag: [tags.function(tags.variableName), tags.function(tags.propertyName)], color: '#8fd6ff' },
-  { tag: [tags.className, tags.definition(tags.typeName), tags.typeName], color: '#ffd27d' },
-  { tag: [tags.number, tags.bool, tags.null, tags.atom], color: '#c7a6ff' },
-  { tag: [tags.string, tags.special(tags.string)], color: '#9be69f' },
-  { tag: [tags.regexp, tags.escape], color: '#86e1d1' },
+  { tag: tags.keyword, color: 'var(--cm-keyword)', fontWeight: '600' },
+  { tag: [tags.name, tags.deleted, tags.character, tags.macroName], color: 'var(--cm-name)' },
+  { tag: [tags.propertyName, tags.variableName, tags.labelName], color: 'var(--cm-property)' },
+  {
+    tag: [tags.function(tags.variableName), tags.function(tags.propertyName)],
+    color: 'var(--cm-function)'
+  },
+  { tag: [tags.className, tags.definition(tags.typeName), tags.typeName], color: 'var(--cm-type)' },
+  { tag: [tags.number, tags.bool, tags.null, tags.atom], color: 'var(--cm-number)' },
+  { tag: [tags.string, tags.special(tags.string)], color: 'var(--cm-string)' },
+  { tag: [tags.regexp, tags.escape], color: 'var(--cm-regexp)' },
   {
     tag: [tags.comment, tags.lineComment, tags.blockComment],
-    color: 'rgba(255,255,255,0.42)',
+    color: 'var(--cm-comment)',
     fontStyle: 'italic'
   },
-  { tag: tags.meta, color: '#9aa7ff' },
-  { tag: tags.heading, color: '#f4f7ff', fontWeight: '700' },
+  { tag: tags.meta, color: 'var(--cm-meta)' },
+  { tag: tags.heading, color: 'var(--cm-heading)', fontWeight: '700' },
   { tag: tags.link, color: 'var(--accent)', textDecoration: 'underline' },
-  { tag: tags.invalid, color: '#ff8080' }
+  { tag: tags.invalid, color: 'var(--cm-invalid)' }
 ])
 
 const shellLanguage = StreamLanguage.define(shell)
diff --git a/src/renderer/src/components/FirstLaunchSheet.tsx b/src/renderer/src/components/FirstLaunchSheet.tsx
index 41ca83dc..03f936da 100644
--- a/src/renderer/src/components/FirstLaunchSheet.tsx
+++ b/src/renderer/src/components/FirstLaunchSheet.tsx
@@ -817,79 +817,89 @@ export function FirstLaunchSheet({
                       applies to the preview too. For the other shells these
                       wrappers are layout-neutral (textarea-wrap is a plain
                       relative box; bottom-controls is display:contents).
+
+                      Console redesign — both the textarea-wrap AND the
+                      bottom-controls are wrapped together in
+                      .composer-inner-module (theme-tone inset panel inside
+                      the solid frame), mirroring the real default composer.
+                      The base `.composer-inner-module { display: contents }`
+                      rule keeps this layout-neutral for the non-default
+                      shell previews; the chips stay OUTSIDE/above it.
                     */}
-                    <div className="composer-textarea-wrap">
-                      <div
-                        className="composer-textarea settings-composer-preview-textarea"
-                        aria-hidden="true"
-                        style={{ minHeight: '60px' }}
-                      >
-                        {composerPreview.placeholder}
+                    <div className="composer-inner-module">
+                      <div className="composer-textarea-wrap">
+                        <div
+                          className="composer-textarea settings-composer-preview-textarea"
+                          aria-hidden="true"
+                          style={{ minHeight: '60px' }}
+                        >
+                          {composerPreview.placeholder}
+                        </div>
                       </div>
-                    </div>
-                    <div className="composer-bottom-controls">
-                      <div className="composer-control-footer settings-composer-preview-footer">
-                        <div className="composer-inline-pickers">
-                          <div className="composer-inline-pickers-left" aria-hidden="true">
-                            <button
-                              type="button"
-                              className="composer-picker-label settings-composer-preview-control"
-                              data-composer-control="attach"
-                              tabIndex={-1}
-                            >
-                              +
-                            </button>
-                            <span
-                              className="composer-picker-label settings-composer-preview-control"
-                              data-composer-control="provider"
-                            >
-                              {composerPreview.providerLabel}
-                            </span>
-                            <span
-                              className="composer-picker-label settings-composer-preview-control"
-                              data-composer-control="permission"
-                            >
-                              {composerPreview.permissionLabel}
-                            </span>
-                            <span
-                              className="composer-picker-label settings-composer-preview-control"
-                              data-composer-control="model"
-                            >
-                              {composerPreview.modelLabel}
-                            </span>
-                          </div>
-                          <div className="composer-inline-actions" aria-hidden="true">
-                            <span className="context-wheel settings-composer-preview-context">
-                              <svg viewBox="0 0 18 18" width="18" height="18">
-                                <circle
-                                  cx="9"
-                                  cy="9"
-                                  r="6.6"
-                                  fill="none"
-                                  stroke="currentColor"
-                                  strokeWidth="2"
-                                  opacity="0.22"
-                                />
-                                <path
-                                  d="M9 2.4a6.6 6.6 0 0 1 5.4 10.4"
-                                  fill="none"
-                                  stroke="currentColor"
-                                  strokeWidth="2"
-                                  strokeLinecap="round"
-                                />
-                              </svg>
-                            </span>
-                            <span className="composer-thread-token-tally">44%</span>
-                            <span className="composer-send-cluster">
+                      <div className="composer-bottom-controls">
+                        <div className="composer-control-footer settings-composer-preview-footer">
+                          <div className="composer-inline-pickers">
+                            <div className="composer-inline-pickers-left" aria-hidden="true">
                               <button
                                 type="button"
-                                className="composer-action-btn run-btn"
+                                className="composer-picker-label settings-composer-preview-control"
+                                data-composer-control="attach"
                                 tabIndex={-1}
-                                aria-label="Preview send button"
                               >
-                                ↑
+                                +
                               </button>
-                            </span>
+                              <span
+                                className="composer-picker-label settings-composer-preview-control"
+                                data-composer-control="provider"
+                              >
+                                {composerPreview.providerLabel}
+                              </span>
+                              <span
+                                className="composer-picker-label settings-composer-preview-control"
+                                data-composer-control="permission"
+                              >
+                                {composerPreview.permissionLabel}
+                              </span>
+                              <span
+                                className="composer-picker-label settings-composer-preview-control"
+                                data-composer-control="model"
+                              >
+                                {composerPreview.modelLabel}
+                              </span>
+                            </div>
+                            <div className="composer-inline-actions" aria-hidden="true">
+                              <span className="context-wheel settings-composer-preview-context">
+                                <svg viewBox="0 0 18 18" width="18" height="18">
+                                  <circle
+                                    cx="9"
+                                    cy="9"
+                                    r="6.6"
+                                    fill="none"
+                                    stroke="currentColor"
+                                    strokeWidth="2"
+                                    opacity="0.22"
+                                  />
+                                  <path
+                                    d="M9 2.4a6.6 6.6 0 0 1 5.4 10.4"
+                                    fill="none"
+                                    stroke="currentColor"
+                                    strokeWidth="2"
+                                    strokeLinecap="round"
+                                  />
+                                </svg>
+                              </span>
+                              <span className="composer-thread-token-tally">44%</span>
+                              <span className="composer-send-cluster">
+                                <button
+                                  type="button"
+                                  className="composer-action-btn run-btn"
+                                  tabIndex={-1}
+                                  aria-label="Preview send button"
+                                >
+                                  ↑
+                                </button>
+                              </span>
+                            </div>
                           </div>
                         </div>
                       </div>
@@ -1054,6 +1064,12 @@ export function FirstLaunchSheet({
               <strong>Cmd-K command palette.</strong> Anywhere in the app, press <kbd>Cmd</kbd>+
               <kbd>K</kbd> for the global command palette.
             </li>
+            <li>
+              <strong>Commit &amp; open PRs from the composer.</strong> The composer&apos;s{' '}
+              <em>Review changes</em> menu has a real Git flow — see your branch and changed files,
+              write a message and <em>Stage all &amp; Commit</em>, then <em>Create PR</em> once the
+              branch is pushed and ready.
+            </li>
             <li>
               <strong>Permission picker colour-codes the mode.</strong> Plan = blue (read-only),
               Default = neutral, Full Workspace Access / Auto-edit = red (orange in the Codex shell)
diff --git a/src/renderer/src/components/GitCommitControls.tsx b/src/renderer/src/components/GitCommitControls.tsx
new file mode 100644
index 00000000..11bf847f
--- /dev/null
+++ b/src/renderer/src/components/GitCommitControls.tsx
@@ -0,0 +1,422 @@
+/*
+ * GitCommitControls — the real, user-driven Git affordance that lives
+ * inside the composer above-bar's diff-action menu.
+ *
+ * This replaces the previous "Commit Changes" entry, which injected a
+ * natural-language prompt at the agent ("Commit N files…, review the
+ * diff, then run the commit") and relied on the model to drive git.
+ * Now the user drives it directly through the stable preload Git API
+ * (shipped in the main process / GitService — see
+ * src/main/services/GitService.ts):
+ *
+ *   window.api.gitSnapshot → read repo status (branch, file counts,
+ *                            staged/unstaged, ahead/behind, remote)
+ *   window.api.gitStage    → `git add` (we stage all changes)
+ *   window.api.gitCommit   → `git commit -m <message>`
+ *   window.api.createGithubPr → open a GitHub PR (gated on readiness)
+ *
+ * The ordering mirrors the safety story the composer already tells:
+ *   1. Review changes  (FIRST — open Diff Studio before mutating)
+ *   2. Stage + Commit  (explicit message + button; no prompt injection)
+ *   3. Create PR       (only when the repo is valid + branch suitable)
+ *
+ * The component owns its own snapshot fetch so App.tsx stays thin, and
+ * lifts the snapshot up via `onSnapshot` so the above-bar header can
+ * surface live git state (branch / changed-file count / staged state /
+ * push + PR readiness) without a second IPC round-trip.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { GitPrReadiness, GitRepositorySnapshot, GitResult } from '../../../main/services/GitService'
+
+export interface GitCommitControlsProps {
+  /** Workspace path to operate on. When absent the controls render a
+   * "no workspace" hint and disable all git actions. */
+  workspacePath: string | null | undefined
+  /** Whether the parent diff-action menu is currently open. We lazily
+   * fetch the snapshot only while open to avoid background IPC churn. */
+  open: boolean
+  /** True when the latest run produced a reviewable diff. Drives the
+   * Review-changes enablement so the FIRST safety step matches the rest
+   * of the above-bar. */
+  hasReviewableDiff: boolean
+  /** Open Diff Studio (the canonical "review changes" entry point). */
+  onReviewChanges: () => void
+  /** Close the parent menu (after a terminal action). */
+  onClose: () => void
+  /** Create a GitHub PR for this workspace. The parent owns the
+   * per-path PR state machine + the actual createGithubPr call so the
+   * other above-bar rows stay coherent; we just gate + delegate. */
+  onCreatePr: () => void
+  /** Current PR state for this workspace path (from the parent's
+   * per-path map). Drives the Create-PR label/disabled visuals. */
+  prState: { status: 'idle' | 'pending' | 'success' | 'error'; message?: string }
+  /** Lifts the freshest snapshot (or null on failure) up to the parent
+   * so the above-bar header can render live git state. Called on every
+   * successful/failed fetch and after stage/commit refreshes. */
+  onSnapshot?: (snapshot: GitRepositorySnapshot | null) => void
+}
+
+type ActionState = {
+  status: 'idle' | 'working' | 'error' | 'success'
+  message?: string
+}
+
+/**
+ * FALLBACK PR-readiness — used only while the canonical backend
+ * `githubPrReadiness` is loading or unavailable (older build / `gh`
+ * missing). When the backend readiness resolves it is preferred.
+ *
+ * Whether the repo is in a state where opening a PR can plausibly
+ * succeed. Mirrors GitService.createPullRequest's own guards (not
+ * detached, has a branch, has a remote) plus a "there is something to
+ * PR" heuristic so a pristine repo with no local work doesn't offer a
+ * PR button that the backend would only reject. We deliberately stay a
+ * touch permissive on the "commits vs base" check — if the user is
+ * ahead, dirty, or already tracking an upstream, there is something to
+ * turn into a PR; the backend surfaces the precise "push first" error
+ * when needed.
+ */
+function computePrReadiness(snapshot: GitRepositorySnapshot | null): {
+  canCreate: boolean
+  reason: string
+} {
+  if (!snapshot) return { canCreate: false, reason: 'Not a Git repository.' }
+  if (snapshot.detached || !snapshot.branch) {
+    return { canCreate: false, reason: 'Detached HEAD — switch to a branch to open a PR.' }
+  }
+  if (!snapshot.remoteUrl) {
+    return { canCreate: false, reason: 'No git remote configured — add one to open a PR.' }
+  }
+  const hasSomethingToPr = !snapshot.clean || snapshot.ahead > 0 || Boolean(snapshot.upstream)
+  if (!hasSomethingToPr) {
+    return { canCreate: false, reason: 'No commits to turn into a PR yet.' }
+  }
+  return { canCreate: true, reason: '' }
+}
+
+export function GitCommitControls({
+  workspacePath,
+  open,
+  hasReviewableDiff,
+  onReviewChanges,
+  onClose,
+  onCreatePr,
+  prState,
+  onSnapshot
+}: GitCommitControlsProps): React.JSX.Element {
+  const [snapshot, setSnapshot] = useState<GitRepositorySnapshot | null>(null)
+  // Canonical PR readiness from the backend (Codex's githubPrReadiness,
+  // 8d348fc) — checks detached / remote / push-first AND existing PRs via
+  // gh. Preferred over the local computePrReadiness mirror; null while it
+  // loads or if the API / `gh` is unavailable, in which case we fall back.
+  const [serverReadiness, setServerReadiness] = useState<GitPrReadiness | null>(null)
+  const [loadState, setLoadState] = useState<ActionState>({ status: 'idle' })
+  const [commitState, setCommitState] = useState<ActionState>({ status: 'idle' })
+  const [message, setMessage] = useState('')
+  // Guards against setState-after-unmount when the menu closes mid-IPC.
+  const mountedRef = useRef(true)
+  // Keep the latest onSnapshot without making fetch effects depend on
+  // an inline callback identity (parents often pass a fresh arrow).
+  // Synced in an effect (matching ChangelogSheet/BugReportSheet's
+  // `dismissRef` pattern) rather than during render.
+  const onSnapshotRef = useRef(onSnapshot)
+  useEffect(() => {
+    onSnapshotRef.current = onSnapshot
+  }, [onSnapshot])
+
+  useEffect(() => {
+    mountedRef.current = true
+    return () => {
+      mountedRef.current = false
+    }
+  }, [])
+
+  const refreshSnapshot = useCallback(async () => {
+    if (!workspacePath) {
+      setSnapshot(null)
+      setLoadState({ status: 'idle' })
+      onSnapshotRef.current?.(null)
+      return
+    }
+    if (typeof window.api?.gitSnapshot !== 'function') {
+      setLoadState({ status: 'error', message: 'Git is unavailable in this build.' })
+      onSnapshotRef.current?.(null)
+      return
+    }
+    setLoadState({ status: 'working' })
+    try {
+      const result: GitResult<GitRepositorySnapshot> = await window.api.gitSnapshot({
+        workspacePath
+      })
+      if (!mountedRef.current) return
+      if (result.ok) {
+        setSnapshot(result.data)
+        setLoadState({ status: 'idle' })
+        onSnapshotRef.current?.(result.data)
+      } else {
+        setSnapshot(null)
+        setLoadState({ status: 'error', message: result.error || 'Not a Git repository.' })
+        onSnapshotRef.current?.(null)
+      }
+    } catch (error) {
+      if (!mountedRef.current) return
+      setSnapshot(null)
+      setLoadState({
+        status: 'error',
+        message: error instanceof Error ? error.message : 'Failed to read Git status.'
+      })
+      onSnapshotRef.current?.(null)
+    }
+  }, [workspacePath])
+
+  // Canonical PR-readiness fetch (backend, gh-aware). Runs alongside the
+  // snapshot fetch; any failure leaves serverReadiness null so the local
+  // mirror takes over — this never blocks commit/status. Guarded for
+  // older builds that predate the githubPrReadiness API.
+  const refreshReadiness = useCallback(async () => {
+    if (!workspacePath || typeof window.api?.githubPrReadiness !== 'function') {
+      setServerReadiness(null)
+      return
+    }
+    try {
+      const result = await window.api.githubPrReadiness({ workspacePath })
+      if (!mountedRef.current) return
+      setServerReadiness(result.ok ? result.data : null)
+    } catch {
+      if (!mountedRef.current) return
+      setServerReadiness(null)
+    }
+  }, [workspacePath])
+
+  // Lazily (re)fetch whenever the menu opens or the workspace changes.
+  useEffect(() => {
+    if (!open) return
+    void refreshSnapshot()
+    void refreshReadiness()
+  }, [open, refreshSnapshot, refreshReadiness])
+
+  const handleCommit = useCallback(async () => {
+    const trimmed = message.trim()
+    if (!workspacePath) {
+      setCommitState({ status: 'error', message: 'Open a workspace to commit.' })
+      return
+    }
+    if (!trimmed) {
+      setCommitState({ status: 'error', message: 'Enter a commit message first.' })
+      return
+    }
+    if (typeof window.api?.gitStage !== 'function' || typeof window.api?.gitCommit !== 'function') {
+      setCommitState({ status: 'error', message: 'Git is unavailable in this build.' })
+      return
+    }
+    setCommitState({ status: 'working', message: 'Staging changes…' })
+    try {
+      // Stage everything the user is reviewing, then commit. Two
+      // explicit steps so a stage failure surfaces distinctly from a
+      // commit failure (e.g. nothing staged, hook rejection).
+      const staged = await window.api.gitStage({ workspacePath, all: true })
+      if (!mountedRef.current) return
+      if (!staged.ok) {
+        setCommitState({ status: 'error', message: staged.error || 'Failed to stage changes.' })
+        return
+      }
+      setCommitState({ status: 'working', message: 'Committing…' })
+      const committed = await window.api.gitCommit({ workspacePath, message: trimmed })
+      if (!mountedRef.current) return
+      if (!committed.ok) {
+        setCommitState({ status: 'error', message: committed.error || 'Failed to commit.' })
+        // Refresh so the status block reflects the (now-staged) state.
+        void refreshSnapshot()
+        return
+      }
+      // Success: clear the draft, reflect the post-commit snapshot, and
+      // surface the new state. We keep the menu open so the user can
+      // immediately push/PR if they want.
+      setMessage('')
+      setSnapshot(committed.data)
+      onSnapshotRef.current?.(committed.data)
+      // The new commit changes ahead/push state — refresh the canonical PR gate.
+      void refreshReadiness()
+      setCommitState({ status: 'success', message: 'Committed.' })
+    } catch (error) {
+      if (!mountedRef.current) return
+      setCommitState({
+        status: 'error',
+        message: error instanceof Error ? error.message : 'Failed to commit.'
+      })
+    }
+  }, [message, workspacePath, refreshSnapshot, refreshReadiness])
+
+  // Prefer the canonical backend readiness (gh-aware: detached, remote,
+  // push-first, AND existing-PR detection); fall back to the local mirror
+  // while it loads or if the API / `gh` is unavailable.
+  const prReadiness: { canCreate: boolean; reason: string } = serverReadiness
+    ? { canCreate: serverReadiness.canCreatePullRequest, reason: serverReadiness.reason ?? '' }
+    : computePrReadiness(snapshot)
+  const prLabel =
+    prState.status === 'pending'
+      ? 'Creating…'
+      : prState.status === 'success'
+        ? 'PR opened'
+        : prState.status === 'error'
+          ? 'Retry PR'
+          : 'Create PR'
+
+  const counts = snapshot?.counts
+  const hasStaged = (counts?.staged ?? 0) > 0
+  const changedCount = counts?.changed ?? 0
+  // Commit is allowed whenever there is anything to stage+commit OR
+  // something already staged. (The backend re-checks staged-ness, so a
+  // race that leaves nothing staged still fails safely with a message.)
+  const canCommit =
+    Boolean(workspacePath) &&
+    snapshot != null &&
+    commitState.status !== 'working' &&
+    (changedCount > 0 || hasStaged)
+
+  return (
+    <div className="composer-git-controls" role="group" aria-label="Git controls">
+      {/* Live repo status, driven entirely by gitSnapshot. */}
+      <div className="composer-git-status" aria-live="polite">
+        {loadState.status === 'working' && !snapshot ? (
+          <span className="composer-git-status-line is-muted">Reading Git status…</span>
+        ) : loadState.status === 'error' ? (
+          <span className="composer-git-status-line is-error">
+            {loadState.message || 'Not a Git repository.'}
+          </span>
+        ) : snapshot ? (
+          <>
+            <span className="composer-git-status-line">
+              <strong className="composer-git-branch">
+                {snapshot.detached ? 'detached HEAD' : snapshot.branch || 'unknown branch'}
+              </strong>
+              {snapshot.clean ? (
+                <span className="composer-git-status-clean">clean</span>
+              ) : (
+                <span className="composer-git-status-counts">
+                  {changedCount} {changedCount === 1 ? 'change' : 'changes'}
+                  {hasStaged ? ` · ${counts?.staged} staged` : ''}
+                  {(counts?.unstaged ?? 0) > 0 ? ` · ${counts?.unstaged} unstaged` : ''}
+                  {(counts?.untracked ?? 0) > 0 ? ` · ${counts?.untracked} new` : ''}
+                </span>
+              )}
+            </span>
+            {(snapshot.ahead > 0 || snapshot.behind > 0 || !snapshot.upstream) && (
+              <span className="composer-git-status-line is-muted">
+                {!snapshot.upstream
+                  ? 'No upstream — push to set one.'
+                  : `${snapshot.ahead} ahead · ${snapshot.behind} behind ${snapshot.upstream}`}
+              </span>
+            )}
+          </>
+        ) : (
+          <span className="composer-git-status-line is-muted">No workspace selected.</span>
+        )}
+      </div>
+
+      {/* 1. Review changes — the FIRST safety step, before any mutation. */}
+      <button
+        type="button"
+        className="composer-git-menu-item"
+        onClick={() => {
+          onReviewChanges()
+          onClose()
+        }}
+        disabled={!hasReviewableDiff}
+        title={
+          hasReviewableDiff
+            ? 'Open Diff Studio to review the latest run changes'
+            : 'No latest run diff is available yet'
+        }
+      >
+        Review changes
+      </button>
+
+      {/* 2. Stage + commit — explicit message + button (no prompt injection). */}
+      <div className="composer-git-commit">
+        <input
+          type="text"
+          className="composer-git-commit-input"
+          value={message}
+          placeholder="Commit message"
+          aria-label="Commit message"
+          onChange={(event) => {
+            setMessage(event.target.value)
+            if (commitState.status === 'error' || commitState.status === 'success') {
+              setCommitState({ status: 'idle' })
+            }
+          }}
+          onKeyDown={(event) => {
+            // Enter commits (mirrors the dedicated button) so the flow is
+            // keyboard-complete; Escape bubbles to the menu's own handler.
+            if (event.key === 'Enter' && canCommit && message.trim()) {
+              event.preventDefault()
+              void handleCommit()
+            }
+          }}
+          disabled={!workspacePath || commitState.status === 'working'}
+        />
+        <button
+          type="button"
+          className={`composer-above-bar-action composer-git-commit-button ${
+            commitState.status === 'working' ? 'is-pending' : ''
+          } ${commitState.status === 'error' ? 'is-error' : ''} ${
+            commitState.status === 'success' ? 'is-success' : ''
+          }`}
+          onClick={() => void handleCommit()}
+          disabled={!canCommit || !message.trim()}
+          title={
+            !workspacePath
+              ? 'Open a workspace to commit'
+              : changedCount === 0 && !hasStaged
+                ? 'No changes to commit'
+                : 'Stage all changes and commit with this message'
+          }
+        >
+          {commitState.status === 'working' ? 'Committing…' : 'Stage all & Commit'}
+        </button>
+      </div>
+      {commitState.message && commitState.status !== 'idle' && (
+        <span
+          className={`composer-git-feedback ${
+            commitState.status === 'error'
+              ? 'is-error'
+              : commitState.status === 'success'
+                ? 'is-success'
+                : 'is-muted'
+          }`}
+          role={commitState.status === 'error' ? 'alert' : undefined}
+        >
+          {commitState.message}
+        </span>
+      )}
+
+      {/* 3. Create PR — gated on validity + branch suitability. */}
+      <button
+        type="button"
+        className={`composer-git-menu-item composer-git-pr ${
+          prState.status === 'pending' ? 'is-pending' : ''
+        } ${prState.status === 'error' ? 'is-error' : ''} ${
+          prState.status === 'success' ? 'is-success' : ''
+        }`}
+        onClick={() => {
+          onCreatePr()
+          onClose()
+        }}
+        disabled={prState.status === 'pending' || !prReadiness.canCreate}
+        title={
+          prState.message ||
+          (prReadiness.canCreate
+            ? 'Open a GitHub pull request for this branch'
+            : prReadiness.reason)
+        }
+      >
+        {prLabel}
+        {!prReadiness.canCreate && prState.status !== 'pending' && (
+          <span className="composer-git-pr-reason">{prReadiness.reason}</span>
+        )}
+      </button>
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/Inspector.test.ts b/src/renderer/src/components/Inspector.test.ts
index cea8b384..7d3fa9b0 100644
--- a/src/renderer/src/components/Inspector.test.ts
+++ b/src/renderer/src/components/Inspector.test.ts
@@ -54,7 +54,9 @@ function makeCapabilityContract(provider: ProviderId): ProviderCapabilityContrac
       fileChanges: tool('fileChanges', 'Files'),
       mcpTools: tool('mcpTools', 'MCP'),
       creativeApps: tool('creativeApps', 'Creative apps'),
-      networkAccess: tool('networkAccess', 'Network')
+      networkAccess: tool('networkAccess', 'Network'),
+      elicit: tool('elicit', 'Ask the user'),
+      delegate: tool('delegate', 'Delegate to sub-thread')
     },
     approvals: {
       requestedMode: 'default',
diff --git a/src/renderer/src/components/Inspector.tsx b/src/renderer/src/components/Inspector.tsx
index b05c1028..152b88d0 100644
--- a/src/renderer/src/components/Inspector.tsx
+++ b/src/renderer/src/components/Inspector.tsx
@@ -1154,14 +1154,20 @@ function ToolingContractCard({ contract }: { contract?: ProviderCapabilityContra
     )
   }
 
-  const tools = [
+  // The five functional-control rows drive the AGBench-enforcement tally. The
+  // elicit/delegate rows are DISPLAY-only additions: they render in the strip
+  // but are deliberately excluded from `enforcedCount` so promoting
+  // subThreadDelegation to a row does not double-count against its existing
+  // settings gate or change the "X/5 controls" number.
+  const controlTools = [
     contract.tools.shellCommands,
     contract.tools.fileChanges,
     contract.tools.mcpTools,
     contract.tools.creativeApps,
     contract.tools.networkAccess
   ]
-  const enforcedCount = tools.filter((tool) => tool.enforcedByAgentBench).length
+  const displayTools = [...controlTools, contract.tools.elicit, contract.tools.delegate]
+  const enforcedCount = controlTools.filter((tool) => tool.enforcedByAgentBench).length
   return (
     <div className="safety-card">
       <h4>{safeText(contract.label, 'Provider')} tooling contract</h4>
@@ -1198,7 +1204,7 @@ function ToolingContractCard({ contract }: { contract?: ProviderCapabilityContra
       <div className="safety-row">
         <span>AGBench enforcement</span>
         <span style={{ color: enforcedCount > 0 ? 'var(--success)' : 'var(--warning)' }}>
-          {enforcedCount}/{tools.length} controls
+          {enforcedCount}/{controlTools.length} controls
         </span>
       </div>
       <div className="safety-row">
@@ -1215,7 +1221,7 @@ function ToolingContractCard({ contract }: { contract?: ProviderCapabilityContra
           marginTop: 'var(--space-md)'
         }}
       >
-        {tools.map((tool, idx) => (
+        {displayTools.map((tool, idx) => (
           <div
             key={safeText(tool.id) || `tool-${idx}`}
             style={{ borderTop: '1px solid var(--panel-border)', paddingTop: 'var(--space-sm)' }}
diff --git a/src/renderer/src/components/SettingsPanel.tsx b/src/renderer/src/components/SettingsPanel.tsx
index b44a6b5f..44383d68 100644
--- a/src/renderer/src/components/SettingsPanel.tsx
+++ b/src/renderer/src/components/SettingsPanel.tsx
@@ -1,4 +1,5 @@
 import React, { useEffect, useState } from 'react'
+import { MascotGhost } from './AppChromeSymbols'
 import type {
   AgenticNetworkPolicy,
   AgenticServiceId,
@@ -2125,81 +2126,91 @@ export function SettingsPanel({
                         Obsidian/Alabaster two-rect split + reorder CSS
                         applies to this preview (layout-neutral for the
                         other shells).
+
+                        Console redesign — wrap BOTH the textarea-wrap and
+                        the bottom-controls together in .composer-inner-module
+                        (theme-tone inset panel inside the solid frame), to
+                        match the real default composer. Layout-neutral for
+                        the non-default shell previews via the base
+                        `.composer-inner-module { display: contents }` rule;
+                        the chips stay OUTSIDE/above it.
                       */}
-                      <div className="composer-textarea-wrap">
-                        <textarea
-                          className="composer-textarea settings-composer-preview-textarea"
-                          value={composerPreviewText}
-                          onChange={(e) => setComposerPreviewText(e.target.value)}
-                          placeholder={composerPreviewMeta.placeholder}
-                          rows={3}
-                          aria-label="Composer font preview text"
-                          style={{ fontFamily: previewComposerFontFamily }}
-                        />
-                      </div>
-                      <div className="composer-bottom-controls">
-                        <div className="composer-control-footer settings-composer-preview-footer">
-                          <div className="composer-inline-pickers">
-                            <div className="composer-inline-pickers-left" aria-hidden="true">
-                              <button
-                                type="button"
-                                className="composer-picker-label settings-composer-preview-control"
-                                data-composer-control="attach"
-                                tabIndex={-1}
-                              >
-                                +
-                              </button>
-                              <span
-                                className="composer-picker-label settings-composer-preview-control"
-                                data-composer-control="provider"
-                              >
-                                {composerPreviewMeta.providerLabel}
-                              </span>
-                              <span
-                                className="composer-picker-label settings-composer-preview-control"
-                                data-composer-control="permission"
-                              >
-                                {composerPreviewMeta.permissionLabel}
-                              </span>
-                              <span
-                                className="composer-picker-label settings-composer-preview-control"
-                                data-composer-control="model"
-                              >
-                                {composerPreviewMeta.modelLabel}
-                              </span>
-                            </div>
-                            <div className="composer-inline-actions" aria-hidden="true">
-                              <span className="context-wheel settings-composer-preview-context">
-                                <svg viewBox="0 0 18 18" width="18" height="18">
-                                  <circle
-                                    cx="9"
-                                    cy="9"
-                                    r="6.6"
-                                    fill="none"
-                                    stroke="currentColor"
-                                    strokeWidth="2"
-                                    opacity="0.22"
-                                  />
-                                  <path
-                                    d="M9 2.4a6.6 6.6 0 0 1 5.4 10.4"
-                                    fill="none"
-                                    stroke="currentColor"
-                                    strokeWidth="2"
-                                    strokeLinecap="round"
-                                  />
-                                </svg>
-                              </span>
-                              <span className="composer-thread-token-tally">44%</span>
-                              <span className="composer-send-cluster">
+                      <div className="composer-inner-module">
+                        <div className="composer-textarea-wrap">
+                          <textarea
+                            className="composer-textarea settings-composer-preview-textarea"
+                            value={composerPreviewText}
+                            onChange={(e) => setComposerPreviewText(e.target.value)}
+                            placeholder={composerPreviewMeta.placeholder}
+                            rows={3}
+                            aria-label="Composer font preview text"
+                            style={{ fontFamily: previewComposerFontFamily }}
+                          />
+                        </div>
+                        <div className="composer-bottom-controls">
+                          <div className="composer-control-footer settings-composer-preview-footer">
+                            <div className="composer-inline-pickers">
+                              <div className="composer-inline-pickers-left" aria-hidden="true">
                                 <button
                                   type="button"
-                                  className="composer-action-btn run-btn"
+                                  className="composer-picker-label settings-composer-preview-control"
+                                  data-composer-control="attach"
                                   tabIndex={-1}
-                                  aria-label="Preview send button"
                                 >
-                                  ↑
+                                  +
                                 </button>
-                              </span>
+                                <span
+                                  className="composer-picker-label settings-composer-preview-control"
+                                  data-composer-control="provider"
+                                >
+                                  {composerPreviewMeta.providerLabel}
+                                </span>
+                                <span
+                                  className="composer-picker-label settings-composer-preview-control"
+                                  data-composer-control="permission"
+                                >
+                                  {composerPreviewMeta.permissionLabel}
+                                </span>
+                                <span
+                                  className="composer-picker-label settings-composer-preview-control"
+                                  data-composer-control="model"
+                                >
+                                  {composerPreviewMeta.modelLabel}
+                                </span>
+                              </div>
+                              <div className="composer-inline-actions" aria-hidden="true">
+                                <span className="context-wheel settings-composer-preview-context">
+                                  <svg viewBox="0 0 18 18" width="18" height="18">
+                                    <circle
+                                      cx="9"
+                                      cy="9"
+                                      r="6.6"
+                                      fill="none"
+                                      stroke="currentColor"
+                                      strokeWidth="2"
+                                      opacity="0.22"
+                                    />
+                                    <path
+                                      d="M9 2.4a6.6 6.6 0 0 1 5.4 10.4"
+                                      fill="none"
+                                      stroke="currentColor"
+                                      strokeWidth="2"
+                                      strokeLinecap="round"
+                                    />
+                                  </svg>
+                                </span>
+                                <span className="composer-thread-token-tally">44%</span>
+                                <span className="composer-send-cluster">
+                                  <button
+                                    type="button"
+                                    className="composer-action-btn run-btn"
+                                    tabIndex={-1}
+                                    aria-label="Preview send button"
+                                  >
+                                    ↑
+                                  </button>
+                                </span>
+                              </div>
                             </div>
                           </div>
                         </div>
@@ -2579,8 +2590,7 @@ export function SettingsPanel({
                 <span className="settings-field-label">Layout</span>
                 <div className="settings-option-list settings-option-list-inline">
                   {(['stacked', 'single'] as const).map((opt) => {
-                    const current =
-                      welcomeHeatmapPrefs?.layout === 'single' ? 'single' : 'stacked'
+                    const current = welcomeHeatmapPrefs?.layout === 'single' ? 'single' : 'stacked'
                     return (
                       <button
                         key={opt}
@@ -3010,7 +3020,7 @@ export function SettingsPanel({
 
               {/*
                 1.0.5-EW26 — Kimi (Moonshot) compatibility filter.
-                Off by default. When enabled, ensemble-mode Kimi
+                On by default. Ensemble-mode Kimi
                 participants get their prompt context scanned by
                 `src/main/lib/kimiSanitiser.ts` before spawn:
                 sentences containing curated trigger keywords
@@ -3620,12 +3630,15 @@ export function SettingsPanel({
                     {providerCapabilities.mcp.state}, creative apps are{' '}
                     {providerCapabilities.tools.creativeApps.state};{' '}
                     {
-                      Object.values(providerCapabilities.tools).filter(
-                        (tool) => tool.enforcedByAgentBench
-                      ).length
+                      [
+                        providerCapabilities.tools.shellCommands,
+                        providerCapabilities.tools.fileChanges,
+                        providerCapabilities.tools.mcpTools,
+                        providerCapabilities.tools.creativeApps,
+                        providerCapabilities.tools.networkAccess
+                      ].filter((tool) => tool.enforcedByAgentBench).length
                     }
-                    /{Object.values(providerCapabilities.tools).length} controls are
-                    AGBench-enforced.
+                    /5 controls are AGBench-enforced.
                   </div>
                 )}
                 {!providerCapabilities && (
@@ -4718,6 +4731,7 @@ export function SettingsPanel({
             </div>
             {workspaces.length === 0 ? (
               <div className="settings-workspaces-empty" role="note">
+                <MascotGhost size={30} />
                 <strong>No workspaces yet.</strong>
                 <span>
                   Use <em>Add workspace</em> above to point AGBench at your first project folder.
diff --git a/src/renderer/src/components/Sidebar.tsx b/src/renderer/src/components/Sidebar.tsx
index ced8b5e6..7945271d 100644
--- a/src/renderer/src/components/Sidebar.tsx
+++ b/src/renderer/src/components/Sidebar.tsx
@@ -7,6 +7,7 @@ import {
   type MouseEvent,
   type ReactNode
 } from 'react'
+import { MascotGhost } from './AppChromeSymbols'
 import type {
   WorkspaceRecord,
   ChatRecord,
@@ -2801,7 +2802,11 @@ export function Sidebar({
                     )
                   })}
                   {visibleGlobalChats.length === 0 && !isSidebarSearchActive && (
-                    <div className="sidebar-empty-state">No chats yet.</div>
+                    <div className="sidebar-empty-state sidebar-empty-state--ghost">
+                      <MascotGhost size={28} />
+                      <strong>No chats yet</strong>
+                      <span>Hit + above to start one.</span>
+                    </div>
                   )}
                 </div>
               )}
diff --git a/src/renderer/src/components/UpdatePill.tsx b/src/renderer/src/components/UpdatePill.tsx
new file mode 100644
index 00000000..10ec2a2b
--- /dev/null
+++ b/src/renderer/src/components/UpdatePill.tsx
@@ -0,0 +1,65 @@
+import React from 'react'
+import type { UpdateStateSnapshot } from '../../../main/UpdateService'
+
+interface UpdatePillProps {
+  snapshot: UpdateStateSnapshot | null
+  onOpen: () => void
+}
+
+const ACTIONABLE_UPDATE_STATUSES = new Set<UpdateStateSnapshot['status']>([
+  'available',
+  'downloading',
+  'downloaded',
+  'error'
+])
+
+export function UpdatePill({ snapshot, onOpen }: UpdatePillProps): React.JSX.Element | null {
+  if (!snapshot || !ACTIONABLE_UPDATE_STATUSES.has(snapshot.status)) return null
+
+  const label = labelForSnapshot(snapshot)
+  return (
+    <button
+      className={`chat-corner-btn chat-corner-update-pill chat-corner-update-pill-${snapshot.status}`}
+      type="button"
+      onClick={onOpen}
+      title={titleForSnapshot(snapshot)}
+      aria-label={titleForSnapshot(snapshot)}
+    >
+      <span className="chat-corner-update-pill-label">{label}</span>
+    </button>
+  )
+}
+
+function labelForSnapshot(snapshot: UpdateStateSnapshot): string {
+  switch (snapshot.status) {
+    case 'available':
+      return snapshot.latestVersion ? `Update ${snapshot.latestVersion}` : 'Update'
+    case 'downloading':
+      return typeof snapshot.downloadProgress?.percent === 'number'
+        ? `${Math.round(snapshot.downloadProgress.percent)}%`
+        : 'Downloading'
+    case 'downloaded':
+      return 'Restart'
+    case 'error':
+      return 'Update issue'
+    default:
+      return 'Update'
+  }
+}
+
+function titleForSnapshot(snapshot: UpdateStateSnapshot): string {
+  switch (snapshot.status) {
+    case 'available':
+      return snapshot.latestVersion
+        ? `AGBench ${snapshot.latestVersion} is available`
+        : 'An AGBench update is available'
+    case 'downloading':
+      return 'AGBench update is downloading'
+    case 'downloaded':
+      return 'Restart AGBench to install the downloaded update'
+    case 'error':
+      return snapshot.errorMessage || 'AGBench update check failed'
+    default:
+      return 'AGBench update'
+  }
+}
diff --git a/src/renderer/src/components/UpdateStatusPane.tsx b/src/renderer/src/components/UpdateStatusPane.tsx
index a8a20d74..61b41195 100644
--- a/src/renderer/src/components/UpdateStatusPane.tsx
+++ b/src/renderer/src/components/UpdateStatusPane.tsx
@@ -1,4 +1,6 @@
-import React, { useCallback, useEffect, useState } from 'react'
+import React, { useCallback } from 'react'
+import type { UpdateStateSnapshot } from '../../../main/UpdateService'
+import { useUpdateStatus } from '../hooks/useUpdateStatus'
 
 /**
  * UpdateStatusPane — Phase G2 sub-section of Settings → System.
@@ -15,79 +17,14 @@ import React, { useCallback, useEffect, useState } from 'react'
  * reshape the Settings layout later.
  */
 
-interface UpdateSnapshot {
-  status:
-    | 'disabled'
-    | 'idle'
-    | 'checking'
-    | 'available'
-    | 'not-available'
-    | 'downloading'
-    | 'downloaded'
-    | 'error'
-  enabled: boolean
-  channel: 'debug' | 'stable' | 'nightly'
-  latestVersion?: string
-  downloadProgress?: {
-    bytesPerSecond: number
-    percent: number
-    transferred: number
-    total: number
-  }
-  errorMessage?: string
-  lastCheckedAt?: string
-}
-
 export function UpdateStatusPane(): React.JSX.Element {
-  const [snap, setSnap] = useState<UpdateSnapshot | null>(null)
-  const [busy, setBusy] = useState(false)
-
-  const refresh = useCallback(async () => {
-    try {
-      const next = (await window.api.updateSnapshot()) as UpdateSnapshot
-      setSnap(next)
-    } catch {
-      // Ignore — IPC handler may not be registered yet during a hot
-      // reload; the next event will repopulate.
-    }
-  }, [])
-
-  useEffect(() => {
-    void Promise.resolve().then(() => refresh())
-    if (typeof window.api.onUpdateStatusChanged === 'function') {
-      window.api.onUpdateStatusChanged((next) => setSnap(next as UpdateSnapshot))
-    }
-  }, [refresh])
-
-  const handleCheck = useCallback(async () => {
-    setBusy(true)
-    try {
-      const next = (await window.api.checkForUpdates()) as UpdateSnapshot
-      setSnap(next)
-    } finally {
-      setBusy(false)
-    }
-  }, [])
-
-  const handleDownload = useCallback(async () => {
-    setBusy(true)
-    try {
-      const next = (await window.api.downloadUpdate()) as UpdateSnapshot
-      setSnap(next)
-    } finally {
-      setBusy(false)
-    }
-  }, [])
+  const { snapshot: snap, busy, checkForUpdates, downloadUpdate, installUpdateNow } =
+    useUpdateStatus()
 
   const handleInstall = useCallback(async () => {
     if (!confirm('Install update and restart AGBench now?')) return
-    setBusy(true)
-    try {
-      await window.api.installUpdateNow()
-    } finally {
-      setBusy(false)
-    }
-  }, [])
+    await installUpdateNow()
+  }, [installUpdateNow])
 
   if (!snap) {
     return (
@@ -136,7 +73,7 @@ export function UpdateStatusPane(): React.JSX.Element {
           disabled={
             busy || !snap.enabled || snap.status === 'checking' || snap.status === 'downloading'
           }
-          onClick={() => void handleCheck()}
+          onClick={() => void checkForUpdates()}
         >
           {snap.status === 'checking' ? 'Checking…' : 'Check for updates'}
         </button>
@@ -145,7 +82,7 @@ export function UpdateStatusPane(): React.JSX.Element {
             type="button"
             className="btn btn-sm btn-primary"
             disabled={busy}
-            onClick={() => void handleDownload()}
+            onClick={() => void downloadUpdate()}
           >
             Download
           </button>
@@ -174,7 +111,7 @@ export function UpdateStatusPane(): React.JSX.Element {
   )
 }
 
-function labelForStatus(status: UpdateSnapshot['status']): string {
+function labelForStatus(status: UpdateStateSnapshot['status']): string {
   switch (status) {
     case 'disabled':
       return 'Disabled'
diff --git a/src/renderer/src/hooks/useUpdateStatus.ts b/src/renderer/src/hooks/useUpdateStatus.ts
new file mode 100644
index 00000000..1219bb38
--- /dev/null
+++ b/src/renderer/src/hooks/useUpdateStatus.ts
@@ -0,0 +1,68 @@
+import { useCallback, useEffect, useState } from 'react'
+import type { UpdateStateSnapshot } from '../../../main/UpdateService'
+
+export function useUpdateStatus(): {
+  snapshot: UpdateStateSnapshot | null
+  busy: boolean
+  refresh: () => Promise<UpdateStateSnapshot | null>
+  checkForUpdates: () => Promise<UpdateStateSnapshot | null>
+  downloadUpdate: () => Promise<UpdateStateSnapshot | null>
+  installUpdateNow: () => Promise<UpdateStateSnapshot | null>
+} {
+  const [snapshot, setSnapshot] = useState<UpdateStateSnapshot | null>(null)
+  const [busy, setBusy] = useState(false)
+
+  const refresh = useCallback(async (): Promise<UpdateStateSnapshot | null> => {
+    try {
+      const next = await window.api.updateSnapshot()
+      setSnapshot(next)
+      return next
+    } catch {
+      return null
+    }
+  }, [])
+
+  useEffect(() => {
+    void refresh()
+    if (typeof window.api.onUpdateStatusChanged !== 'function') return
+    return window.api.onUpdateStatusChanged((next) => setSnapshot(next))
+  }, [refresh])
+
+  const runUpdateAction = useCallback(
+    async (
+      action: () => Promise<UpdateStateSnapshot>
+    ): Promise<UpdateStateSnapshot | null> => {
+      setBusy(true)
+      try {
+        const next = await action()
+        setSnapshot(next)
+        return next
+      } finally {
+        setBusy(false)
+      }
+    },
+    []
+  )
+
+  const checkForUpdates = useCallback(
+    () => runUpdateAction(() => window.api.checkForUpdates()),
+    [runUpdateAction]
+  )
+  const downloadUpdate = useCallback(
+    () => runUpdateAction(() => window.api.downloadUpdate()),
+    [runUpdateAction]
+  )
+  const installUpdateNow = useCallback(
+    () => runUpdateAction(() => window.api.installUpdateNow()),
+    [runUpdateAction]
+  )
+
+  return {
+    snapshot,
+    busy,
+    refresh,
+    checkForUpdates,
+    downloadUpdate,
+    installUpdateNow
+  }
+}
diff --git a/src/renderer/src/lib/ActivityPathDisplay.test.ts b/src/renderer/src/lib/ActivityPathDisplay.test.ts
index 0bcf38ca..9b400e9f 100644
--- a/src/renderer/src/lib/ActivityPathDisplay.test.ts
+++ b/src/renderer/src/lib/ActivityPathDisplay.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { displayPathRelativeToWorkspace } from './ActivityPathDisplay'
+import { displayPathRelativeToWorkspace, tildifyHomePath } from './ActivityPathDisplay'
 
 describe('displayPathRelativeToWorkspace', () => {
   describe('workspace-relative truncation', () => {
@@ -160,3 +160,33 @@ describe('displayPathRelativeToWorkspace', () => {
     })
   })
 })
+
+describe('tildifyHomePath', () => {
+  it('collapses a macOS home prefix to ~/ (strips the OS username)', () => {
+    expect(tildifyHomePath('/Users/bob/Documents/AGBench')).toBe('~/Documents/AGBench')
+  })
+
+  it('keeps the project folder + intermediate segments', () => {
+    expect(tildifyHomePath('/Users/alice/code/proj/src')).toBe('~/code/proj/src')
+  })
+
+  it('returns a non-home path unchanged (nothing to strip)', () => {
+    expect(tildifyHomePath('/Volumes/External/proj')).toBe('/Volumes/External/proj')
+  })
+
+  it('does not collapse bare `/Users` (no user segment)', () => {
+    expect(tildifyHomePath('/Users')).toBe('/Users')
+  })
+
+  it('trims surrounding whitespace before collapsing', () => {
+    expect(tildifyHomePath('  /Users/bob/x  ')).toBe('~/x')
+  })
+
+  it('returns "" for empty / nullish / non-string inputs', () => {
+    expect(tildifyHomePath('')).toBe('')
+    expect(tildifyHomePath('   ')).toBe('')
+    expect(tildifyHomePath(null)).toBe('')
+    expect(tildifyHomePath(undefined)).toBe('')
+    expect(tildifyHomePath(42 as unknown as string)).toBe('')
+  })
+})
diff --git a/src/renderer/src/lib/ActivityPathDisplay.ts b/src/renderer/src/lib/ActivityPathDisplay.ts
index 70b9efab..b799c52f 100644
--- a/src/renderer/src/lib/ActivityPathDisplay.ts
+++ b/src/renderer/src/lib/ActivityPathDisplay.ts
@@ -40,6 +40,22 @@ function startsWithSegment(haystack: string, prefix: string): boolean {
   return nextChar === '/' || nextChar === '\\'
 }
 
+/**
+ * Collapse a macOS home-directory prefix (`/Users/<user>/…`) to `~/…`,
+ * stripping the OS username. Used for compact display AND to keep a user's
+ * home path — which embeds their account name — out of anything shared
+ * publicly, e.g. the pre-filled GitHub issue produced by the bug reporter.
+ * Non-home paths (and bare `/Users` with no user segment) are returned
+ * trimmed but otherwise unchanged. Empty / nullish / non-string → ''.
+ */
+export function tildifyHomePath(filePath: string | undefined | null): string {
+  if (!filePath || typeof filePath !== 'string') return ''
+  const trimmed = filePath.trim()
+  if (!trimmed) return ''
+  const homeMatch = trimmed.match(HOME_PREFIX_RE)
+  return homeMatch ? `~/${trimmed.slice(homeMatch[0].length)}` : trimmed
+}
+
 /**
  * Returns a display-friendly path:
  *   - workspace-relative when the file lives under `workspacePath`
@@ -69,10 +85,5 @@ export function displayPathRelativeToWorkspace(
     }
   }
 
-  const homeMatch = trimmedPath.match(HOME_PREFIX_RE)
-  if (homeMatch) {
-    return `~/${trimmedPath.slice(homeMatch[0].length)}`
-  }
-
-  return trimmedPath
+  return tildifyHomePath(trimmedPath)
 }
diff --git a/src/renderer/src/lib/DelegationAudit.ts b/src/renderer/src/lib/DelegationAudit.ts
index 1ca23e39..610c8d8b 100644
--- a/src/renderer/src/lib/DelegationAudit.ts
+++ b/src/renderer/src/lib/DelegationAudit.ts
@@ -311,13 +311,22 @@ function labelForDelegationName(name: string, provider: ProviderId): string {
   return name || 'Delegated activity'
 }
 
+// The five functional-control rows. The DISPLAY-only elicit/delegate rows are
+// excluded from this enforcement tally so they never shift the count.
+const TOOLING_CONTROL_KEYS = [
+  'shellCommands',
+  'fileChanges',
+  'mcpTools',
+  'creativeApps',
+  'networkAccess'
+] as const
+
 function toolPolicyLabel(contract?: ProviderCapabilityContract | null): string | undefined {
   if (!contract) return undefined
-  const controlled = Object.values(contract.tools).filter(
-    (tool) => tool.enforcedByAgentBench
-  ).length
+  const controlRows = TOOLING_CONTROL_KEYS.map((key) => contract.tools[key])
+  const controlled = controlRows.filter((tool) => tool.enforcedByAgentBench).length
   return controlled > 0
-    ? `AGBench-enforced (${controlled}/${Object.values(contract.tools).length})`
+    ? `AGBench-enforced (${controlled}/${controlRows.length})`
     : 'provider-managed'
 }
 
diff --git a/src/renderer/src/lib/providerRateEstimate.test.ts b/src/renderer/src/lib/providerRateEstimate.test.ts
new file mode 100644
index 00000000..5e785e9e
--- /dev/null
+++ b/src/renderer/src/lib/providerRateEstimate.test.ts
@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest'
+import {
+  estimateRunCostUsd,
+  normalizeProviderRates,
+  resolveModelRate,
+  type RendererProviderRates
+} from './providerRateEstimate'
+
+const RATES: RendererProviderRates = {
+  codex: [
+    { modelId: 'gpt-5.5', inputUsdPerMillion: 1.25, outputUsdPerMillion: 10.0 },
+    { modelId: 'gpt-5.4-mini', inputUsdPerMillion: 0.25, outputUsdPerMillion: 2.0 }
+  ],
+  cursor: [] // empty list — Cursor ships no public rate
+}
+
+describe('normalizeProviderRates', () => {
+  it('unwraps the ProviderRatesSnapshot baseline envelope', () => {
+    const snapshot = {
+      rateTableVersion: '2026-05-29',
+      baseline: {
+        codex: {
+          provider: 'codex',
+          pricingUrl: 'https://example',
+          models: [
+            {
+              modelId: 'gpt-5.5',
+              inputUsdPerMillion: 1.25,
+              outputUsdPerMillion: 10.0,
+              cachedInputUsdPerMillion: 0.125,
+              sourceUrl: 'x',
+              lastVerified: '2026-05-29'
+            }
+          ]
+        },
+        cursor: { provider: 'cursor', pricingUrl: '', models: [] }
+      }
+    }
+    const out = normalizeProviderRates(snapshot)
+    expect(out.codex).toEqual([
+      { modelId: 'gpt-5.5', inputUsdPerMillion: 1.25, outputUsdPerMillion: 10.0 }
+    ])
+    // Empty model lists are dropped entirely.
+    expect(out.cursor).toBeUndefined()
+  })
+
+  it('accepts an already-unwrapped table map', () => {
+    const out = normalizeProviderRates({
+      grok: { models: [{ modelId: 'grok-build', inputUsdPerMillion: 1, outputUsdPerMillion: 2 }] }
+    })
+    expect(out.grok).toEqual([
+      { modelId: 'grok-build', inputUsdPerMillion: 1, outputUsdPerMillion: 2 }
+    ])
+  })
+
+  it('returns {} for malformed / missing input and skips invalid entries', () => {
+    expect(normalizeProviderRates(null)).toEqual({})
+    expect(normalizeProviderRates('nope')).toEqual({})
+    expect(normalizeProviderRates(undefined)).toEqual({})
+    // entry missing a numeric rate is skipped, leaving the provider absent
+    expect(
+      normalizeProviderRates({
+        codex: { models: [{ modelId: 'x', inputUsdPerMillion: 'bad', outputUsdPerMillion: 1 }] }
+      })
+    ).toEqual({})
+  })
+})
+
+describe('resolveModelRate', () => {
+  it('matches exactly, then by prefix, then falls back to the first model', () => {
+    expect(resolveModelRate(RATES, 'codex', 'gpt-5.5')?.modelId).toBe('gpt-5.5')
+    // dated suffix resolves to the base entry via prefix match
+    expect(resolveModelRate(RATES, 'codex', 'gpt-5.5-2026-06-01')?.modelId).toBe('gpt-5.5')
+    // unknown model on a known provider falls back to first listed
+    expect(resolveModelRate(RATES, 'codex', 'totally-unknown')?.modelId).toBe('gpt-5.5')
+  })
+
+  it('returns null for unknown provider or empty rate list', () => {
+    expect(resolveModelRate(RATES, undefined, 'gpt-5.5')).toBeNull()
+    expect(resolveModelRate(RATES, 'cursor', 'composer-2.5')).toBeNull()
+    expect(resolveModelRate(RATES, 'gemini', 'gemini-3.1-pro')).toBeNull()
+  })
+})
+
+describe('estimateRunCostUsd', () => {
+  it('projects input+output tokens at the per-million rate', () => {
+    // 1,000,000 in * $1.25/M + 500,000 out * $10/M = 1.25 + 5.00 = 6.25
+    const usd = estimateRunCostUsd(RATES, 'codex', 'gpt-5.5', 1_000_000, 500_000)
+    expect(usd).toBeCloseTo(6.25, 6)
+  })
+
+  it('uses the resolved (prefix/fallback) model rate', () => {
+    // unknown model → falls back to gpt-5.5 rate
+    const usd = estimateRunCostUsd(RATES, 'codex', 'mystery', 100_000, 0)
+    expect(usd).toBeCloseTo(0.125, 6)
+  })
+
+  it('returns 0 when provider/model cannot be resolved', () => {
+    expect(estimateRunCostUsd(RATES, 'cursor', 'composer-2.5', 100_000, 100_000)).toBe(0)
+    expect(estimateRunCostUsd(RATES, undefined, 'x', 100_000, 100_000)).toBe(0)
+  })
+
+  it('returns 0 when there are no tokens', () => {
+    expect(estimateRunCostUsd(RATES, 'codex', 'gpt-5.5', 0, 0)).toBe(0)
+  })
+
+  it('treats non-finite token counts as zero', () => {
+    expect(estimateRunCostUsd(RATES, 'codex', 'gpt-5.5', NaN, NaN)).toBe(0)
+    // one valid count still estimates
+    expect(estimateRunCostUsd(RATES, 'codex', 'gpt-5.5', 1_000_000, NaN)).toBeCloseTo(1.25, 6)
+  })
+})
diff --git a/src/renderer/src/lib/providerRateEstimate.ts b/src/renderer/src/lib/providerRateEstimate.ts
new file mode 100644
index 00000000..04e5003d
--- /dev/null
+++ b/src/renderer/src/lib/providerRateEstimate.ts
@@ -0,0 +1,163 @@
+/**
+ * 1.0.7 — Renderer-side token->USD ESTIMATOR for subscription/credit seats.
+ *
+ * Several providers bill via a flat subscription or a credit pool rather than
+ * per-token, so their run stats carry NO `cost_usd`:
+ *   - Codex  → ChatGPT subscription quota (Plus / Pro / Business)
+ *   - Grok   → SuperGrok subscription credits
+ *   - Cursor → Cursor subscription (token-based but no clean public rate)
+ *
+ * For those seats the real spend is blank. This module maps summed input /
+ * output tokens to a PROJECTED API-equivalent USD figure using the per-model
+ * rate table that `ProviderRateService` exposes over the `providerRates:get`
+ * IPC (rates are USD per 1,000,000 tokens).
+ *
+ * **HONESTY GUARDRAILS** (the maintainer's explicit constraint):
+ * `ProviderRateService` self-documents these rates as PROJECTED API-equivalents
+ * — "what this run WOULD have cost on the API", not what was actually billed.
+ * Therefore:
+ *   (a) callers MUST only estimate when there is no explicit `cost_usd`, and
+ *   (b) an estimate MUST be badged as such (e.g. "~$0.0x est. API-equiv"),
+ *       never rendered as a bare currency string that implies money spent.
+ * This module returns the raw USD number only; the badging lives in the
+ * display layer (see `runCompleteSummary.ts`).
+ *
+ * Kept PURE + dependency-free so it's exhaustively unit-testable without an
+ * IPC harness. The (impure) one-shot fetch helper is the only window-touching
+ * export and is trivially mockable.
+ */
+
+import type { ProviderId } from '../../../main/store/types'
+
+/**
+ * Minimal renderer-side mirror of `ProviderRateService`'s `ModelRateEntry`.
+ * The preload types `getProviderRates()` as `unknown` (the concrete shape
+ * lives main-side), so we narrow to just the fields the estimator needs and
+ * stay defensive about everything else.
+ */
+export interface RendererModelRate {
+  modelId: string
+  inputUsdPerMillion: number
+  outputUsdPerMillion: number
+}
+
+/** Per-provider rate table, keyed by provider id. Partial because a snapshot
+ * may omit providers (e.g. Cursor ships an empty model list). */
+export type RendererProviderRates = Partial<Record<ProviderId, RendererModelRate[]>>
+
+const isFiniteNonNeg = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value >= 0
+
+/**
+ * Narrow the loosely-typed `providerRates:get` IPC payload into a
+ * {@link RendererProviderRates} map. Tolerant of the full
+ * `ProviderRatesSnapshot` envelope (`{ baseline: { <provider>: { models } } }`)
+ * as well as already-unwrapped shapes. Returns `{}` on anything unexpected so
+ * a malformed snapshot can never break the estimator or rendering.
+ */
+export function normalizeProviderRates(raw: unknown): RendererProviderRates {
+  if (!raw || typeof raw !== 'object') return {}
+  // The IPC returns the full snapshot; the per-provider tables live under
+  // `.baseline`. Fall back to treating `raw` itself as the table map for
+  // forward/backward compatibility.
+  const envelope = raw as Record<string, unknown>
+  const tables =
+    envelope.baseline && typeof envelope.baseline === 'object'
+      ? (envelope.baseline as Record<string, unknown>)
+      : envelope
+  const out: RendererProviderRates = {}
+  for (const [provider, table] of Object.entries(tables)) {
+    if (!table || typeof table !== 'object') continue
+    const models = (table as Record<string, unknown>).models
+    if (!Array.isArray(models)) continue
+    const entries: RendererModelRate[] = []
+    for (const model of models) {
+      if (!model || typeof model !== 'object') continue
+      const m = model as Record<string, unknown>
+      if (
+        typeof m.modelId === 'string' &&
+        isFiniteNonNeg(m.inputUsdPerMillion) &&
+        isFiniteNonNeg(m.outputUsdPerMillion)
+      ) {
+        entries.push({
+          modelId: m.modelId,
+          inputUsdPerMillion: m.inputUsdPerMillion,
+          outputUsdPerMillion: m.outputUsdPerMillion
+        })
+      }
+    }
+    if (entries.length > 0) out[provider as ProviderId] = entries
+  }
+  return out
+}
+
+/**
+ * Resolve a rate entry for a (provider, model) pair. Matches the model id
+ * exactly first, then by case-insensitive prefix (CLIs sometimes report
+ * `gpt-5.5-2026-xx` where the table keys `gpt-5.5`), then falls back to the
+ * provider's first/cheapest-listed model so a known provider still yields a
+ * ballpark rather than nothing. Returns `null` when the provider is unknown
+ * or has no rates (e.g. Cursor's empty list).
+ */
+export function resolveModelRate(
+  rates: RendererProviderRates,
+  provider: ProviderId | undefined,
+  model: string | undefined
+): RendererModelRate | null {
+  if (!provider) return null
+  const table = rates[provider]
+  if (!table || table.length === 0) return null
+  const wanted = (model || '').trim().toLowerCase()
+  if (wanted) {
+    const exact = table.find((r) => r.modelId.toLowerCase() === wanted)
+    if (exact) return exact
+    const prefix = table.find(
+      (r) =>
+        wanted.startsWith(r.modelId.toLowerCase()) || r.modelId.toLowerCase().startsWith(wanted)
+    )
+    if (prefix) return prefix
+  }
+  return table[0]
+}
+
+/**
+ * Pure estimate: project the USD API-equivalent cost of `inputTokens` /
+ * `outputTokens` for one (provider, model) pair using the rate table.
+ *
+ * Returns `0` when the provider/model can't be resolved or both token counts
+ * are zero — callers treat `<= 0` as "no estimate available" and render
+ * nothing rather than a misleading `$0.00`.
+ */
+export function estimateRunCostUsd(
+  rates: RendererProviderRates,
+  provider: ProviderId | undefined,
+  model: string | undefined,
+  inputTokens: number,
+  outputTokens: number
+): number {
+  const rate = resolveModelRate(rates, provider, model)
+  if (!rate) return 0
+  const inTok = isFiniteNonNeg(inputTokens) ? inputTokens : 0
+  const outTok = isFiniteNonNeg(outputTokens) ? outputTokens : 0
+  if (inTok === 0 && outTok === 0) return 0
+  const usd =
+    (inTok / 1_000_000) * rate.inputUsdPerMillion + (outTok / 1_000_000) * rate.outputUsdPerMillion
+  return Number.isFinite(usd) && usd > 0 ? usd : 0
+}
+
+/**
+ * One-shot fetch of the provider rate snapshot over the existing
+ * `providerRates:get` IPC, narrowed to {@link RendererProviderRates}. The only
+ * impure export. Returns `{}` (never throws) when the API is unavailable or
+ * the call fails, so the estimator degrades to "no estimate" gracefully.
+ */
+export async function fetchProviderRates(): Promise<RendererProviderRates> {
+  try {
+    const api = (globalThis as { api?: { getProviderRates?: () => Promise<unknown> } }).api
+    if (typeof api?.getProviderRates !== 'function') return {}
+    const raw = await api.getProviderRates()
+    return normalizeProviderRates(raw)
+  } catch {
+    return {}
+  }
+}
diff --git a/src/renderer/src/lib/runCompleteSummary.test.ts b/src/renderer/src/lib/runCompleteSummary.test.ts
index 8694f2ff..aa1b9fd3 100644
--- a/src/renderer/src/lib/runCompleteSummary.test.ts
+++ b/src/renderer/src/lib/runCompleteSummary.test.ts
@@ -1,6 +1,13 @@
 import { describe, expect, it } from 'vitest'
-import type { ChatRecord } from '../../../main/store/types'
-import { buildEnsembleRoundSummaryRows, buildRoundOutcomeRows } from './runCompleteSummary'
+import type { ChatRecord, ChatRun } from '../../../main/store/types'
+import {
+  buildEnsembleRoundCostRow,
+  buildEnsembleRoundSummaryRows,
+  buildEscalationChips,
+  buildRoundOutcomeRows
+} from './runCompleteSummary'
+import type { ComplexityEscalationSignal } from '../../../main/store/types'
+import type { RendererProviderRates } from './providerRateEstimate'
 
 // activeRound.participants is all buildRoundOutcomeRows reads; a partial cast
 // keeps the fixture focused on status outcomes.
@@ -68,4 +75,219 @@ describe('buildEnsembleRoundSummaryRows', () => {
     expect(labels).toContain('Skipped')
     expect(labels.indexOf('Contributed')).toBe(labels.indexOf('Status') + 1)
   })
+
+  it('labels the round wall-clock row "Latency" (not "Duration")', () => {
+    const chat = {
+      chatKind: 'ensemble',
+      runs: [],
+      ensemble: {
+        activeRound: {
+          roundId: 'r1',
+          participants: [],
+          startedAt: '2026-06-04T10:00:00.000Z',
+          endedAt: '2026-06-04T10:00:30.000Z'
+        }
+      }
+    } as unknown as ChatRecord
+    const labels = buildEnsembleRoundSummaryRows(chat, false).map((r) => r.label)
+    expect(labels).toContain('Latency')
+    expect(labels).not.toContain('Duration')
+    const latency = buildEnsembleRoundSummaryRows(chat, false).find((r) => r.label === 'Latency')
+    expect(latency?.value).toBe('30s')
+  })
+
+  it('threads cost options through to a Cost row', () => {
+    const chat = {
+      chatKind: 'ensemble',
+      runs: [run({ provider: 'claude', stats: { cost_usd: 0.5 } })],
+      ensemble: { activeRound: { roundId: 'r1', participants: [] } }
+    } as unknown as ChatRecord
+    const cost = buildEnsembleRoundSummaryRows(chat, false, { currency: 'USD' }).find(
+      (r) => r.label === 'Cost'
+    )
+    expect(cost?.value).toBe('$0.50')
+  })
+})
+
+// A run belonging to round r1, with overridable provider/model/stats. Only the
+// fields the cost row reads matter; cast keeps the fixture focused.
+function run(partial: Partial<ChatRun>): ChatRun {
+  return {
+    runId: Math.random().toString(36).slice(2),
+    ensembleRoundId: 'r1',
+    ...partial
+  } as ChatRun
+}
+
+const ESTIMATE_RATES: RendererProviderRates = {
+  codex: [{ modelId: 'gpt-5.5', inputUsdPerMillion: 1.25, outputUsdPerMillion: 10.0 }],
+  cursor: []
+}
+
+describe('buildEnsembleRoundCostRow', () => {
+  it('sums explicit cost_usd across runs into a plain currency string', () => {
+    const row = buildEnsembleRoundCostRow(
+      [run({ provider: 'claude', stats: { cost_usd: 0.5 } }), run({ stats: { cost_usd: 0.25 } })],
+      { currency: 'USD' }
+    )
+    expect(row).toEqual({ label: 'Cost', value: '$0.75' })
+  })
+
+  it('returns null when there is no real cost AND no estimate', () => {
+    // Codex run with no cost_usd and no rate table → nothing to show.
+    expect(buildEnsembleRoundCostRow([run({ provider: 'codex', stats: {} })], {})).toBeNull()
+    expect(buildEnsembleRoundCostRow([], {})).toBeNull()
+  })
+
+  it('projects a clearly-badged API-equivalent estimate for subscription seats', () => {
+    // Codex emits no cost_usd → estimate from tokens:
+    // 1,000,000 in * $1.25/M + 100,000 out * $10/M = 1.25 + 1.00 = $2.25
+    const row = buildEnsembleRoundCostRow(
+      [
+        run({
+          provider: 'codex',
+          actualModel: 'gpt-5.5',
+          stats: { input_tokens: 1_000_000, output_tokens: 100_000 }
+        })
+      ],
+      { currency: 'USD', providerRates: ESTIMATE_RATES }
+    )
+    expect(row?.label).toBe('Cost')
+    // Badged with leading ~ AND the est. API-equiv qualifier — never a bare $.
+    expect(row?.value).toBe('~$2.25 est. API-equiv')
+  })
+
+  it('shows real + estimate together when seats are mixed, keeping the estimate badged', () => {
+    const row = buildEnsembleRoundCostRow(
+      [
+        run({ provider: 'claude', stats: { cost_usd: 0.5 } }),
+        run({
+          provider: 'codex',
+          actualModel: 'gpt-5.5',
+          stats: { input_tokens: 1_000_000, output_tokens: 0 }
+        })
+      ],
+      { currency: 'USD', providerRates: ESTIMATE_RATES }
+    )
+    // Real $0.50 + projected $1.25 (1M in * $1.25/M), estimate still badged.
+    expect(row?.value).toBe('$0.50 + ~$1.25 est. API-equiv')
+  })
+
+  it('never estimates a seat that already reported cost_usd', () => {
+    // Even with a rate table present + tokens, an explicit cost wins and no
+    // "est." badge appears.
+    const row = buildEnsembleRoundCostRow(
+      [
+        run({
+          provider: 'codex',
+          actualModel: 'gpt-5.5',
+          stats: { cost_usd: 3, input_tokens: 1_000_000, output_tokens: 1_000_000 }
+        })
+      ],
+      { currency: 'USD', providerRates: ESTIMATE_RATES }
+    )
+    expect(row?.value).toBe('$3.00')
+    expect(row?.value).not.toContain('est.')
+  })
+
+  it('does not estimate Cursor (empty rate list) and shows nothing for a pure subscription round with no rates', () => {
+    const row = buildEnsembleRoundCostRow(
+      [run({ provider: 'cursor', stats: { input_tokens: 500_000, output_tokens: 500_000 } })],
+      { currency: 'USD', providerRates: ESTIMATE_RATES }
+    )
+    expect(row).toBeNull()
+  })
+
+  it('honours the display currency for the real-cost path', () => {
+    const row = buildEnsembleRoundCostRow([run({ provider: 'claude', stats: { cost_usd: 1 } })], {
+      currency: 'GBP'
+    })
+    // £ symbol present (GBP); exact figure depends on the FX table.
+    expect(row?.value).toMatch(/£/)
+  })
+})
+
+function sig(partial: Partial<ComplexityEscalationSignal>): ComplexityEscalationSignal {
+  return {
+    id: partial.id || Math.random().toString(36).slice(2),
+    chatId: 'c1',
+    roundId: 'r1',
+    kind: 'stuck',
+    evidence: 'because',
+    recommendedAction: 'pause-for-user',
+    createdAt: '2026-06-04T10:00:00.000Z',
+    ...partial
+  }
+}
+
+function chatWithSignals(
+  signals: ComplexityEscalationSignal[],
+  roundId: string | null = 'r1'
+): ChatRecord {
+  return {
+    chatKind: 'ensemble',
+    runs: [],
+    ensemble: {
+      ...(roundId ? { activeRound: { roundId, participants: [] } } : {}),
+      escalationSignals: signals
+    }
+  } as unknown as ChatRecord
+}
+
+describe('buildEscalationChips', () => {
+  it('returns [] when there is no active round or no signals', () => {
+    expect(buildEscalationChips(null)).toEqual([])
+    expect(buildEscalationChips(chatWithSignals([], null))).toEqual([])
+    expect(buildEscalationChips(chatWithSignals([sig({ kind: 'stuck' })], null))).toEqual([])
+    expect(buildEscalationChips(chatWithParticipants([]))).toEqual([])
+  })
+
+  it('maps kind + recommendedAction to label/action/tone for the current round', () => {
+    const chips = buildEscalationChips(
+      chatWithSignals([
+        sig({ id: 's1', kind: 'disagreement-unresolved', recommendedAction: 'call-synthesizer' })
+      ])
+    )
+    expect(chips).toEqual([
+      {
+        id: 's1',
+        label: 'Unreconciled answers',
+        action: 'Add a synthesizer to reconcile the answers.',
+        tone: 'info'
+      }
+    ])
+  })
+
+  it('marks failure-shaped signals as attention tone', () => {
+    const chips = buildEscalationChips(
+      chatWithSignals([
+        sig({ id: 's1', kind: 'tool-error-cluster', recommendedAction: 'pause-for-user' })
+      ])
+    )
+    expect(chips[0].tone).toBe('attention')
+    expect(chips[0].label).toBe('Tool errors clustered')
+  })
+
+  it('only surfaces signals for the active round and de-dups by kind', () => {
+    const chips = buildEscalationChips(
+      chatWithSignals([
+        sig({ id: 'old', kind: 'stuck', roundId: 'r0' }), // previous round — excluded
+        sig({ id: 'a', kind: 'stuck' }),
+        sig({ id: 'b', kind: 'stuck' }) // dup kind — collapsed
+      ])
+    )
+    expect(chips).toHaveLength(1)
+    expect(chips[0].id).toBe('a')
+  })
+
+  it('never frames panel size as waste — copy leans into the panel', () => {
+    const chips = buildEscalationChips(
+      chatWithSignals([
+        sig({ id: '1', kind: 'disagreement-unresolved', recommendedAction: 'call-synthesizer' }),
+        sig({ id: '2', kind: 'looping', recommendedAction: 'extend-rounds' })
+      ])
+    )
+    const allCopy = chips.map((c) => `${c.label} ${c.action}`).join(' ')
+    expect(allCopy.toLowerCase()).not.toMatch(/too many|waste|fewer seats|reduce/)
+  })
 })
diff --git a/src/renderer/src/lib/runCompleteSummary.ts b/src/renderer/src/lib/runCompleteSummary.ts
index c6cd7db8..523672f1 100644
--- a/src/renderer/src/lib/runCompleteSummary.ts
+++ b/src/renderer/src/lib/runCompleteSummary.ts
@@ -1,12 +1,115 @@
-import type { ChatRecord, ChatRun, EnsembleRoundParticipantState } from '../../../main/store/types'
+import type {
+  ChatRecord,
+  ChatRun,
+  ComplexityEscalationAction,
+  ComplexityEscalationKind,
+  ComplexityEscalationSignal,
+  EnsembleRoundParticipantState
+} from '../../../main/store/types'
 import { formatContextTokens } from './contextWindows'
-import { extractUsageCount, extractUsageCountsFromCandidate } from './usageStats'
+import { formatCostAlwaysOn, type DisplayCurrency } from './formatCost'
+import { estimateRunCostUsd, type RendererProviderRates } from './providerRateEstimate'
+import {
+  extractUsageCount,
+  extractUsageCostUsd,
+  extractUsageCountsFromCandidate
+} from './usageStats'
 
 export type RunCompleteSummaryRow = {
   label: string
   value: string
 }
 
+/**
+ * 1.0.7 — Cost-display inputs threaded into the (otherwise pure) ensemble
+ * round summary builder so it can render a currency-aware Cost row + a
+ * projected token->USD estimate for subscription/credit seats. All optional:
+ * omitting them reproduces the pre-1.0.7 behaviour (no Cost row).
+ *
+ * - `currency` / `overestimatePercent`: the user's Settings → General
+ *   preferences, already plumbed to the transcript.
+ * - `providerRates`: the per-provider rate table from the `providerRates:get`
+ *   IPC (USD per 1M tokens). Used ONLY to estimate seats that emit no
+ *   `cost_usd`. Absent/empty → no estimate, just real cost (which may be
+ *   blank for subscription seats).
+ */
+export type EnsembleRoundSummaryCostOptions = {
+  currency?: DisplayCurrency
+  overestimatePercent?: number
+  providerRates?: RendererProviderRates
+}
+
+/**
+ * 1.0.7 — Build the Cost row for a finished ensemble round, kept PURE so the
+ * estimator math + honesty badging are exhaustively testable.
+ *
+ * Two USD figures are accumulated separately across the round's runs:
+ *   - `realUsd`: the sum of explicit `cost_usd` the provider actually
+ *     reported (per-token API seats: Claude / Gemini / Kimi).
+ *   - `estUsd`: a PROJECTED API-equivalent for runs that reported NO
+ *     `cost_usd` (subscription / credit seats: Codex / Grok / Cursor),
+ *     derived from summed tokens × the provider rate table.
+ *
+ * HONESTY GUARDRAILS (the maintainer's explicit constraint —
+ * ProviderRateService self-documents its rates as projected, not billed):
+ *   (a) a run is only estimated when it has no explicit cost_usd, and
+ *   (b) any estimated component is badged "est. API-equiv" (with a leading
+ *       "~" on a fully-estimated row), NEVER rendered as a bare currency
+ *       string that implies money was spent.
+ *
+ * Returns `null` when there's nothing to show (no real cost AND no estimate)
+ * so the caller omits the row entirely rather than printing a misleading
+ * `$0.00`. When only real cost exists it's a plain currency string; when only
+ * an estimate exists it's `~<amount> est. API-equiv`; a mix shows both.
+ */
+export const buildEnsembleRoundCostRow = (
+  roundRuns: ChatRun[],
+  options: EnsembleRoundSummaryCostOptions
+): RunCompleteSummaryRow | null => {
+  const currency: DisplayCurrency = options.currency || 'USD'
+  const overestimate = options.overestimatePercent ?? 0
+  const rates = options.providerRates || {}
+
+  let realUsd = 0
+  let estUsd = 0
+  for (const run of roundRuns) {
+    const explicit = extractUsageCostUsd(run.stats)
+    if (explicit > 0) {
+      // Per-token seat reported real spend — never override with an estimate.
+      realUsd += explicit
+      continue
+    }
+    // No explicit cost (subscription / credit seat) — project from tokens.
+    const counts = extractUsageCountsFromCandidate(run.stats)
+    const model = run.actualModel || run.requestedModel
+    estUsd += estimateRunCostUsd(
+      rates,
+      run.provider,
+      model,
+      counts.inputTokens,
+      counts.outputTokens
+    )
+  }
+
+  if (realUsd <= 0 && estUsd <= 0) return null
+
+  if (estUsd <= 0) {
+    // Pure real cost — plain currency string.
+    return { label: 'Cost', value: formatCostAlwaysOn(realUsd, currency, undefined, overestimate) }
+  }
+
+  const estText = `~${formatCostAlwaysOn(estUsd, currency, undefined, overestimate)} est. API-equiv`
+  if (realUsd <= 0) {
+    // Pure estimate — badge it unmistakably as projected, not billed.
+    return { label: 'Cost', value: estText }
+  }
+  // Mix of real + estimated seats — show both, keep the estimate badged.
+  return {
+    label: 'Cost',
+    value: `${formatCostAlwaysOn(realUsd, currency, undefined, overestimate)} + ${estText}`
+  }
+}
+
 export const formatWorkDuration = (startedAt?: string, completedAt?: string): string | null => {
   if (!startedAt || !completedAt) {
     return null
@@ -152,7 +255,8 @@ export const buildRoundOutcomeRows = (chat: ChatRecord | null): RunCompleteSumma
  */
 export const buildEnsembleRoundSummaryRows = (
   chat: ChatRecord | null,
-  cancelled: boolean
+  cancelled: boolean,
+  costOptions: EnsembleRoundSummaryCostOptions = {}
 ): RunCompleteSummaryRow[] => {
   const round = chat?.ensemble?.activeRound
   if (!round) return []
@@ -195,12 +299,15 @@ export const buildEnsembleRoundSummaryRows = (
   // panel's round-close "who passed / skipped / failed" ask.
   rows.push(...buildRoundOutcomeRows(chat))
 
-  // Round-envelope duration.
+  // Round-envelope wall-clock — the time the user actually waited for the
+  // round to close. Labelled "Latency" (its own distinct row) so it reads
+  // clearly alongside the Cost row below; this is end-to-end round latency,
+  // not summed per-participant compute time.
   const startedAtMs = round.startedAt ? new Date(round.startedAt).getTime() : NaN
   const endedAtMs = round.endedAt ? new Date(round.endedAt).getTime() : Date.now()
   if (Number.isFinite(startedAtMs) && endedAtMs > startedAtMs) {
     rows.push({
-      label: 'Duration',
+      label: 'Latency',
       value: formatCompactDurationMs(endedAtMs - startedAtMs)
     })
   }
@@ -223,5 +330,85 @@ export const buildEnsembleRoundSummaryRows = (
     rows.push({ label: 'Total', value: `${formatContextTokens(totalTokens)} tokens` })
   }
 
+  // Cost — real provider-reported spend plus a clearly-badged projected
+  // API-equivalent for subscription/credit seats that emit no cost_usd.
+  const costRow = buildEnsembleRoundCostRow(roundRuns, costOptions)
+  if (costRow) rows.push(costRow)
+
   return rows
 }
+
+/**
+ * 1.0.7 (M5 surfacing) — presentation model for one complexity-escalation
+ * signal. The orchestrator already computes + persists these every round
+ * (`chat.ensemble.escalationSignals`); they were dark-shipped and rendered
+ * nowhere. This is a PURE mapping from the stored signal to the copy an
+ * advisory chip renders — short label + a one-line recommended next step.
+ *
+ * FRAMING (the maintainer's explicit constraint): these are advisory only —
+ * the orchestrator never auto-acts. The copy makes a tradeoff VISIBLE so the
+ * user decides; it must never frame a multi-seat panel as waste. Note the
+ * recommended action for `disagreement-unresolved` is to ADD a synthesizer to
+ * reconcile — i.e. lean INTO the panel, not shrink it.
+ */
+export type EscalationChipModel = {
+  id: string
+  /** Short human label for the signal kind. */
+  label: string
+  /** One-line recommended next step (advisory). */
+  action: string
+  /** Coarse tone for styling — failures read warmer than advisories. */
+  tone: 'attention' | 'info'
+}
+
+const ESCALATION_KIND_LABEL: Record<ComplexityEscalationKind, string> = {
+  stuck: 'Round stalled',
+  looping: 'Handoffs exhausted',
+  'disagreement-unresolved': 'Unreconciled answers',
+  'tool-error-cluster': 'Tool errors clustered'
+}
+
+const ESCALATION_KIND_TONE: Record<ComplexityEscalationKind, EscalationChipModel['tone']> = {
+  stuck: 'attention',
+  looping: 'info',
+  'disagreement-unresolved': 'info',
+  'tool-error-cluster': 'attention'
+}
+
+const ESCALATION_ACTION_COPY: Record<ComplexityEscalationAction, string> = {
+  // Lean into the panel — never frame more seats as waste.
+  'extend-rounds': 'Consider another round to converge.',
+  'call-synthesizer': 'Add a synthesizer to reconcile the answers.',
+  'pause-for-user': 'Your input would help unblock this.'
+}
+
+/**
+ * Map the signals persisted on a chat's ensemble state to chip view-models
+ * for the CURRENT round only (signals carry their originating `roundId`).
+ * De-duplicates by signal kind (the orchestrator already uses deterministic
+ * `${roundId}-esc-${kind}` ids, but a defensive de-dup keeps the chip strip
+ * tidy). Returns [] when there's no active round or no signals — the caller
+ * renders nothing.
+ *
+ * Pure + side-effect-free so the kind/action copy + filtering are unit-tested
+ * without a render harness.
+ */
+export const buildEscalationChips = (chat: ChatRecord | null): EscalationChipModel[] => {
+  const round = chat?.ensemble?.activeRound
+  const signals = chat?.ensemble?.escalationSignals
+  if (!round || !signals || signals.length === 0) return []
+  const seenKinds = new Set<ComplexityEscalationKind>()
+  const chips: EscalationChipModel[] = []
+  for (const signal of signals as ComplexityEscalationSignal[]) {
+    if (signal.roundId !== round.roundId) continue
+    if (seenKinds.has(signal.kind)) continue
+    seenKinds.add(signal.kind)
+    chips.push({
+      id: signal.id,
+      label: ESCALATION_KIND_LABEL[signal.kind] || signal.kind,
+      action: ESCALATION_ACTION_COPY[signal.recommendedAction] || '',
+      tone: ESCALATION_KIND_TONE[signal.kind] || 'info'
+    })
+  }
+  return chips
+}
diff --git a/src/renderer/src/lib/sessionActivityLedger.test.ts b/src/renderer/src/lib/sessionActivityLedger.test.ts
index e74dda5b..a76a5fd0 100644
--- a/src/renderer/src/lib/sessionActivityLedger.test.ts
+++ b/src/renderer/src/lib/sessionActivityLedger.test.ts
@@ -1,6 +1,14 @@
 import { describe, expect, it } from 'vitest'
-import type { ChatRecord, EnsembleParticipant } from '../../../main/store/types'
-import { withSessionActivityLedger } from './sessionActivityLedger'
+import type {
+  ChatMessage,
+  ChatRecord,
+  EnsembleParticipant,
+  SessionActivityLedgerEntry
+} from '../../../main/store/types'
+import {
+  deriveParticipantRenameContinuity,
+  withSessionActivityLedger
+} from './sessionActivityLedger'
 
 function participant(overrides: Partial<EnsembleParticipant> = {}): EnsembleParticipant {
   return {
@@ -99,3 +107,125 @@ describe('sessionActivityLedger', () => {
     expect(updated.ensemble?.sessionActivityLedger).toBeUndefined()
   })
 })
+
+/*
+ * 1.0.7 — participant-rename continuity for the transcript. A small
+ * "renamed from X" note that lets a reader follow one seat across a
+ * mid-session role rename. Ledger-preferred with a frozen-vs-current
+ * fallback; never mutates the frozen `ensembleRole`.
+ */
+describe('deriveParticipantRenameContinuity', () => {
+  function assistantMsg(overrides: Partial<ChatMessage['metadata']> = {}): ChatMessage {
+    return {
+      id: 'a1',
+      role: 'assistant',
+      content: 'Prior turn.',
+      timestamp: '2026-05-27T00:00:00.000Z',
+      metadata: {
+        ensembleProvider: 'claude',
+        ensembleRole: 'Planner',
+        ensembleParticipantId: 'p1',
+        ...overrides
+      }
+    }
+  }
+
+  const renameEntry = (
+    overrides: Partial<SessionActivityLedgerEntry> = {}
+  ): SessionActivityLedgerEntry => ({
+    id: 'e1',
+    timestamp: '2026-05-27T00:01:00.000Z',
+    changedBy: 'user',
+    scope: 'participant',
+    target: 'p1',
+    oldValue: 'Claude / Planner',
+    newValue: 'Claude / Architect',
+    reason: 'Participant role/name changed.',
+    ...overrides
+  })
+
+  it('returns null when the message is not an ensemble assistant message', () => {
+    const roster = [participant({ id: 'p1', role: 'Architect' })]
+    expect(
+      deriveParticipantRenameContinuity(
+        { role: 'user', metadata: { ensembleParticipantId: 'p1' } },
+        roster,
+        []
+      )
+    ).toBeNull()
+  })
+
+  it('returns null when the frozen role matches the current role', () => {
+    const roster = [participant({ id: 'p1', role: 'Planner' })]
+    expect(deriveParticipantRenameContinuity(assistantMsg(), roster, [])).toBeNull()
+  })
+
+  it('falls back to frozen-vs-current when the ledger has no matching entry', () => {
+    // Ledger empty (rename aged out) — the frozen role drives the note.
+    const roster = [participant({ id: 'p1', role: 'Architect' })]
+    const result = deriveParticipantRenameContinuity(assistantMsg(), roster, [])
+    expect(result).toEqual({ fromRole: 'Planner', currentRole: 'Architect' })
+  })
+
+  it('prefers the ledger entry when present and consistent with the frozen role', () => {
+    const roster = [participant({ id: 'p1', role: 'Architect' })]
+    const result = deriveParticipantRenameContinuity(assistantMsg(), roster, [renameEntry()])
+    expect(result).toEqual({ fromRole: 'Planner', currentRole: 'Architect' })
+  })
+
+  it('uses the ledger old role when the message carries no frozen role', () => {
+    // Older transcript row predating the ensembleRole stamp.
+    const roster = [participant({ id: 'p1', role: 'Architect' })]
+    const msg = assistantMsg({ ensembleRole: undefined })
+    const result = deriveParticipantRenameContinuity(msg, roster, [renameEntry()])
+    expect(result).toEqual({ fromRole: 'Planner', currentRole: 'Architect' })
+  })
+
+  it('ignores a stale intermediate ledger rename that does not land on the current role', () => {
+    // Seat renamed Planner→Architect, then Architect→Lead. Current is
+    // Lead. The Planner→Architect entry must NOT mislabel this. The
+    // message frozen as "Planner" should report the per-message-
+    // accurate frozen role as the "from".
+    const roster = [participant({ id: 'p1', role: 'Lead' })]
+    const ledger = [
+      renameEntry({ id: 'e1', oldValue: 'Claude / Planner', newValue: 'Claude / Architect' }),
+      renameEntry({ id: 'e2', oldValue: 'Claude / Architect', newValue: 'Claude / Lead' })
+    ]
+    const result = deriveParticipantRenameContinuity(assistantMsg(), roster, ledger)
+    expect(result).toEqual({ fromRole: 'Planner', currentRole: 'Lead' })
+  })
+
+  it('returns null when the participant id is not in the current roster', () => {
+    const roster = [participant({ id: 'other', role: 'Architect' })]
+    expect(deriveParticipantRenameContinuity(assistantMsg(), roster, [renameEntry()])).toBeNull()
+  })
+
+  it('does not fire for a rename-then-rename-back to the original name', () => {
+    // Planner→Architect→Planner. A message frozen as the original
+    // "Planner" matches the current name again → no confusing note.
+    const roster = [participant({ id: 'p1', role: 'Planner' })]
+    const ledger = [
+      renameEntry({ id: 'e1', oldValue: 'Claude / Planner', newValue: 'Claude / Architect' }),
+      renameEntry({ id: 'e2', oldValue: 'Claude / Architect', newValue: 'Claude / Planner' })
+    ]
+    expect(deriveParticipantRenameContinuity(assistantMsg(), roster, ledger)).toBeNull()
+  })
+
+  it('ignores non-rename participant events sharing the seat', () => {
+    // A permission-preset entry (target is the LABEL, not the id) must
+    // not be mistaken for a rename. With an empty role-rename history
+    // the frozen-vs-current fallback still drives the note.
+    const roster = [participant({ id: 'p1', role: 'Architect' })]
+    const ledger = [
+      renameEntry({
+        id: 'perm',
+        target: 'Claude / Planner permission preset',
+        oldValue: 'read_only',
+        newValue: 'workspace_write',
+        reason: 'Participant permission preset changed.'
+      })
+    ]
+    const result = deriveParticipantRenameContinuity(assistantMsg(), roster, ledger)
+    expect(result).toEqual({ fromRole: 'Planner', currentRole: 'Architect' })
+  })
+})
diff --git a/src/renderer/src/lib/sessionActivityLedger.ts b/src/renderer/src/lib/sessionActivityLedger.ts
index 936a8f9c..00fcce08 100644
--- a/src/renderer/src/lib/sessionActivityLedger.ts
+++ b/src/renderer/src/lib/sessionActivityLedger.ts
@@ -1,4 +1,5 @@
 import type {
+  ChatMessage,
   ChatRecord,
   EnsembleConfig,
   EnsembleParticipant,
@@ -185,3 +186,113 @@ function normalizedRole(participant: EnsembleParticipant): string {
 function nextSessionActivityId(): string {
   return `session-event-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`
 }
+
+/**
+ * 1.0.7 — participant-rename continuity for the transcript.
+ *
+ * An assistant message freezes the role its author held at the time
+ * (`metadata.ensembleRole`). When the user later renames that seat
+ * ("Planner" → "Architect"), a reader scrolling the transcript can't
+ * tell the earlier "Planner" message and the seat now called
+ * "Architect" are the SAME participant. This derives a quiet
+ * "renamed from <role>" continuity note for such a message.
+ *
+ * Resolution order (per the dogfood-triage spec):
+ *   1. PREFER the session-activity ledger's explicit old→new rename
+ *      entry for this participant id, when one is still present (the
+ *      ledger is the authoritative record of the transition, with a
+ *      reason string). We require the entry's recorded NEW role to
+ *      match the seat's CURRENT role so a stale intermediate rename
+ *      (Planner→Architect, then Architect→Lead) doesn't mislabel a
+ *      Lead seat as "renamed from Planner".
+ *   2. FALLBACK (required — the ledger is capped/sliced, so a rename
+ *      can age out): compare the message's FROZEN role against the
+ *      participant's CURRENT role looked up by id. If they differ,
+ *      still surface the note using the frozen role as the "from".
+ *
+ * Returns `null` when there's nothing to show (no id, no current
+ * seat, roles match, or the message isn't an ensemble assistant
+ * message). The frozen `ensembleRole` on the message is never
+ * mutated — this is a read-only derivation for display.
+ */
+export interface ParticipantRenameContinuity {
+  /** The role the message was authored under (or the ledger's
+   * recorded prior role) — the "renamed from X" value. */
+  fromRole: string
+  /** The participant's current role — useful for a tooltip/aria
+   * ("Now: Architect"). */
+  currentRole: string
+}
+
+export function deriveParticipantRenameContinuity(
+  message: Pick<ChatMessage, 'role' | 'metadata'>,
+  participants: readonly EnsembleParticipant[] | undefined,
+  ledger: readonly SessionActivityLedgerEntry[] | undefined
+): ParticipantRenameContinuity | null {
+  if (message.role !== 'assistant' || !message.metadata) return null
+  const metadata = message.metadata
+  const participantId =
+    typeof metadata.ensembleParticipantId === 'string' ? metadata.ensembleParticipantId : ''
+  if (!participantId || !participants || participants.length === 0) return null
+  const current = participants.find((participant) => participant.id === participantId)
+  if (!current) return null
+  const currentRole = normalizedRole(current)
+  if (!currentRole) return null
+  const frozenRole = typeof metadata.ensembleRole === 'string' ? metadata.ensembleRole.trim() : ''
+
+  // A message authored under the seat's CURRENT name needs no note,
+  // even if the seat churned through other names and back — the label
+  // the reader sees already matches the live roster. This also guards
+  // the rename-then-rename-back case from a false positive.
+  if (frozenRole && frozenRole === currentRole) return null
+
+  // 1. Ledger-preferred. Scan newest→oldest for a role-rename entry
+  //    targeting this participant whose recorded NEW role equals the
+  //    current role. Its recorded OLD role is the authoritative
+  //    "from". Requiring the new role to match current stops a stale
+  //    intermediate rename (Planner→Architect, then Architect→Lead)
+  //    from mislabelling a Lead seat as "renamed from Planner".
+  if (ledger && ledger.length > 0) {
+    for (let i = ledger.length - 1; i >= 0; i -= 1) {
+      const entry = ledger[i]
+      if (entry.scope !== 'participant') continue
+      // Rename/provider-change entries target the raw participant id
+      // (other participant events target the label) — so this filter
+      // selects only identity-changing entries for this seat.
+      if (entry.target !== participantId) continue
+      const oldRole = roleFromLabel(entry.oldValue)
+      const newRole = roleFromLabel(entry.newValue)
+      if (!oldRole || !newRole) continue
+      if (newRole !== currentRole) continue
+      if (oldRole === currentRole) continue
+      // When the message carries a frozen role, only trust the ledger
+      // entry if it matches THIS message's transition; otherwise the
+      // frozen role is the per-message-accurate "from" (handled by the
+      // fallback below).
+      if (frozenRole && oldRole !== frozenRole) break
+      return { fromRole: oldRole, currentRole }
+    }
+  }
+
+  // 2. Fallback: frozen-vs-current compare (the required path when the
+  //    ledger has aged the rename out, or carries no matching entry).
+  if (frozenRole && frozenRole !== currentRole) {
+    return { fromRole: frozenRole, currentRole }
+  }
+  return null
+}
+
+/**
+ * Extract the role half of a "Provider / Role" ledger label. Ledger
+ * rename entries store oldValue/newValue as `participantLabel`
+ * output (e.g. "Claude / Explorer"); the role is the segment after
+ * the LAST " / " so provider names containing a slash (none today,
+ * but defensive) don't truncate the role. Returns '' when the label
+ * is empty/unparseable.
+ */
+function roleFromLabel(label: string | null | undefined): string {
+  const text = String(label || '').trim()
+  if (!text) return ''
+  const idx = text.lastIndexOf(' / ')
+  return idx >= 0 ? text.slice(idx + 3).trim() : text
+}
diff --git a/src/renderer/src/lib/typefaceOptions.test.ts b/src/renderer/src/lib/typefaceOptions.test.ts
index 2027ad64..6605780e 100644
--- a/src/renderer/src/lib/typefaceOptions.test.ts
+++ b/src/renderer/src/lib/typefaceOptions.test.ts
@@ -4,6 +4,7 @@ import {
   COMPOSER_FONT_OPTIONS,
   CUSTOM_FONT_SELECT_VALUE,
   FONT_STACKS,
+  LEGACY_AGBENCH_FONT_STACK,
   TRANSCRIPT_FONT_OPTIONS,
   getFontSelectValue,
   normalizeComposerFontFamily,
@@ -25,6 +26,7 @@ describe('typeface option lists', () => {
     expect(TRANSCRIPT_FONT_OPTIONS).not.toContainEqual(
       expect.objectContaining({ value: COMPOSER_FONT_MATCH_TRANSCRIPT })
     )
+    expect(FONT_STACKS.agbench).toContain('"Avenir Next", Avenir')
   })
 
   it('puts match-transcript first for composer options', () => {
@@ -44,6 +46,10 @@ describe('normalizeFontFamily', () => {
     expect(normalizeFontFamily(undefined, FONT_STACKS.system)).toBe(FONT_STACKS.system)
     expect(normalizeFontFamily('   ', FONT_STACKS.compact)).toBe(FONT_STACKS.compact)
   })
+
+  it('normalizes the old SF Pro AGBench default to the current default stack', () => {
+    expect(normalizeFontFamily(LEGACY_AGBENCH_FONT_STACK)).toBe(FONT_STACKS.agbench)
+  })
 })
 
 describe('composer font resolution', () => {
@@ -71,6 +77,12 @@ describe('getFontSelectValue', () => {
     )
   })
 
+  it('maps the old SF Pro AGBench default to the current default option', () => {
+    expect(getFontSelectValue(TRANSCRIPT_FONT_OPTIONS, LEGACY_AGBENCH_FONT_STACK)).toBe(
+      FONT_STACKS.agbench
+    )
+  })
+
   it('maps unknown custom stacks to the custom select value', () => {
     expect(getFontSelectValue(TRANSCRIPT_FONT_OPTIONS, '"Custom", sans-serif')).toBe(
       CUSTOM_FONT_SELECT_VALUE
diff --git a/src/renderer/src/lib/typefaceOptions.ts b/src/renderer/src/lib/typefaceOptions.ts
index a7a17262..27d4f72d 100644
--- a/src/renderer/src/lib/typefaceOptions.ts
+++ b/src/renderer/src/lib/typefaceOptions.ts
@@ -1,6 +1,9 @@
+export const LEGACY_AGBENCH_FONT_STACK =
+  '"SF Pro", "SF Pro Text", "SF Pro Display", -apple-system, BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", Roboto, Arial, sans-serif'
+
 export const FONT_STACKS = {
   agbench:
-    '"SF Pro", "SF Pro Text", "SF Pro Display", -apple-system, BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", Roboto, Arial, sans-serif',
+    '"Avenir Next", Avenir, system-ui, -apple-system, BlinkMacSystemFont, "SF Pro Text", "Segoe UI", sans-serif',
   compact: '-apple-system, BlinkMacSystemFont, "SF Pro Text", "Segoe UI", sans-serif',
   humanist:
     '"Avenir Next", "SF Pro Text", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
@@ -45,6 +48,7 @@ export function normalizeFontFamily(
 ): string {
   if (typeof value !== 'string') return fallback
   const trimmed = value.trim()
+  if (trimmed === LEGACY_AGBENCH_FONT_STACK) return FONT_STACKS.agbench
   return trimmed.length > 0 ? trimmed : fallback
 }
 
@@ -63,7 +67,10 @@ export function resolveComposerFontFamily(
 }
 
 export function getFontSelectValue(options: TypefaceOption[], value: string): string {
-  return options.some((option) => option.value === value) ? value : CUSTOM_FONT_SELECT_VALUE
+  const normalizedValue = normalizeFontFamily(value, value)
+  return options.some((option) => option.value === normalizedValue)
+    ? normalizedValue
+    : CUSTOM_FONT_SELECT_VALUE
 }
 
 export function quoteInstalledFontFamily(fontFamily: string): string {
diff --git a/src/renderer/src/styles/theme.css b/src/renderer/src/styles/theme.css
index 6d9e135d..b2177e7c 100644
--- a/src/renderer/src/styles/theme.css
+++ b/src/renderer/src/styles/theme.css
@@ -139,6 +139,32 @@
   --diff-del-text: #f08080;
   --diff-hunk: #5a8cff;
 
+  /* CodeMirror syntax + editor chrome (File Editor / popout).
+   * Defaults here are the original dark-mode palette so dark themes
+   * render IDENTICALLY to before var-ization. Light themes
+   * (light/citrus/mist/sage/alabaster) override these with a
+   * readable dark-on-light editor palette below. FileEditorPanel.tsx
+   * consumes these via `color: var(--cm-…)` inside its CodeMirror
+   * HighlightStyle + EditorView.theme — CodeMirror emits those
+   * declarations into a stylesheet, so the vars resolve at runtime
+   * and follow `data-theme` like any other token. */
+  --cm-keyword: #ff8fb3;
+  --cm-name: #f6f0ff;
+  --cm-property: #b9d7ff;
+  --cm-function: #8fd6ff;
+  --cm-type: #ffd27d;
+  --cm-number: #c7a6ff;
+  --cm-string: #9be69f;
+  --cm-regexp: #86e1d1;
+  --cm-comment: rgba(255, 255, 255, 0.42);
+  --cm-meta: #9aa7ff;
+  --cm-heading: #f4f7ff;
+  --cm-invalid: #ff8080;
+  --cm-gutter-bg: rgba(0, 0, 0, 0.18);
+  --cm-gutter-border: rgba(255, 255, 255, 0.06);
+  --cm-active-line: rgba(255, 255, 255, 0.045);
+  --cm-bracket-match: rgba(255, 255, 255, 0.12);
+
   /* Tool Activity */
   --tool-running: #5a8cff;
   --tool-success: #4cc38a;
@@ -228,6 +254,30 @@
   --theme-wash-soft: 8%;
   --theme-wash-medium: 13%;
   --theme-wash-strong: 18%;
+  /* Light-theme diff: dark text on faint tints (was bright-on-white). */
+  --diff-add-bg: rgba(12, 132, 82, 0.16);
+  --diff-add-text: #0a7f50;
+  --diff-del-bg: rgba(198, 52, 66, 0.16);
+  --diff-del-text: #bc2e3d;
+  --diff-hunk: #0550ae;
+  /* Light-editor syntax palette (muted VS Code / GitHub light).
+   * Dark-on-near-white with WCAG-ish contrast. */
+  --cm-keyword: #cf222e;
+  --cm-name: #1f2328;
+  --cm-property: #0550ae;
+  --cm-function: #8250df;
+  --cm-type: #953800;
+  --cm-number: #0a7c42;
+  --cm-string: #0a3069;
+  --cm-regexp: #116329;
+  --cm-comment: #6e7781;
+  --cm-meta: #8250df;
+  --cm-heading: #0550ae;
+  --cm-invalid: #cf222e;
+  --cm-gutter-bg: rgba(18, 21, 27, 0.05);
+  --cm-gutter-border: rgba(18, 21, 27, 0.10);
+  --cm-active-line: rgba(18, 21, 27, 0.045);
+  --cm-bracket-match: rgba(18, 21, 27, 0.12);
 }
 
 [data-theme="midnight"] {
@@ -372,6 +422,28 @@
   --theme-wash-soft: 8%;
   --theme-wash-medium: 13%;
   --theme-wash-strong: 18%;
+  /* Light-theme diff + editor palette (mist — teal-leaning). */
+  --diff-add-bg: rgba(12, 132, 82, 0.16);
+  --diff-add-text: #0a7f50;
+  --diff-del-bg: rgba(198, 52, 66, 0.16);
+  --diff-del-text: #bc2e3d;
+  --diff-hunk: #2e7180;
+  --cm-keyword: #b91c50;
+  --cm-name: #142127;
+  --cm-property: #0f6b78;
+  --cm-function: #7a52c8;
+  --cm-type: #8a4b14;
+  --cm-number: #0a7c42;
+  --cm-string: #0a4f5c;
+  --cm-regexp: #116329;
+  --cm-comment: #5a7077;
+  --cm-meta: #7a52c8;
+  --cm-heading: #2e7180;
+  --cm-invalid: #cf222e;
+  --cm-gutter-bg: rgba(18, 29, 35, 0.05);
+  --cm-gutter-border: rgba(18, 29, 35, 0.10);
+  --cm-active-line: rgba(18, 29, 35, 0.045);
+  --cm-bracket-match: rgba(18, 29, 35, 0.12);
 }
 
 [data-theme="sage"] {
@@ -414,6 +486,28 @@
   --theme-wash-soft: 8%;
   --theme-wash-medium: 13%;
   --theme-wash-strong: 18%;
+  /* Light-theme diff + editor palette (sage — green-leaning). */
+  --diff-add-bg: rgba(12, 132, 82, 0.16);
+  --diff-add-text: #0a7f50;
+  --diff-del-bg: rgba(198, 52, 66, 0.16);
+  --diff-del-text: #bc2e3d;
+  --diff-hunk: #4b7a4f;
+  --cm-keyword: #b5263b;
+  --cm-name: #16201a;
+  --cm-property: #2c6a8c;
+  --cm-function: #7a52c8;
+  --cm-type: #8a4b14;
+  --cm-number: #2f6f1f;
+  --cm-string: #0a3069;
+  --cm-regexp: #116329;
+  --cm-comment: #5f6f5f;
+  --cm-meta: #7a52c8;
+  --cm-heading: #4b7a4f;
+  --cm-invalid: #cf222e;
+  --cm-gutter-bg: rgba(22, 32, 22, 0.05);
+  --cm-gutter-border: rgba(22, 32, 22, 0.10);
+  --cm-active-line: rgba(22, 32, 22, 0.045);
+  --cm-bracket-match: rgba(22, 32, 22, 0.12);
 }
 
 [data-theme="graphite"] {
@@ -726,6 +820,30 @@
   --theme-wash-soft: 8%;
   --theme-wash-medium: 13%;
   --theme-wash-strong: 18%;
+  /* Light-theme diff (matches the alabaster popout override in
+   * 09-ensemble-work-session.css so the in-app diff viewer reads
+   * the same) + light-editor syntax palette. */
+  --diff-add-bg: rgba(12, 132, 82, 0.16);
+  --diff-add-text: #0a7f50;
+  --diff-del-bg: rgba(198, 52, 66, 0.16);
+  --diff-del-text: #bc2e3d;
+  --diff-hunk: #596174;
+  --cm-keyword: #cf222e;
+  --cm-name: #1f2328;
+  --cm-property: #0550ae;
+  --cm-function: #8250df;
+  --cm-type: #953800;
+  --cm-number: #0a7c42;
+  --cm-string: #0a3069;
+  --cm-regexp: #116329;
+  --cm-comment: #6e7781;
+  --cm-meta: #8250df;
+  --cm-heading: #0550ae;
+  --cm-invalid: #cf222e;
+  --cm-gutter-bg: rgba(18, 21, 27, 0.05);
+  --cm-gutter-border: rgba(18, 21, 27, 0.10);
+  --cm-active-line: rgba(18, 21, 27, 0.045);
+  --cm-bracket-match: rgba(18, 21, 27, 0.12);
   /* Cool halo wash — lavender/blue at very low alpha. The
    * polar inverse of obsidian's warm peach/copper halo. */
   --alabaster-halo-cool: rgba(120, 140, 200, 0.10);