diff --git a/.github/workflows/deepagent-code.yml b/.github/workflows/deepagent-code.yml
index 9a117e8a..0eab6d2e 100644
--- a/.github/workflows/deepagent-code.yml
+++ b/.github/workflows/deepagent-code.yml
@@ -26,7 +26,7 @@ jobs:
       - uses: ./.github/actions/setup-bun
 
       - name: Run deepagent-code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           DEEPAGENT_CODE_API_KEY: ${{ secrets.DEEPAGENT_CODE_API_KEY }}
           DEEPAGENT_CODE_PERMISSION: '{"bash": "deny"}'
diff --git a/.github/workflows/docs-update.yml b/.github/workflows/docs-update.yml
index d503a9f2..b707db2a 100644
--- a/.github/workflows/docs-update.yml
+++ b/.github/workflows/docs-update.yml
@@ -43,7 +43,7 @@ jobs:
 
       - name: Run deepagent-code
         if: steps.commits.outputs.has_commits == 'true'
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           DEEPAGENT_CODE_API_KEY: ${{ secrets.DEEPAGENT_CODE_API_KEY }}
         with:
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 3c55bd09..787ade76 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -21,6 +21,26 @@ env:
   FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
 
 jobs:
+  test-fixture-gate:
+    name: test-fixture-gate
+    # QUAL-003: forbid test fixtures from bypassing the durable session state
+    # machine via direct inserts into authority tables. Pure grep gate, no deps.
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+
+      - name: Run test fixture gate
+        run: bun script/check-test-fixtures.ts
+
   unit:
     name: unit (${{ matrix.settings.name }})
     strategy:
diff --git a/.github/workflows/typecheck.yml b/.github/workflows/typecheck.yml
index fc9a5279..0e5c3b3b 100644
--- a/.github/workflows/typecheck.yml
+++ b/.github/workflows/typecheck.yml
@@ -3,8 +3,9 @@ name: typecheck
 on:
   push:
     branches: [dev]
+  # Gate every PR regardless of target branch: the typecheck baseline is easily polluted by stale
+  # worktrees/generated files, so keep it required and branch-agnostic.
   pull_request:
-    branches: [dev]
   workflow_dispatch:
 
 jobs:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 11b906cc..49ba7836 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # Changelog
 
+## Desktop 1.4.7 / DeepAgent Core V4.0.8 - Release hardening and data governance
+
+- Recover the two incident sessions through the formal abandoned path with a zero-provider-invocation oracle and fork smoke on production-snapshot copies; fence pre-successor binaries via a protocol-3 database capability so older builds refuse to open databases carrying successor ownership.
+- Fix the desktop startup crash in the session_intent rebuild migration on SQLite 3.51 (node runtime) and retry transient schema-lock failures in the migration runner.
+- Stop the infinite compaction-continuation recovery loop on startup: recovery failures now land fail-closed (pending → failed) through the widened continuation state machine, serialized per session, with warning-level telemetry.
+- Add durable turn stage evidence and a pre-dispatch watchdog for hung activities; order app timelines by (time, id) so wrapped opaque IDs never reorder messages.
+- Persist encrypted remote-compaction content per session and commit remote compaction runs with an opaque blob pointer instead of a text summary, exempt from information-hole validation.
+- Land RISK-003 data governance: runtime diff-artifact capture (staged behind a flag), a legacy event canonicalizer daemon, portable aggregate snapshot bundles, and a gate-ordered maintenance drill that reclaimed hundreds of MiB on production-snapshot copies (33,168 events deleted, VACUUM 5075 → 4311 MiB).
+- Add the release-evidence manifest infrastructure and archive the 2026-08-19/20 release gates; lock REL-002 wire-budget and discovery-budget regressions; retire the legacy activity authority in favor of the durable path.
+- Align Desktop 1.4.7, DeepAgent Core V4.0.8, and GitHub Action `github-v1.4.7` across package metadata, updater tags, and workflow references.
+
 ## Desktop 1.4.5 / DeepAgent Core V4.0.6 - Bounded planning and runtime hardening
 
 - Make compaction durable through explicit run/attempt lifecycle records and Prompt Epoch authority, with bounded text-only summary retries and typed terminal failures.
diff --git a/README.md b/README.md
index 5572d09f..c96e8638 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@
 
 <p align="center">
   <a href="README.md">English</a> |
-  <a href="README.zh.md">简体中文</a> |
+  <a href="README.zh.md">中文</a> |
   <a href="https://github.com/deepagent-ltd/deepagent-code-enterprise">Enterprise</a>
 </p>
 
diff --git a/github/README.md b/github/README.md
index 949c933d..95d09412 100644
--- a/github/README.md
+++ b/github/README.md
@@ -90,7 +90,7 @@ This will walk you through installing the GitHub app, creating the workflow, and
               persist-credentials: false
 
           - name: Run deepagent-code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
              GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/github/VERSION b/github/VERSION
index e516bb9d..be05bba9 100644
--- a/github/VERSION
+++ b/github/VERSION
@@ -1 +1 @@
-1.4.5
+1.4.7
diff --git a/packages/app/package.json b/packages/app/package.json
index b143030a..cea1b8d1 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@deepagent-code/app",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "",
   "type": "module",
   "exports": {
diff --git a/packages/app/src/components/dialog-console-account.tsx b/packages/app/src/components/dialog-console-account.tsx
new file mode 100644
index 00000000..ed101149
--- /dev/null
+++ b/packages/app/src/components/dialog-console-account.tsx
@@ -0,0 +1,105 @@
+import { createResource, createSignal, type Component, For, Show } from "solid-js"
+import { useDialog } from "@deepagent-code/ui/context/dialog"
+import { Dialog } from "@deepagent-code/ui/dialog"
+import { Spinner } from "@deepagent-code/ui/spinner"
+import { showToast } from "@/utils/toast"
+import { useLanguage } from "@/context/language"
+import { useServerSDK } from "@/context/server-sdk"
+import { useServerSync } from "@/context/server-sync"
+
+// PARITY-004 / GUI 批 — Console 账号接线:消费 /experimental/console/orgs 与 /switch,
+// 列出可切换的 Console 组织并切换活跃组织(server-side truth,见 worklist GUI 批)。
+type Org = {
+  accountID: string
+  accountEmail: string
+  accountUrl: string
+  orgID: string
+  orgName: string
+  active: boolean
+}
+
+export const DialogConsoleAccount: Component = () => {
+  const dialog = useDialog()
+  const language = useLanguage()
+  const serverSDK = useServerSDK()
+  const serverSync = useServerSync()
+  const [switching, setSwitching] = createSignal<string | undefined>()
+
+  const [orgs] = createResource(async () => {
+    const result = await serverSDK.client.experimental.console.listOrgs(undefined, { throwOnError: true })
+    return (result.data?.orgs ?? []) as Org[]
+  })
+
+  const switchOrg = async (org: Org) => {
+    if (switching()) return
+    setSwitching(`${org.accountID}:${org.orgID}`)
+    await serverSDK.client.experimental.console
+      .switchOrg({ accountID: org.accountID, orgID: org.orgID }, { throwOnError: true })
+      .then(() => {
+        serverSync.refreshProviders()
+        showToast({
+          variant: "success",
+          icon: "circle-check",
+          title: language.t("settings.providers.console.switch.toast.title"),
+          description: language.t("settings.providers.console.switch.toast.description", { org: org.orgName }),
+        })
+        dialog.close()
+      })
+      .catch((err: unknown) => {
+        const message = err instanceof Error ? err.message : String(err)
+        showToast({ title: language.t("common.requestFailed"), description: message })
+      })
+      .finally(() => setSwitching(undefined))
+  }
+
+  return (
+    <Dialog title={language.t("settings.providers.console.switchOrg")} transition>
+      <Show
+        when={!orgs.loading}
+        fallback={
+          <div class="flex items-center justify-center py-8">
+            <Spinner />
+          </div>
+        }
+      >
+        <Show
+          when={(orgs() ?? []).length > 0}
+          fallback={
+            <div class="px-4 py-6 text-14-regular text-text-weak">
+              {language.t("settings.providers.console.empty")}
+            </div>
+          }
+        >
+          <div class="flex flex-col px-2 py-1">
+            <For each={orgs() ?? []}>
+              {(org) => {
+                const key = `${org.accountID}:${org.orgID}`
+                return (
+                  <button
+                    type="button"
+                    disabled={!!switching()}
+                    class="flex w-full items-center justify-between gap-3 rounded-md px-3 py-2 text-left hover:bg-fill-weak-base disabled:opacity-60"
+                    onClick={() => void switchOrg(org)}
+                  >
+                    <span class="flex min-w-0 flex-col">
+                      <span class="truncate text-14-medium text-text-strong">{org.orgName}</span>
+                      <span class="truncate text-12-regular text-text-weak">{org.accountEmail}</span>
+                    </span>
+                    <Show when={switching() === key}>
+                      <Spinner />
+                    </Show>
+                    <Show when={org.active && switching() !== key}>
+                      <span class="text-12-medium text-text-interactive-base">
+                        {language.t("common.active")}
+                      </span>
+                    </Show>
+                  </button>
+                )
+              }}
+            </For>
+          </div>
+        </Show>
+      </Show>
+    </Dialog>
+  )
+}
diff --git a/packages/app/src/components/settings-providers.tsx b/packages/app/src/components/settings-providers.tsx
index 07f5da31..32fee603 100644
--- a/packages/app/src/components/settings-providers.tsx
+++ b/packages/app/src/components/settings-providers.tsx
@@ -4,7 +4,7 @@ import { ProviderIcon } from "@deepagent-code/ui/provider-icon"
 import { Tag } from "@deepagent-code/ui/tag"
 import { showToast } from "@/utils/toast"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
-import { createMemo, type Component, For, Show } from "solid-js"
+import { createMemo, createResource, type Component, For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useLanguage } from "@/context/language"
 import { useServerSDK } from "@/context/server-sdk"
@@ -12,6 +12,7 @@ import { useServerSync } from "@/context/server-sync"
 import { DialogConnectProvider } from "./dialog-connect-provider"
 import { DialogSelectProvider } from "./dialog-select-provider"
 import { DialogCustomProvider } from "./dialog-custom-provider"
+import { DialogConsoleAccount } from "./dialog-console-account"
 import { SettingsList } from "./settings-list"
 import { SettingsServerPicker, SettingsServerScope } from "./settings-server-picker"
 import { canRefreshProviderModels } from "./provider-model-refresh"
@@ -50,6 +51,12 @@ const SettingsProvidersContent: Component = () => {
   const providers = useProviders()
   const [refreshing, setRefreshing] = createStore<Record<string, boolean>>({})
 
+  // PARITY-004 / GUI 批 — Console 账号:消费 /experimental/console,显示活跃组织与可切换数量。
+  const [consoleState] = createResource(async () => {
+    const result = await serverSDK.client.experimental.console.get().catch(() => undefined)
+    return result?.data
+  })
+
   const isConfigCustom = (providerID: string) => {
     const provider = serverSync.data.config.provider?.[providerID]
     if (!provider) return false
@@ -180,6 +187,39 @@ const SettingsProvidersContent: Component = () => {
       </div>
 
       <div class="flex flex-col gap-8 max-w-[720px]">
+        <Show
+          when={(consoleState()?.switchableOrgCount ?? 0) > 0 || (consoleState()?.consoleManagedProviders.length ?? 0) > 0}
+        >
+          <div class="flex flex-col gap-1" data-component="console-account-section">
+            <h3 class="text-14-medium text-text-strong pb-2">
+              {language.t("settings.providers.section.consoleAccount")}
+            </h3>
+            <SettingsList>
+              <div class="flex flex-wrap items-center justify-between gap-4 min-h-16 py-3 border-b border-border-weak-base last:border-none">
+                <div class="flex flex-col min-w-0">
+                  <span class="text-14-medium text-text-strong truncate">
+                    {consoleState()?.activeOrgName ?? language.t("settings.providers.console.noOrg")}
+                  </span>
+                  <span class="text-12-regular text-text-weak">
+                    {language.t("settings.providers.console.managedCount", {
+                      count: consoleState()?.consoleManagedProviders.length ?? 0,
+                    })}
+                  </span>
+                </div>
+                <Button
+                  size="large"
+                  variant="ghost"
+                  onClick={() => {
+                    dialog.show(() => <DialogConsoleAccount />)
+                  }}
+                >
+                  {language.t("settings.providers.console.switchOrg")}
+                </Button>
+              </div>
+            </SettingsList>
+          </div>
+        </Show>
+
         <div class="flex flex-col gap-1" data-component="connected-providers-section">
           <h3 class="text-14-medium text-text-strong pb-2">{language.t("settings.providers.section.connected")}</h3>
           <SettingsList>
diff --git a/packages/app/src/components/settings-v2/import-history.tsx b/packages/app/src/components/settings-v2/import-history.tsx
index a351bfe7..759c16f6 100644
--- a/packages/app/src/components/settings-v2/import-history.tsx
+++ b/packages/app/src/components/settings-v2/import-history.tsx
@@ -10,7 +10,7 @@ import { SettingsListV2 } from "./parts/list"
 import { SettingsRowV2 } from "./parts/row"
 import "./settings-v2.css"
 
-type SourceFormat = "codex" | "claude"
+type SourceFormat = "codex" | "claude" | "deepagent"
 type SourceMode = SourceFormat | "custom"
 type Scope = "session" | "memory" | "skill"
 type ProgressEvent =
@@ -90,6 +90,7 @@ export const ImportSection: Component = () => {
   const [dryRun, setDryRun] = createSignal(false)
   const [copyLiveDb, setCopyLiveDb] = createSignal(true)
   const [cwdFilter, setCwdFilter] = createSignal("")
+  const [snapshotFile, setSnapshotFile] = createSignal<File | undefined>(undefined)
   const [running, setRunning] = createSignal(false)
   const [logs, setLogs] = createSignal<string[]>([])
   const [summary, setSummary] = createSignal<string>("")
@@ -113,6 +114,7 @@ export const ImportSection: Component = () => {
   const modeOptions = createMemo(() => [
     { value: "codex" as const, label: t("settings.import.preset.codex", "Codex") },
     { value: "claude" as const, label: t("settings.import.preset.claude", "Claude Code") },
+    { value: "deepagent" as const, label: t("settings.import.preset.deepagent", "DeepAgent Code (snapshot)") },
     { value: "custom" as const, label: t("settings.import.preset.custom", "Custom") },
   ])
   const formatOptions = createMemo(() => [
@@ -125,6 +127,42 @@ export const ImportSection: Component = () => {
     { id: "skill", icon: "bookmark" },
   ]
 
+  // DeepAgent Code snapshot import: read the chosen bundle file and POST it to
+  // /session/import-snapshot (server rebuilds a fresh, continuable session).
+  const runSnapshotImport = async (h: HttpBase | undefined) => {
+    try {
+      const file = snapshotFile()
+      if (!file) {
+        push(`  [error] ${t("settings.import.snapshot.noFile", "Choose a snapshot bundle file first")}`)
+        return
+      }
+      const bundle = await file.text()
+      const res = await fetch(`${h?.url ?? ""}/session/import-snapshot`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeader(h) },
+        body: JSON.stringify({ bundle }),
+        signal: abort?.signal,
+      })
+      if (!res.ok) {
+        const text = await res.text().catch(() => res.statusText)
+        push(`  [error] HTTP ${res.status}: ${text.slice(0, 200)}`)
+        return
+      }
+      const result = (await res.json().catch(() => undefined)) as
+        | { sessionID?: string; messages?: number; parts?: number }
+        | undefined
+      push(
+        `  [session] imported ${result?.sessionID?.slice(0, 16) ?? ""}… · ${result?.messages ?? 0} messages · ${result?.parts ?? 0} parts`,
+      )
+      setSummary(t("settings.import.snapshot.done", "Snapshot imported as a new continuable session"))
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      push(`  [error] ${message}`)
+    } finally {
+      setRunning(false)
+    }
+  }
+
   const run = async () => {
     if (running()) return
     setLogs([])
@@ -134,6 +172,10 @@ export const ImportSection: Component = () => {
     const h = http()
     const src = format()
     push(`→ ${src}${mode() === "custom" ? ` (custom: ${sourcePath() || "default"})` : ` (default)`} · scopes: ${scopes().join(",")}${dryRun() ? " · dry-run" : ""}`)
+    if (src === "deepagent") {
+      await runSnapshotImport(h)
+      return
+    }
     try {
       await streamImport(
         h?.url ?? "",
@@ -218,6 +260,29 @@ export const ImportSection: Component = () => {
           />
         </SettingsRowV2>
 
+        <Show when={mode() === "deepagent"}>
+          <SettingsRowV2
+            title={t("settings.import.snapshot.file", "Snapshot bundle")}
+            description={t(
+              "settings.import.snapshot.file.hint",
+              "Choose an exported session snapshot bundle (.json). It imports as a new continuable session.",
+            )}
+          >
+            <div class="flex flex-col gap-2 w-full sm:w-[260px]">
+              <input
+                data-action="settings-import-snapshot-file"
+                type="file"
+                accept=".json,application/json"
+                disabled={running()}
+                onChange={(e) => setSnapshotFile(e.currentTarget.files?.[0])}
+              />
+              <Show when={snapshotFile()}>
+                {(file) => <span class="text-12-regular text-text-weak truncate">{file().name}</span>}
+              </Show>
+            </div>
+          </SettingsRowV2>
+        </Show>
+
         <Show when={mode() === "custom"}>
           <SettingsRowV2 title={t("settings.import.customPath", "Path")} description={t("settings.import.customPath.hint", "Absolute path to the agent data directory.")}>
             <div class="flex flex-col gap-2 w-full sm:w-[260px]">
diff --git a/packages/app/src/context/bug407008-projection.test.ts b/packages/app/src/context/bug407008-projection.test.ts
new file mode 100644
index 00000000..486f9425
--- /dev/null
+++ b/packages/app/src/context/bug407008-projection.test.ts
@@ -0,0 +1,435 @@
+/**
+ * BUG-407-008 — spec §7.2 App projection deterministic regression tests (scenarios 20-25,
+ * sync/reducer layer). Harness style mirrors ./global-sync/event-reducer.test.ts and
+ * ./directory-sync.test.ts.
+ *
+ * Covered layers:
+ *  - `mergeMessage` / `applyDirectoryEvent` (packages/app/src/context/global-sync/event-reducer.ts)
+ *    — Fix-D server-owned marker monotonicity + conflict → refetchSession.
+ *  - `runInflight` (packages/app/src/context/directory-sync.ts) — keyed trailing forced sync.
+ *  - `createDirSyncContext` pagination — deterministic convergence across page order/refresh.
+ *
+ * Implementation note: the working tree carries a BUG-005 change that classifies a same-activity
+ * revision mismatch as staleness (keep the higher revision, no conflict, no forced reload). Tests
+ * below pin that actual semantics and annotate where it differs from earlier behavior.
+ */
+import { describe, expect, test } from "bun:test"
+import { createRoot } from "solid-js"
+import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
+import type { Message } from "@deepagent-code/sdk/v2/client"
+import { ServerScope } from "@/utils/server-scope"
+import type { State } from "./global-sync/types"
+import { applyDirectoryEvent } from "./global-sync/event-reducer"
+import { createDirSyncContext, runInflight } from "./directory-sync"
+
+type AssistantMessage = Extract<Message, { role: "assistant" }>
+
+const baseState = (input: Partial<State> = {}) =>
+  ({
+    status: "complete",
+    agent: [],
+    command: [],
+    project: "",
+    projectMeta: undefined,
+    icon: undefined,
+    provider: {} as State["provider"],
+    config: {} as State["config"],
+    path: { directory: "/tmp" } as State["path"],
+    session: [],
+    sessionTotal: 0,
+    session_status: {},
+    session_diff: {},
+    todo: {},
+    permission: {},
+    question: {},
+    mcp: {},
+    lsp: [],
+    vcs: undefined,
+    limit: 10,
+    message: {},
+    part: {},
+    part_text_accum_delta: {},
+    ...input,
+  }) as State
+
+const assistantMessage = (
+  id: string,
+  sessionID: string,
+  activityProgress?: AssistantMessage["activityProgress"],
+) =>
+  ({
+    id,
+    sessionID,
+    role: "assistant",
+    parentID: "msg_user",
+    time: { created: 1 },
+    modelID: "gpt",
+    providerID: "openai",
+    mode: "build",
+    agent: "assistant",
+    path: { cwd: "/tmp", root: "/tmp" },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    activityProgress,
+  }) as AssistantMessage
+
+const INCIDENT_ACTIVITY = "a6d06b2a82ef234ab9dc71e3fd940292a21b34f4732f28aa19ba8416c4c5e5a9"
+
+const applyMessageUpdated = (
+  store: Store<State>,
+  setStore: SetStoreFunction<State>,
+  info: Message,
+  refetchSession?: (sessionID: string) => void,
+) =>
+  applyDirectoryEvent({
+    event: { type: "message.updated", properties: { info } },
+    store,
+    setStore,
+    push() {},
+    directory: "/tmp",
+    loadLsp() {},
+    ...(refetchSession ? { refetchSession } : {}),
+  })
+
+const firstAssistant = (store: State, sessionID: string) =>
+  store.message[sessionID]?.[0] as AssistantMessage | undefined
+
+describe("BUG-407-008 §7.2 App projection — reducer monotonicity (scenarios 20-22)", () => {
+  test("20: revision 8 arrives via SSE first, revision 9 after — latest revision 9 is established", () => {
+    const sessionID = "ses_0149b8afffffWlu80cVGdzFI9s"
+    const [store, setStore] = createStore(baseState())
+
+    // revision 8's owning assistant message arrives first over the realtime stream.
+    applyMessageUpdated(
+      store,
+      setStore,
+      assistantMessage("msg_incident_r8", sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 8,
+        state: "progress",
+      }),
+    )
+    // revision 9's owning assistant message arrives afterwards.
+    applyMessageUpdated(
+      store,
+      setStore,
+      assistantMessage("msg_incident_r9", sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 9,
+        state: "progress",
+      }),
+    )
+
+    // Both owning messages coexist in the store with their server-owned markers intact; the
+    // "only revision 9 is visible" contract is a timeline-layer selection (Fix-E). Fix-E was
+    // removed in commit 1ae96499 — see message-timeline.bug407008.test.ts scenario 18 for the
+    // pinned actual timeline behavior. At the store layer the latest revision is well-defined:
+    expect(store.message[sessionID]?.map((m) => m.id)).toEqual(["msg_incident_r8", "msg_incident_r9"])
+    expect((store.message[sessionID]?.[0] as AssistantMessage).activityProgress?.revision).toBe(8)
+    expect((store.message[sessionID]?.[1] as AssistantMessage).activityProgress?.revision).toBe(9)
+  })
+
+  test("21: revision 9 first, out-of-order revision 8 after — no regression to revision 8", () => {
+    const sessionID = "ses_1"
+    const current = assistantMessage("msg_assistant", sessionID, {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 9,
+      state: "progress",
+    })
+    const [store, setStore] = createStore(baseState({ message: { [sessionID]: [current] } }))
+    const refreshed: string[] = []
+
+    // A stale event/page replays the SAME owning message with the older revision 8.
+    applyMessageUpdated(
+      store,
+      setStore,
+      assistantMessage(current.id, sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 8,
+        state: "progress",
+      }),
+      (id) => refreshed.push(id),
+    )
+
+    // The store never regresses to revision 8 ...
+    expect(firstAssistant(store, sessionID)?.activityProgress?.revision).toBe(9)
+    expect(firstAssistant(store, sessionID)?.activityProgress?.activityID).toBe(INCIDENT_ACTIVITY)
+    // ... and, per the working-tree BUG-005 semantics, a same-activity revision mismatch is
+    // treated as staleness: it keeps the higher revision WITHOUT escalating to a forced session
+    // reload. (Before BUG-005 this same event was a conflict that triggered refetchSession.)
+    expect(refreshed).toEqual([])
+  })
+
+  test("22: after a terminal marker, marker-less or stale progress events cannot clear or downgrade it", () => {
+    const sessionID = "ses_1"
+    const terminal = assistantMessage("msg_assistant", sessionID, {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 10,
+      state: "interrupted",
+      terminalReason: "user_abort",
+    })
+    const [store, setStore] = createStore(baseState({ message: { [sessionID]: [terminal] } }))
+    const refreshed: string[] = []
+    const refetch = (id: string) => refreshed.push(id)
+
+    // (a) A late ordinary update WITHOUT any marker must not clear the terminal marker.
+    applyMessageUpdated(store, setStore, { ...terminal, activityProgress: undefined }, refetch)
+    expect(firstAssistant(store, sessionID)?.activityProgress).toEqual(terminal.activityProgress)
+
+    // (b) A stale event replaying the same revision as non-terminal `progress` must not downgrade.
+    applyMessageUpdated(
+      store,
+      setStore,
+      assistantMessage(terminal.id, sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 10,
+        state: "progress",
+      }),
+      refetch,
+    )
+    expect(firstAssistant(store, sessionID)?.activityProgress?.state).toBe("interrupted")
+    expect(firstAssistant(store, sessionID)?.activityProgress?.terminalReason).toBe("user_abort")
+
+    // (c) An even older revision's progress event cannot displace the terminal revision either.
+    applyMessageUpdated(
+      store,
+      setStore,
+      assistantMessage(terminal.id, sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 8,
+        state: "progress",
+      }),
+      refetch,
+    )
+    expect(firstAssistant(store, sessionID)?.activityProgress?.revision).toBe(10)
+    expect(firstAssistant(store, sessionID)?.activityProgress?.state).toBe("interrupted")
+    // None of these are integrity conflicts, so no forced reload is requested.
+    expect(refreshed).toEqual([])
+  })
+})
+
+describe("BUG-407-008 §7.2 App projection — trailing forced sync (scenarios 23-24)", () => {
+  test("23: conflict during an in-flight ordinary sync keeps canonical and runs one trailing forced sync after commit", async () => {
+    const sessionID = "ses_1"
+    const canonical = assistantMessage("msg_assistant", sessionID, {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 9,
+      state: "progress",
+    })
+    const [store, setStore] = createStore(baseState({ message: { [sessionID]: [canonical] } }))
+
+    // Simulated durable read source: the authority commit flips this flag while the ordinary
+    // sync is still in flight; only the trailing forced sync may observe the committed state.
+    let authorityCommitted = false
+    const reads: Array<{ run: number; sawCommittedState: boolean }> = []
+    let runs = 0
+    let gate: (() => void) | undefined
+    const task = async () => {
+      runs += 1
+      const run = runs
+      // The read happens at sync start — the ordinary sync reads BEFORE the authority commit,
+      // while the trailing forced sync reads after it.
+      reads.push({ run, sawCommittedState: authorityCommitted })
+      if (run === 1) {
+        // The ordinary sync is still in flight when the conflict arrives.
+        await new Promise<void>((resolve) => {
+          gate = resolve
+        })
+      }
+    }
+
+    const inflight = new Map<string, Promise<void>>()
+    const trailing = new Set<string>()
+    let forced: Promise<void> | undefined
+    // Mirrors directory-sync wiring: refetchSession -> session.sync(sessionID, { force: true }),
+    // implemented via keyed runInflight so a forced call during an in-flight sync becomes a
+    // trailing forced sync instead of being swallowed.
+    const refetchSession = (id: string) => {
+      forced = runInflight(inflight, trailing, id, true, task)
+    }
+
+    const ordinary = runInflight(inflight, trailing, sessionID, false, task)
+    await Promise.resolve()
+    expect(runs).toBe(1)
+
+    // Authority commit happens, then the conflicting marker event arrives mid-flight.
+    applyMessageUpdated(
+      store,
+      setStore,
+      assistantMessage(canonical.id, sessionID, {
+        activityID: "activity-other",
+        revision: 0,
+        state: "final",
+      }),
+      refetchSession,
+    )
+
+    // Canonical marker is preserved against the conflicting incoming marker ...
+    expect(firstAssistant(store, sessionID)?.activityProgress).toEqual(canonical.activityProgress)
+    // ... and the conflict requested a refetch that was queued, not executed yet.
+    expect(forced).toBeDefined()
+    expect(runs).toBe(1)
+    expect(trailing.has(sessionID)).toBe(true)
+
+    // The authority commit lands while the ordinary sync is still running.
+    authorityCommitted = true
+    gate?.()
+    await ordinary
+    await forced
+
+    // Exactly one trailing forced sync ran, and its read happened AFTER the commit.
+    expect(runs).toBe(2)
+    expect(reads).toEqual([
+      { run: 1, sawCommittedState: false },
+      { run: 2, sawCommittedState: true },
+    ])
+    expect(trailing.size).toBe(0)
+  })
+
+  test("24: multiple conflicts in the same window coalesce into exactly one trailing forced sync, no loop", async () => {
+    const sessionID = "ses_1"
+    let runs = 0
+    let gate: (() => void) | undefined
+    const task = async () => {
+      runs += 1
+      if (runs === 1) {
+        await new Promise<void>((resolve) => {
+          gate = resolve
+        })
+      }
+    }
+    const inflight = new Map<string, Promise<void>>()
+    const trailing = new Set<string>()
+
+    // Ordinary sync already in flight ...
+    const ordinary = runInflight(inflight, trailing, sessionID, false, task)
+    await Promise.resolve()
+    expect(runs).toBe(1)
+
+    // ... then the SAME session receives several marker conflicts inside that window. Each one
+    // asks for a forced refetch (as applyDirectoryEvent would via refetchSession).
+    const forced = [
+      runInflight(inflight, trailing, sessionID, true, task),
+      runInflight(inflight, trailing, sessionID, true, task),
+      runInflight(inflight, trailing, sessionID, true, task),
+    ]
+    await Promise.resolve()
+    // The in-flight ordinary Promise must not swallow them: a trailing run is armed.
+    expect(trailing.has(sessionID)).toBe(true)
+    expect(runs).toBe(1)
+
+    gate?.()
+    await Promise.all([ordinary, ...forced])
+
+    // Exactly ONE trailing forced sync executed (ordinary + trailing = 2 runs total).
+    expect(runs).toBe(2)
+    expect(trailing.size).toBe(0)
+
+    // No retry loop: after settling, nothing else runs.
+    for (let attempt = 0; attempt < 50; attempt += 1) await Promise.resolve()
+    expect(runs).toBe(2)
+    expect(trailing.size).toBe(0)
+  })
+})
+
+describe("BUG-407-008 §7.2 App projection — pagination determinism (scenario 25)", () => {
+  test("25: newest-first paging, refresh and reconnect all converge to the same projection", async () => {
+    await createRoot(async (dispose) => {
+      const sessionID = "ses_0149b8afffffWlu80cVGdzFI9s"
+      const newest = assistantMessage("msg_incident_new", sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 9,
+        state: "progress",
+      })
+      const older = assistantMessage("msg_incident_old", sessionID, {
+        activityID: INCIDENT_ACTIVITY,
+        revision: 8,
+        state: "progress",
+      })
+
+      const state = () =>
+        createStore({
+          path: { directory: "/repo" },
+          session: [] as Array<{ id: string }>,
+          mcp: {},
+          message: {} as Record<string, Message[] | undefined>,
+          part: {} as Record<string, unknown[] | undefined>,
+          part_text_accum_delta: {} as Record<string, string | undefined>,
+          todo: {} as Record<string, unknown[] | undefined>,
+          session_diff: {} as Record<string, unknown[] | undefined>,
+          session_status: {} as Record<string, unknown | undefined>,
+          permission: {} as Record<string, unknown[] | undefined>,
+          question: {} as Record<string, unknown[] | undefined>,
+        })
+      const current = state()
+      const serverSync = {
+        child() {
+          return current
+        },
+        plan: {
+          async sync() {},
+        },
+      } as unknown as Parameters<typeof createDirSyncContext>[1]
+
+      let messageCalls = 0
+      const sync = createDirSyncContext("/repo/main", serverSync, {
+        scope: ServerScope.local,
+        createClient() {
+          return {
+            session: {
+              async get() {
+                return { data: { id: sessionID } }
+              },
+              // Durable authority: the newest page (revision 9) is served first with a cursor to
+              // the older page (revision 8); the older page has no further cursor.
+              async messages(input: { limit: number; before?: string }) {
+                messageCalls += 1
+                if (input.before === "cursor-old") {
+                  return { data: [{ info: older, parts: [] }], response: { headers: new Headers() } }
+                }
+                return {
+                  data: [{ info: newest, parts: [] }],
+                  response: { headers: new Headers({ "x-next-cursor": "cursor-old" }) },
+                }
+              },
+            },
+          }
+        },
+      } as unknown as Parameters<typeof createDirSyncContext>[2])
+
+      const snapshot = () =>
+        JSON.parse(
+          JSON.stringify(
+            (current[0].message[sessionID] ?? []).map((message) => ({
+              id: message.id,
+              progress: message.role === "assistant" ? message.activityProgress ?? null : null,
+            })),
+          ),
+        )
+
+      current[1]("session", [current[0].session.length], { id: sessionID })
+
+      // Pass 1: load the newest page first, then page backwards to the older page.
+      await sync.session.sync(sessionID)
+      await sync.session.history.loadMore(sessionID)
+      const afterPaging = snapshot()
+      expect(afterPaging).toEqual([
+        { id: newest.id, progress: newest.activityProgress },
+        { id: older.id, progress: older.activityProgress },
+      ])
+
+      // Pass 2: refresh/reconnect — evict all in-memory caches and rebuild from HTTP pages.
+      sync.session.evict(sessionID)
+      expect(current[0].message[sessionID]).toBeUndefined()
+      await sync.session.sync(sessionID, { force: true })
+      await sync.session.history.loadMore(sessionID)
+      const afterReconnect = snapshot()
+
+      // Identical projection regardless of page arrival order and cache state.
+      expect(afterReconnect).toEqual(afterPaging)
+      // Both pages were served twice (newest + older per pass); nothing else was fetched.
+      expect(messageCalls).toBe(4)
+      dispose()
+    })
+  })
+})
diff --git a/packages/app/src/context/directory-sync.test.ts b/packages/app/src/context/directory-sync.test.ts
index 0791d8ab..5f5baaf6 100644
--- a/packages/app/src/context/directory-sync.test.ts
+++ b/packages/app/src/context/directory-sync.test.ts
@@ -3,7 +3,7 @@ import { createRoot } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { Message, Part } from "@deepagent-code/sdk/v2/client"
 import { ServerScope } from "@/utils/server-scope"
-import { createDirSyncContext, runInflight } from "./directory-sync"
+import { applyOptimisticAdd, createDirSyncContext, mergeOptimisticPage, runInflight } from "./directory-sync"
 
 const state = () =>
   createStore({
@@ -412,6 +412,76 @@ describe("directory optimistic targeting", () => {
     if (result?.role === "assistant") expect(result.activityProgress).toEqual(canonical)
   })
 
+  test("conflict recovery refetches only the authoritative tail, not the whole session", async () => {
+    let messageCalls = 0
+    let sessionGetCalls = 0
+    const messageRequests: Array<{ limit: number; before?: string }> = []
+    let forcedStarted: (() => void) | undefined
+    const current = state()
+    const initial = { activityID: "activity-1", revision: 1, state: "progress" as const }
+    const canonical = { activityID: "activity-1", revision: 2, state: "final" as const }
+    const serverSync = {
+      child() {
+        return current
+      },
+      plan: {
+        async sync() {},
+      },
+    } as unknown as Parameters<typeof createDirSyncContext>[1]
+    const sync = createDirSyncContext("/repo/main", serverSync, {
+      scope: ServerScope.local,
+      createClient() {
+        return {
+          session: {
+            async get() {
+              sessionGetCalls += 1
+              return { data: { id: "ses_1" } }
+            },
+            async messages(input: { limit: number; before?: string }) {
+              messageCalls += 1
+              messageRequests.push({ limit: input.limit, before: input.before })
+              if (messageCalls === 3) forcedStarted?.()
+              const marker =
+                messageCalls === 2
+                  ? { activityID: "activity-conflict", revision: 0, state: "progress" as const }
+                  : messageCalls === 3
+                    ? canonical
+                    : initial
+              return {
+                data: [{ info: assistantMessage("msg_assistant", "ses_1", marker), parts: [] }],
+                response: { headers: new Headers(messageCalls === 1 ? { "x-next-cursor": "older" } : {}) },
+              }
+            },
+          },
+        }
+      },
+    } as unknown as Parameters<typeof createDirSyncContext>[2])
+    const sessionID = "ses_1"
+    current[1]("session", [current[0].session.length], { id: sessionID })
+    await sync.session.sync(sessionID, { force: true })
+
+    const forced = new Promise<void>((resolve) => {
+      forcedStarted = resolve
+    })
+    await sync.session.history.loadMore(sessionID)
+    await forced
+
+    expect(messageCalls).toBe(3)
+    // BUG-005 degradation: the recovery is a BOUNDED authoritative TAIL refetch (newest page, no
+    // `before`), NOT a full-session force reload — a full reload would re-fetch the session header.
+    expect(messageRequests[2]?.before).toBeUndefined()
+    expect(messageRequests[2]?.limit).toBeLessThanOrEqual(80)
+    expect(sessionGetCalls).toBe(1)
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      const message = current[0].message[sessionID]?.[0]
+      if (message?.role === "assistant" && message.activityProgress?.revision === canonical.revision) break
+      await Promise.resolve()
+    }
+    const result = current[0].message[sessionID]?.[0]
+    expect(result?.role).toBe("assistant")
+    if (result?.role === "assistant") expect(result.activityProgress).toEqual(canonical)
+  })
+
   test("does not let an older forced response overwrite a marker received during the request", async () => {
     let release: (() => void) | undefined
     const current = state()
@@ -595,6 +665,105 @@ describe("directory optimistic targeting", () => {
   })
 })
 
+describe("directory sync across the ID time wrap (BUG-407-012 root cause B)", () => {
+  // The 26th wrap of the 6-byte ID time field happened on 2026-08-14: the chronologically NEWER
+  // message carries a lexicographically SMALLER ID. These fixtures mirror the incident session.
+  const WRAP_OLD_ID = "msg_ffa88f0840015Xj7vIrcdNEJJB" // 2026-08-13 17:51:46
+  const WRAP_NEW_ID = "msg_00d62a3c4001KqYw3o8wBBH6qm" // 2026-08-17 09:42:43
+  const WRAP_OLD_TIME = 1786614706000
+  const WRAP_NEW_TIME = 1786930963000
+  const WRAP_OLD_PART = "prt_ffa88f084001aaaa"
+  const WRAP_NEW_PART = "prt_00d62a3c4001bbbb"
+
+  const wrapUserMessage = (id: string, sessionID: string, created: number): Message => ({
+    id,
+    sessionID,
+    role: "user",
+    time: { created },
+    agent: "assistant",
+    model: { providerID: "openai", modelID: "gpt" },
+  })
+
+  const wrapTextPart = (id: string, sessionID: string, messageID: string, start: number): Part =>
+    ({
+      id,
+      sessionID,
+      messageID,
+      type: "text",
+      text: id,
+      time: { start },
+    }) as Part
+
+  test("mergeOptimisticPage appends a wrapped newer optimistic message at the timeline tail", () => {
+    expect(WRAP_NEW_ID < WRAP_OLD_ID).toBe(true) // sanity: raw ID order is reversed
+    const older = wrapUserMessage(WRAP_OLD_ID, "ses_1", WRAP_OLD_TIME)
+    const newer = wrapUserMessage(WRAP_NEW_ID, "ses_1", WRAP_NEW_TIME)
+
+    const merged = mergeOptimisticPage({ session: [older], part: [], complete: true }, [{ message: newer, parts: [] }])
+
+    expect(merged.session.map((message) => message.id)).toEqual([WRAP_OLD_ID, WRAP_NEW_ID])
+  })
+
+  test("applyOptimisticAdd inserts a wrapped newer message after the older msg_ff... one", () => {
+    const older = wrapUserMessage(WRAP_OLD_ID, "ses_1", WRAP_OLD_TIME)
+    const newer = wrapUserMessage(WRAP_NEW_ID, "ses_1", WRAP_NEW_TIME)
+    const draft = { message: { ses_1: [older] }, part: {} } as {
+      message: Record<string, Message[] | undefined>
+      part: Record<string, Part[] | undefined>
+    }
+
+    applyOptimisticAdd(draft, { sessionID: "ses_1", message: newer, parts: [] })
+
+    expect(draft.message.ses_1?.map((message) => message.id)).toEqual([WRAP_OLD_ID, WRAP_NEW_ID])
+  })
+
+  test("a synced page keeps the server (time_created, id) order across the wrap", async () => {
+    const older = wrapUserMessage(WRAP_OLD_ID, "ses_1", WRAP_OLD_TIME)
+    const newer = wrapUserMessage(WRAP_NEW_ID, "ses_1", WRAP_NEW_TIME)
+    // Deliberately hand the page back-to-front plus a wrapped part pair in reversed order: the
+    // client-side re-sort must land on chronological order, not ID order.
+    const oldPart = wrapTextPart(WRAP_OLD_PART, "ses_1", WRAP_NEW_ID, WRAP_OLD_TIME)
+    const newPart = wrapTextPart(WRAP_NEW_PART, "ses_1", WRAP_NEW_ID, WRAP_NEW_TIME)
+    const current = state()
+    const serverSync = {
+      child() {
+        return current
+      },
+      plan: {
+        async sync() {},
+      },
+    } as unknown as Parameters<typeof createDirSyncContext>[1]
+    const sync = createDirSyncContext("/repo/main", serverSync, {
+      scope: ServerScope.local,
+      createClient() {
+        return {
+          session: {
+            async get() {
+              return { data: { id: "ses_1" } }
+            },
+            async messages() {
+              return {
+                data: [
+                  { info: older, parts: [] },
+                  { info: newer, parts: [newPart, oldPart] },
+                ],
+                response: { headers: new Headers() },
+              }
+            },
+          },
+        }
+      },
+    } as unknown as Parameters<typeof createDirSyncContext>[2])
+    const sessionID = "ses_1"
+    current[1]("session", [current[0].session.length], { id: sessionID })
+
+    await sync.session.sync(sessionID)
+
+    expect(current[0].message[sessionID]?.map((message) => message.id)).toEqual([WRAP_OLD_ID, WRAP_NEW_ID])
+    expect(current[0].part[WRAP_NEW_ID]?.map((part) => part.id)).toEqual([WRAP_OLD_PART, WRAP_NEW_PART])
+  })
+})
+
 describe("directory forced session synchronization", () => {
   test("runs one trailing forced refresh after an ordinary refresh completes", async () => {
     const inflight = new Map<string, Promise<void>>()
diff --git a/packages/app/src/context/directory-sync.ts b/packages/app/src/context/directory-sync.ts
index d6bc4a94..d223d515 100644
--- a/packages/app/src/context/directory-sync.ts
+++ b/packages/app/src/context/directory-sync.ts
@@ -12,6 +12,13 @@ import {
 import type { Message, Part } from "@deepagent-code/sdk/v2/client"
 import { SESSION_CACHE_LIMIT, dropSessionCaches, pickSessionCacheEvictions } from "./global-sync/session-cache"
 import { diffs as list, message as clean } from "@/utils/diffs"
+import {
+  compareMessages,
+  compareParts,
+  findMessageIndex,
+  locateMessage,
+  locatePart,
+} from "@/utils/message-order"
 import { createServerSdkContext, useServerSDK } from "./server-sdk"
 import { type createServerSyncContextInner } from "./server-sync"
 import { promptAdmissionClientMessageID } from "./global-sync/prompt-admission"
@@ -20,8 +27,10 @@ import { mergeMessage } from "./global-sync/event-reducer"
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 type ActivityProgress = NonNullable<Extract<Message, { role: "assistant" }>["activityProgress"]>
 
+// BUG-407-012 root cause B: ID order is not chronological order across the 6-byte ID time wrap;
+// parts sort by (time.start, id), messages by (time.created, id). See utils/message-order.ts.
 function sortParts(parts: Part[]) {
-  return parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
+  return parts.filter((part) => !!part?.id).sort((a, b) => compareParts(a, b))
 }
 
 export async function runInflight(
@@ -87,7 +96,7 @@ function mergePageMessages(
     conflict ||= result.conflict
   }
   return {
-    messages: [...messages.values()].sort((a, b) => cmp(a.id, b.id)),
+    messages: [...messages.values()].sort((a, b) => compareMessages(a, b)),
     conflict,
   }
 }
@@ -142,7 +151,7 @@ type MessagePage = {
 
 const hasParts = (parts: Part[] | undefined, want: Part[]) => {
   if (!parts) return want.length === 0
-  return want.every((part) => Binary.search(parts, part.id, (item) => item.id).found)
+  return want.every((part) => locatePart(parts, part).found)
 }
 
 const mergeParts = (parts: Part[] | undefined, want: Part[]) => {
@@ -150,7 +159,7 @@ const mergeParts = (parts: Part[] | undefined, want: Part[]) => {
   const next = [...parts]
   let changed = false
   for (const part of want) {
-    const result = Binary.search(next, part.id, (item) => item.id)
+    const result = locatePart(next, part)
     if (result.found) continue
     next.splice(result.index, 0, part)
     changed = true
@@ -180,7 +189,7 @@ export function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[])
       part.delete(item.message.id)
       continue
     }
-    const result = Binary.search(session, item.message.id, (message) => message.id)
+    const result = locateMessage(session, item.message)
     const found = result.found
     if (!found) session.splice(result.index, 0, item.message)
 
@@ -209,7 +218,7 @@ export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddI
     return
   }
   if (messages) {
-    const result = Binary.search(messages, input.message.id, (m) => m.id)
+    const result = locateMessage(messages, input.message)
     if (result.found) messages[result.index] = input.message
     else messages.splice(result.index, 0, input.message)
   } else {
@@ -221,8 +230,8 @@ export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddI
 export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticRemoveInput) {
   const messages = draft.message[input.sessionID]
   if (messages) {
-    const result = Binary.search(messages, input.messageID, (m) => m.id)
-    if (result.found) messages.splice(result.index, 1)
+    const index = findMessageIndex(messages, input.messageID)
+    if (index !== -1) messages.splice(index, 1)
   }
   delete draft.part[input.messageID]
 }
@@ -230,7 +239,7 @@ export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticR
 function setOptimisticAdd(setStore: (...args: unknown[]) => void, input: OptimisticAddInput) {
   setStore("message", input.sessionID, (messages: Message[] | undefined) => {
     if (!messages) return [input.message]
-    const result = Binary.search(messages, input.message.id, (m) => m.id)
+    const result = locateMessage(messages, input.message)
     const next = [...messages]
     if (result.found) next[result.index] = input.message
     else next.splice(result.index, 0, input.message)
@@ -242,10 +251,10 @@ function setOptimisticAdd(setStore: (...args: unknown[]) => void, input: Optimis
 function setOptimisticRemove(setStore: (...args: unknown[]) => void, input: OptimisticRemoveInput) {
   setStore("message", input.sessionID, (messages: Message[] | undefined) => {
     if (!messages) return messages
-    const result = Binary.search(messages, input.messageID, (m) => m.id)
-    if (!result.found) return messages
+    const index = findMessageIndex(messages, input.messageID)
+    if (index === -1) return messages
     const next = [...messages]
-    next.splice(result.index, 1)
+    next.splice(index, 1)
     return next
   })
   setStore("part", input.messageID, undefined)
@@ -397,7 +406,9 @@ export const createDirSyncContext = (
       input.client.session.messages({ sessionID: input.sessionID, limit: input.limit, before: input.before }),
     )
     const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
-    const session = items.map((x) => clean(x.info)).sort((a, b) => cmp(a.id, b.id))
+    // The server page is already in (time_created, id) order; re-sort with the same compound
+    // comparator so a wrapped `msg_00...` tail is never reordered ahead of `msg_ff...` history.
+    const session = items.map((x) => clean(x.info)).sort((a, b) => compareMessages(a, b))
     const part = items.map((message) => ({ id: message.info.id, part: sortParts(message.parts) }))
     const cursor = messages.response?.headers.get("x-next-cursor") ?? undefined
     return {
@@ -485,7 +496,24 @@ export const createDirSyncContext = (
               draft.loading[key] = false
             }),
           )
-          if (conflict && input.refetchOnConflict !== false) requestSessionSync?.(input.sessionID)
+          if (conflict && input.refetchOnConflict !== false) {
+            // BUG-005 residual: degrade conflict recovery from a FULL-session force reload
+            // (requestSessionSync) to an authoritative TAIL refetch. An activityProgress conflict
+            // only means the recent markers diverged; refetching the newest small page
+            // authoritatively reconciles them in place (mergePageMessages keys by id, so untouched
+            // messages are preserved) instead of refetching and re-rendering the whole session.
+            // force:true queues behind the in-flight page; refetchOnConflict:false bounds recursion.
+            void loadMessages({
+              directory: input.directory,
+              client: input.client,
+              setStore: input.setStore,
+              sessionID: input.sessionID,
+              limit: Math.min(input.limit, initialMessagePageSize),
+              force: true,
+              authoritative: true,
+              refetchOnConflict: false,
+            }).catch(() => {})
+          }
         })
     })
   }
diff --git a/packages/app/src/context/global-sync/event-reducer.test.ts b/packages/app/src/context/global-sync/event-reducer.test.ts
index 70397a69..e7bd1e47 100644
--- a/packages/app/src/context/global-sync/event-reducer.test.ts
+++ b/packages/app/src/context/global-sync/event-reducer.test.ts
@@ -546,6 +546,50 @@ describe("applyDirectoryEvent", () => {
     expect(refreshed).toEqual([sessionID])
   })
 
+  test("BUG-005: treats a same-activity revision mismatch as staleness, not a conflict", () => {
+    const sessionID = "ses_1"
+    const current = assistantMessage("msg_assistant", sessionID, {
+      activityID: "activity-1",
+      revision: 5,
+      state: "progress",
+    })
+    const [store, setStore] = createStore(baseState({ message: { [sessionID]: [current] } }))
+    const refreshed: string[] = []
+    const apply = (revision: number, state: "progress" | "final") =>
+      applyDirectoryEvent({
+        event: {
+          type: "message.updated",
+          properties: {
+            info: assistantMessage(current.id, sessionID, {
+              activityID: "activity-1",
+              revision,
+              state,
+            }),
+          },
+        },
+        store,
+        setStore,
+        push() {},
+        directory: "/tmp",
+        loadLsp() {},
+        refetchSession: (id) => refreshed.push(id),
+      })
+
+    // A stale page/event carrying an older revision must keep the higher one and never escalate.
+    apply(2, "progress")
+    expect(refreshed).toEqual([])
+    expect(
+      (store.message[sessionID]?.[0] as Extract<Message, { role: "assistant" }>).activityProgress?.revision,
+    ).toBe(5)
+
+    // A newer revision is adopted without triggering a canonical refresh either.
+    apply(7, "final")
+    expect(refreshed).toEqual([])
+    const progress = (store.message[sessionID]?.[0] as Extract<Message, { role: "assistant" }>).activityProgress
+    expect(progress?.revision).toBe(7)
+    expect(progress?.state).toBe("final")
+  })
+
   test("allows a same-revision activity marker to advance but never regress", () => {
     const sessionID = "ses_1"
     const provisional = assistantMessage("msg_assistant", sessionID, {
@@ -807,6 +851,83 @@ describe("applyDirectoryEvent", () => {
   })
 })
 
+// BUG-407-012 root cause B: the 6-byte ID time field wrapped on 2026-08-14, so chronologically
+// NEWER messages/parts carry lexicographically SMALLER IDs (`msg_00...` < `msg_ff...`). Realtime
+// inserts must keep (time, id) chronological order instead of ID order.
+describe("message ordering across the ID time wrap (BUG-407-012)", () => {
+  const WRAP_OLD_ID = "msg_ffa88f0840015Xj7vIrcdNEJJB" // 2026-08-13 17:51:46
+  const WRAP_NEW_ID = "msg_00d62a3c4001KqYw3o8wBBH6qm" // 2026-08-17 09:42:43
+  const WRAP_OLD_TIME = 1786614706000
+  const WRAP_NEW_TIME = 1786930963000
+
+  const timedUserMessage = (id: string, sessionID: string, created: number) =>
+    ({ ...userMessage(id, sessionID), time: { created } }) as Message
+
+  const timedTextPart = (id: string, sessionID: string, messageID: string, start: number) =>
+    ({
+      id,
+      sessionID,
+      messageID,
+      type: "text",
+      text: id,
+      time: { start },
+    }) as Part
+
+  test("message.updated appends a chronologically newer msg_00... after the older msg_ff...", () => {
+    const sessionID = "ses_1"
+    expect(WRAP_NEW_ID < WRAP_OLD_ID).toBe(true) // sanity: raw ID order is reversed
+    const [store, setStore] = createStore(
+      baseState({ message: { [sessionID]: [timedUserMessage(WRAP_OLD_ID, sessionID, WRAP_OLD_TIME)] } }),
+    )
+
+    applyDirectoryEvent({
+      event: {
+        type: "message.updated",
+        properties: { info: timedUserMessage(WRAP_NEW_ID, sessionID, WRAP_NEW_TIME) },
+      },
+      store,
+      setStore,
+      push() {},
+      directory: "/tmp",
+      loadLsp() {},
+    })
+
+    expect(store.message[sessionID]?.map((message) => message.id)).toEqual([WRAP_OLD_ID, WRAP_NEW_ID])
+
+    // Identity-based removal still works in a (time, id)-ordered array.
+    applyDirectoryEvent({
+      event: { type: "message.removed", properties: { sessionID, messageID: WRAP_OLD_ID } },
+      store,
+      setStore,
+      push() {},
+      directory: "/tmp",
+      loadLsp() {},
+    })
+
+    expect(store.message[sessionID]?.map((message) => message.id)).toEqual([WRAP_NEW_ID])
+  })
+
+  test("message.part.updated appends a chronologically newer wrapped part at the tail", () => {
+    const sessionID = "ses_1"
+    const messageID = WRAP_NEW_ID
+    const oldPart = timedTextPart("prt_ffa88f084001aaaa", sessionID, messageID, WRAP_OLD_TIME)
+    const newPart = timedTextPart("prt_00d62a3c4001bbbb", sessionID, messageID, WRAP_NEW_TIME)
+    expect(newPart.id < oldPart.id).toBe(true) // sanity: raw ID order is reversed
+    const [store, setStore] = createStore(baseState({ part: { [messageID]: [oldPart] } }))
+
+    applyDirectoryEvent({
+      event: { type: "message.part.updated", properties: { part: newPart } },
+      store,
+      setStore,
+      push() {},
+      directory: "/tmp",
+      loadLsp() {},
+    })
+
+    expect(store.part[messageID]?.map((part) => part.id)).toEqual([oldPart.id, newPart.id])
+  })
+})
+
 // Regression guard for the plan panel. The model pushes repeated plan.updated events that advance
 // step statuses; the reducer feeds them into a per-session plan store via reconcile. The previous
 // code used `{ key: "plan_id" }`, which reconcile applies recursively to the nested `steps[]` array
diff --git a/packages/app/src/context/global-sync/event-reducer.ts b/packages/app/src/context/global-sync/event-reducer.ts
index bb97d479..a0a3615f 100644
--- a/packages/app/src/context/global-sync/event-reducer.ts
+++ b/packages/app/src/context/global-sync/event-reducer.ts
@@ -14,6 +14,10 @@ import type { State, VcsCache, SessionPlan, SessionGoal, SessionPlanUpdateOption
 import { trimSessions } from "./session-trim"
 import { dropSessionCaches } from "./session-cache"
 import { diffs as list, message as clean } from "@/utils/diffs"
+// BUG-407-012 root cause B: message/part arrays are kept in (time, id) chronological order, not
+// ID lexicographic order — the 6-byte ID time field wraps every 2^36 ms, so ID order alone is
+// not time order. Bare-ID events (remove/delta) must locate by identity scan, not binary search.
+import { findMessageIndex, findPartIndex, locateMessage, locatePart } from "@/utils/message-order"
 import { promptAdmissionClientMessageID } from "./prompt-admission"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
@@ -47,8 +51,15 @@ export function mergeMessage(current: Message, incoming: Message) {
     }
   if (!existing) return { message: incoming, conflict: false }
   if (!next) return { message: { ...incoming, activityProgress: existing }, conflict: false }
-  if (existing.activityID !== next.activityID || existing.revision !== next.revision)
+  if (existing.activityID !== next.activityID)
     return { message: { ...incoming, activityProgress: existing }, conflict: true }
+  // BUG-005: revisions are monotonic within one activity (server commits revision+1). The paged
+  // snapshot routinely lags behind the realtime stream, so a revision mismatch is staleness, not a
+  // conflict — take the higher revision instead of escalating to a whole-session force reload.
+  if (existing.revision !== next.revision)
+    return existing.revision > next.revision
+      ? { message: { ...incoming, activityProgress: existing }, conflict: false }
+      : { message: incoming, conflict: false }
   if (existing.state === next.state) return { message: incoming, conflict: false }
   const rank = (progress: ActivityProgress) =>
     progress.state === "provisional" ? 0 : progress.state === "progress" ? 1 : 2
@@ -274,8 +285,8 @@ export function applyDirectoryEvent(input: {
           produce((draft) => {
             const messages = draft.message[info.sessionID]
             if (messages) {
-              const result = Binary.search(messages, clientMessageID, (message) => message.id)
-              if (result.found) messages.splice(result.index, 1)
+              const index = findMessageIndex(messages, clientMessageID)
+              if (index !== -1) messages.splice(index, 1)
             }
             const parts = draft.part[clientMessageID]
             if (parts) {
@@ -290,7 +301,7 @@ export function applyDirectoryEvent(input: {
         input.setStore("message", info.sessionID, [info])
         break
       }
-      const result = Binary.search(messages, info.id, (m) => m.id)
+      const result = locateMessage(messages, info)
       if (result.found) {
         const existing = messages[result.index]!
         const merged = mergeMessage(existing, info)
@@ -321,8 +332,8 @@ export function applyDirectoryEvent(input: {
         produce((draft) => {
           const messages = draft.message[props.sessionID]
           if (messages) {
-            const result = Binary.search(messages, props.messageID, (m) => m.id)
-            if (result.found) messages.splice(result.index, 1)
+            const index = findMessageIndex(messages, props.messageID)
+            if (index !== -1) messages.splice(index, 1)
           }
           const parts = draft.part[props.messageID]
           if (parts) {
@@ -348,7 +359,7 @@ export function applyDirectoryEvent(input: {
         input.setStore("part", part.messageID, [part])
         break
       }
-      const result = Binary.search(parts, part.id, (p) => p.id)
+      const result = locatePart(parts, part)
       if (result.found) {
         input.setStore("part", part.messageID, result.index, reconcile(part))
         break
@@ -371,15 +382,15 @@ export function applyDirectoryEvent(input: {
       )
       const parts = input.store.part[props.messageID]
       if (!parts) break
-      const result = Binary.search(parts, props.partID, (p) => p.id)
-      if (result.found) {
+      const index = findPartIndex(parts, props.partID)
+      if (index !== -1) {
         input.setStore(
           produce((draft) => {
             const list = draft.part[props.messageID]
             if (!list) return
-            const next = Binary.search(list, props.partID, (p) => p.id)
-            if (!next.found) return
-            list.splice(next.index, 1)
+            const next = findPartIndex(list, props.partID)
+            if (next === -1) return
+            list.splice(next, 1)
             if (list.length === 0) delete draft.part[props.messageID]
           }),
         )
@@ -390,14 +401,14 @@ export function applyDirectoryEvent(input: {
       const props = event.properties as { messageID: string; partID: string; field: string; delta: string }
       const parts = input.store.part[props.messageID]
       if (!parts) break
-      const result = Binary.search(parts, props.partID, (p) => p.id)
-      if (!result.found) break
+      const index = findPartIndex(parts, props.partID)
+      if (index === -1) break
       input.setStore("part_text_accum_delta", props.partID, (existing) => (existing ?? "") + props.delta)
       input.setStore(
         "part",
         props.messageID,
         produce((draft) => {
-          const part = draft[result.index]
+          const part = draft[index]
           const field = props.field as keyof typeof part
           const existing = part[field] as string | undefined
           ;(part[field] as string) = (existing ?? "") + props.delta
diff --git a/packages/app/src/context/layout.tsx b/packages/app/src/context/layout.tsx
index 231fa23c..ff4e37c1 100644
--- a/packages/app/src/context/layout.tsx
+++ b/packages/app/src/context/layout.tsx
@@ -120,6 +120,8 @@ type SessionView = {
     | "profile"
     | "debug"
     | "im"
+    // PARITY-001: cross-session cost/token overview panel.
+    | "stats"
     | "oversight"
     // Movable panel views can also live in the side panel.
     | "terminal"
diff --git a/packages/app/src/context/models.tsx b/packages/app/src/context/models.tsx
index 030f0945..0607e900 100644
--- a/packages/app/src/context/models.tsx
+++ b/packages/app/src/context/models.tsx
@@ -1,9 +1,12 @@
-import { createMemo } from "solid-js"
+import { createMemo, onMount } from "solid-js"
 import { createStore } from "solid-js/store"
 import { DateTime } from "luxon"
 import { filter, firstBy, flat, groupBy, mapValues, pipe, uniqueBy, values } from "remeda"
 import { createSimpleContext } from "@deepagent-code/ui/context"
 import { useProviders } from "@/hooks/use-providers"
+import { useServerSync } from "@/context/server-sync"
+import { useLanguage } from "@/context/language"
+import { showToast } from "@/utils/toast"
 import { Persist, persisted } from "@/utils/persist"
 
 export type ModelKey = { providerID: string; modelID: string }
@@ -27,6 +30,8 @@ export const { use: useModels, provider: ModelsProvider } = createSimpleContext(
   gate: false,
   init: () => {
     const providers = useProviders()
+    const serverSync = useServerSync()
+    const language = useLanguage()
 
     const [store, setStore, _, ready] = persisted(
       Persist.global("model", ["model.v1"]),
@@ -87,9 +92,45 @@ export const { use: useModels, provider: ModelsProvider } = createSimpleContext(
 
     const latestSet = createMemo(() => new Set(latest().map((x) => modelKey(x))))
 
+    // PARITY-004 / GUI 批 — 模型启停服务端真相源:可见性(启/停)的权威来源是服务端 config
+    // `provider[pID].models[mID].disabled`(plugin/provider.ts 已映射 model.enabled=!disabled)。
+    // localStorage(store.user)仅作迁移来源与乐观缓存,不再是真相。
+    const serverDisabled = (model: ModelKey): boolean | undefined => {
+      const provider = serverSync.data.config.provider?.[model.providerID]
+      const disabled = provider?.models?.[model.modelID]?.disabled
+      return typeof disabled === "boolean" ? disabled : undefined
+    }
+
+    const setServerDisabled = async (model: ModelKey, disabled: boolean) => {
+      const config = serverSync.data.config
+      const provider = config.provider?.[model.providerID]
+      const current = provider?.models?.[model.modelID]
+      await serverSync.updateConfig({
+        ...config,
+        provider: {
+          ...config.provider,
+          [model.providerID]: {
+            ...provider,
+            models: {
+              ...provider?.models,
+              [model.modelID]: { ...current, disabled },
+            },
+          },
+        },
+      })
+    }
+
     const visibility = createMemo(() => {
       const map = new Map<string, Visibility>()
+      // localStorage 先铺底(迁移前的旧值)
       for (const item of store.user) map.set(`${item.providerID}:${item.modelID}`, item.visibility)
+      // 服务端真相覆盖(权威)
+      for (const model of available()) {
+        const key = `${model.provider.id}:${model.id}`
+        const disabled = serverDisabled({ providerID: model.provider.id, modelID: model.id })
+        if (disabled === true) map.set(key, "hide")
+        else if (disabled === false) map.set(key, "show")
+      }
       return map
     })
 
@@ -115,14 +156,36 @@ export const { use: useModels, provider: ModelsProvider } = createSimpleContext(
     const find = (key: ModelKey) => list().find((m) => m.id === key.modelID && m.provider.id === key.providerID)
 
     function update(model: ModelKey, state: Visibility) {
+      // 乐观写 localStorage(即时 UI),真相异步写服务端 config。
+      const key = modelKey(model)
       const index = store.user.findIndex((x) => x.modelID === model.modelID && x.providerID === model.providerID)
       if (index >= 0) {
         setStore("user", index, (current) => ({ ...current, visibility: state }))
-        return
+      } else {
+        setStore("user", store.user.length, { ...model, visibility: state })
       }
-      setStore("user", store.user.length, { ...model, visibility: state })
+      void setServerDisabled(model, state === "hide").catch(() => {
+        // 服务端写失败:回滚乐观态——移除该 model 的本地覆盖,visibility 回落到服务端真相/默认。
+        setStore("user", (items) => items.filter((item) => modelKey(item) !== key))
+        showToast({ title: language.t("common.requestFailed") })
+      })
     }
 
+    // 一次性迁移:把 localStorage 里的显式 show/hide 上收服务端,随后服务端即真相。
+    onMount(() => {
+      const pending = store.user.slice()
+      if (pending.length === 0) return
+      void (async () => {
+        for (const item of pending) {
+          if (serverDisabled({ providerID: item.providerID, modelID: item.modelID }) !== undefined) continue
+          await setServerDisabled({ providerID: item.providerID, modelID: item.modelID }, item.visibility === "hide").catch(
+            () => undefined,
+          )
+        }
+        setStore("user", [])
+      })()
+    })
+
     const visible = (model: ModelKey) => {
       const key = modelKey(model)
       const state = visibility().get(key)
diff --git a/packages/app/src/context/permission-auto-respond.ts b/packages/app/src/context/permission-auto-respond.ts
index 38670af2..3347f5f0 100644
--- a/packages/app/src/context/permission-auto-respond.ts
+++ b/packages/app/src/context/permission-auto-respond.ts
@@ -1,5 +1,10 @@
 import { base64Encode } from "@deepagent-code/core/util/encode"
 
+// Mutating-tool set is shared with the CLI read-only mode (PARITY-002): the
+// GUI directory read-only guard and `run --permission-mode read-only` must
+// agree on which permissions are denied, so the constant lives in core.
+export { MUTATING_PERMISSIONS, isMutatingPermission } from "@deepagent-code/core/permission/mutating"
+
 export function acceptKey(sessionID: string, directory?: string) {
   if (!directory) return sessionID
   return `${base64Encode(directory)}/${sessionID}`
@@ -16,15 +21,6 @@ export function isDirectoryReadOnly(readOnly: Record<string, boolean>, directory
   return readOnly[key] ?? false
 }
 
-// Tools that write, execute, or otherwise mutate state — denied in read-only mode.
-// Everything else (read/glob/grep/list/lsp/webfetch/websearch/todowrite/…) is left to the
-// normal permission flow so the agent can still inspect the workspace.
-const MUTATING_PERMISSIONS = new Set(["edit", "write", "patch", "bash", "task", "external_directory"])
-
-export function isMutatingPermission(permission: string) {
-  return MUTATING_PERMISSIONS.has(permission)
-}
-
 function accepted(autoAccept: Record<string, boolean>, sessionID: string, directory?: string) {
   const key = acceptKey(sessionID, directory)
   const directoryKey = directory ? directoryAcceptKey(directory) : undefined
diff --git a/packages/app/src/i18n/ar.ts b/packages/app/src/i18n/ar.ts
index f94a0fe2..ca692879 100644
--- a/packages/app/src/i18n/ar.ts
+++ b/packages/app/src/i18n/ar.ts
@@ -499,6 +499,8 @@ export const dict = {
   "session.share.popover.description.shared": "هذه الجلسة عامة على الويب. يمكن لأي شخص لديه الرابط الوصول إليها.",
   "session.share.popover.description.unshared": "شارك الجلسة علنًا على الويب. ستكون متاحة لأي شخص لديه الرابط.",
   "session.share.action.share": "مشاركة",
+  "session.export.action": "تصدير اللقطة",
+  "session.export.success": "تم تصدير لقطة الجلسة",
   "session.share.action.publish": "نشر",
   "session.share.action.publishing": "جارٍ النشر...",
   "session.share.action.unpublish": "إلغاء النشر",
@@ -518,6 +520,7 @@ export const dict = {
   "common.closeTab": "إغلاق علامة التبويب",
   "common.dismiss": "رفض",
   "common.requestFailed": "فشل الطلب",
+  "common.active": "نشط",
   "common.moreOptions": "مزيد من الخيارات",
   "common.learnMore": "اعرف المزيد",
   "common.rename": "إعادة تسمية",
@@ -682,6 +685,14 @@ export const dict = {
   "settings.providers.section.connected": "الموفرون المتصلون",
   "settings.providers.connected.empty": "لا يوجد موفرون متصلون",
   "settings.providers.section.popular": "الموفرون الشائعون",
+  "settings.providers.section.consoleAccount": "حساب Console",
+  "settings.providers.console.activeOrg": "المنظمة النشطة",
+  "settings.providers.console.noOrg": "لم يتم اختيار منظمة",
+  "settings.providers.console.switchOrg": "تبديل المنظمة",
+  "settings.providers.console.empty": "لا توجد مؤسسات Console قابلة للتبديل",
+  "settings.providers.console.managedCount": "{{count}} من مزودي الخدمة المدارة عبر Console",
+  "settings.providers.console.switch.toast.title": "تم تبديل منظمة Console",
+  "settings.providers.console.switch.toast.description": "الآن يتم استخدام {{org}}",
   "settings.providers.tag.environment": "البيئة",
   "settings.providers.tag.config": "التكوين",
   "settings.providers.tag.custom": "مخصص",
@@ -857,6 +868,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (لقطة)",
+  "settings.import.snapshot.file": "حزمة اللقطة",
+  "settings.import.snapshot.file.hint": "اختر حزمة لقطة الجلسة المصدّرة (.json). سيتم استيرادها كجلسة جديدة قابلة للمتابعة.",
+  "settings.import.snapshot.noFile": "اختر ملف حزمة اللقطة أولاً",
+  "settings.import.snapshot.done": "تم استيراد اللقطة كجلسة جديدة قابلة للمتابعة",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/br.ts b/packages/app/src/i18n/br.ts
index 31699b30..115fbede 100644
--- a/packages/app/src/i18n/br.ts
+++ b/packages/app/src/i18n/br.ts
@@ -505,6 +505,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Compartilhar sessão publicamente na web. Estará acessível para qualquer pessoa com o link.",
   "session.share.action.share": "Compartilhar",
+  "session.export.action": "Exportar snapshot",
+  "session.export.success": "Snapshot de sessao exportado",
   "session.share.action.publish": "Publicar",
   "session.share.action.publishing": "Publicando...",
   "session.share.action.unpublish": "Cancelar publicação",
@@ -525,6 +527,7 @@ export const dict = {
   "common.closeTab": "Fechar aba",
   "common.dismiss": "Descartar",
   "common.requestFailed": "Requisição falhou",
+  "common.active": "Ativa",
   "common.moreOptions": "Mais opções",
   "common.learnMore": "Saiba mais",
   "common.rename": "Renomear",
@@ -694,6 +697,14 @@ export const dict = {
   "settings.providers.section.connected": "Provedores conectados",
   "settings.providers.connected.empty": "Nenhum provedor conectado",
   "settings.providers.section.popular": "Provedores populares",
+  "settings.providers.section.consoleAccount": "Conta Console",
+  "settings.providers.console.activeOrg": "Organização ativa",
+  "settings.providers.console.noOrg": "Nenhuma organização selecionada",
+  "settings.providers.console.switchOrg": "Trocar organização",
+  "settings.providers.console.empty": "Nenhuma organização Console disponível para troca",
+  "settings.providers.console.managedCount": "{{count}} provedores gerenciados pelo Console",
+  "settings.providers.console.switch.toast.title": "Organização Console trocada",
+  "settings.providers.console.switch.toast.description": "Agora usando {{org}}",
   "settings.providers.tag.environment": "Ambiente",
   "settings.providers.tag.config": "Configuração",
   "settings.providers.tag.custom": "Personalizado",
@@ -871,6 +882,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (snapshot)",
+  "settings.import.snapshot.file": "Pacote de snapshot",
+  "settings.import.snapshot.file.hint": "Escolha um pacote de snapshot de sessao exportado (.json). Ele sera importado como uma nova sessao continuavel.",
+  "settings.import.snapshot.noFile": "Escolha primeiro um arquivo de pacote de snapshot",
+  "settings.import.snapshot.done": "Snapshot importado como uma nova sessao continuavel",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/bs.ts b/packages/app/src/i18n/bs.ts
index d97be89f..a8285882 100644
--- a/packages/app/src/i18n/bs.ts
+++ b/packages/app/src/i18n/bs.ts
@@ -563,6 +563,8 @@ export const dict = {
   "session.share.popover.description.shared": "Ova sesija je javna na webu. Dostupna je svima koji imaju link.",
   "session.share.popover.description.unshared": "Podijeli sesiju javno na webu. Biće dostupna svima koji imaju link.",
   "session.share.action.share": "Podijeli",
+  "session.export.action": "Izvezi snimak",
+  "session.export.success": "Snimak sesije izvezen",
   "session.share.action.publish": "Objavi",
   "session.share.action.publishing": "Objavljivanje...",
   "session.share.action.unpublish": "Poništi objavu",
@@ -586,6 +588,7 @@ export const dict = {
   "common.closeTab": "Zatvori karticu",
   "common.dismiss": "Odbaci",
   "common.requestFailed": "Zahtjev nije uspio",
+  "common.active": "Aktivna",
   "common.moreOptions": "Više opcija",
   "common.learnMore": "Saznaj više",
   "common.rename": "Preimenuj",
@@ -766,6 +769,14 @@ export const dict = {
   "settings.providers.section.connected": "Povezani provajderi",
   "settings.providers.connected.empty": "Nema povezanih provajdera",
   "settings.providers.section.popular": "Popularni provajderi",
+  "settings.providers.section.consoleAccount": "Console račun",
+  "settings.providers.console.activeOrg": "Aktivna organizacija",
+  "settings.providers.console.noOrg": "Nije odabrana organizacija",
+  "settings.providers.console.switchOrg": "Promijeni organizaciju",
+  "settings.providers.console.empty": "Nema Console organizacija za promjenu",
+  "settings.providers.console.managedCount": "{{count}} provajdera kojima upravlja Console",
+  "settings.providers.console.switch.toast.title": "Console organizacija promijenjena",
+  "settings.providers.console.switch.toast.description": "Sada se koristi {{org}}",
   "settings.providers.tag.environment": "Okruženje",
   "settings.providers.tag.config": "Konfiguracija",
   "settings.providers.tag.custom": "Prilagođeno",
@@ -948,6 +959,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (snimak)",
+  "settings.import.snapshot.file": "Paket snimka",
+  "settings.import.snapshot.file.hint": "Odaberite izvezeni paket snimka sesije (.json). Bice uvezen kao nova nastavljiva sesija.",
+  "settings.import.snapshot.noFile": "Prvo odaberite datoteku paketa snimka",
+  "settings.import.snapshot.done": "Snimak uvezen kao nova nastavljiva sesija",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/da.ts b/packages/app/src/i18n/da.ts
index b725d224..66a68347 100644
--- a/packages/app/src/i18n/da.ts
+++ b/packages/app/src/i18n/da.ts
@@ -560,6 +560,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Del session offentligt på nettet. Den vil være tilgængelig for alle med linket.",
   "session.share.action.share": "Del",
+  "session.export.action": "Eksporter snapshot",
+  "session.export.success": "Sessions-snapshot eksporteret",
   "session.share.action.publish": "Udgiv",
   "session.share.action.publishing": "Udgiver...",
   "session.share.action.unpublish": "Afpublicer",
@@ -582,6 +584,7 @@ export const dict = {
   "common.closeTab": "Luk fane",
   "common.dismiss": "Afvis",
   "common.requestFailed": "Forespørgsel mislykkedes",
+  "common.active": "Aktiv",
   "common.moreOptions": "Flere muligheder",
   "common.learnMore": "Lær mere",
   "common.rename": "Omdøb",
@@ -759,6 +762,14 @@ export const dict = {
   "settings.providers.section.connected": "Forbundne udbydere",
   "settings.providers.connected.empty": "Ingen forbundne udbydere",
   "settings.providers.section.popular": "Populære udbydere",
+  "settings.providers.section.consoleAccount": "Console-konto",
+  "settings.providers.console.activeOrg": "Aktiv organisation",
+  "settings.providers.console.noOrg": "Ingen organisation valgt",
+  "settings.providers.console.switchOrg": "Skift organisation",
+  "settings.providers.console.empty": "Ingen Console-organisationer at skifte mellem",
+  "settings.providers.console.managedCount": "{{count}} Console-administrerede udbydere",
+  "settings.providers.console.switch.toast.title": "Console-organisation skiftet",
+  "settings.providers.console.switch.toast.description": "Bruger nu {{org}}",
   "settings.providers.tag.environment": "Miljø",
   "settings.providers.tag.config": "Konfiguration",
   "settings.providers.tag.custom": "Brugerdefineret",
@@ -941,6 +952,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (snapshot)",
+  "settings.import.snapshot.file": "Snapshot-bundle",
+  "settings.import.snapshot.file.hint": "Vaelg en eksporteret sessions-snapshot-bundle (.json). Den importeres som en ny fortsaetbar session.",
+  "settings.import.snapshot.noFile": "Vaelg foerst en snapshot-bundle-fil",
+  "settings.import.snapshot.done": "Snapshot importeret som en ny fortsaetbar session",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/de.ts b/packages/app/src/i18n/de.ts
index f1972566..4c141d1b 100644
--- a/packages/app/src/i18n/de.ts
+++ b/packages/app/src/i18n/de.ts
@@ -513,6 +513,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Sitzung öffentlich im Web teilen. Sie wird für jeden mit dem Link zugänglich sein.",
   "session.share.action.share": "Teilen",
+  "session.export.action": "Snapshot exportieren",
+  "session.export.success": "Session-Snapshot exportiert",
   "session.share.action.publish": "Veröffentlichen",
   "session.share.action.publishing": "Veröffentliche...",
   "session.share.action.unpublish": "Veröffentlichung aufheben",
@@ -533,6 +535,7 @@ export const dict = {
   "common.closeTab": "Tab schließen",
   "common.dismiss": "Verwerfen",
   "common.requestFailed": "Anfrage fehlgeschlagen",
+  "common.active": "Aktiv",
   "common.moreOptions": "Weitere Optionen",
   "common.learnMore": "Mehr erfahren",
   "common.rename": "Umbenennen",
@@ -704,6 +707,14 @@ export const dict = {
   "settings.providers.section.connected": "Verbundene Anbieter",
   "settings.providers.connected.empty": "Keine verbundenen Anbieter",
   "settings.providers.section.popular": "Beliebte Anbieter",
+  "settings.providers.section.consoleAccount": "Console-Konto",
+  "settings.providers.console.activeOrg": "Aktive Organisation",
+  "settings.providers.console.noOrg": "Keine Organisation ausgewählt",
+  "settings.providers.console.switchOrg": "Organisation wechseln",
+  "settings.providers.console.empty": "Keine wechselbaren Console-Organisationen",
+  "settings.providers.console.managedCount": "{{count}} Console-verwaltete Anbieter",
+  "settings.providers.console.switch.toast.title": "Console-Organisation gewechselt",
+  "settings.providers.console.switch.toast.description": "Jetzt wird {{org}} verwendet",
   "settings.providers.tag.environment": "Umgebung",
   "settings.providers.tag.config": "Konfiguration",
   "settings.providers.tag.custom": "Benutzerdefiniert",
@@ -887,6 +898,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (Snapshot)",
+  "settings.import.snapshot.file": "Snapshot-Bundle",
+  "settings.import.snapshot.file.hint": "Waehlen Sie ein exportiertes Session-Snapshot-Bundle (.json). Es wird als neue fortsetzbare Sitzung importiert.",
+  "settings.import.snapshot.noFile": "Waehlen Sie zuerst eine Snapshot-Bundle-Datei",
+  "settings.import.snapshot.done": "Snapshot als neue fortsetzbare Sitzung importiert",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/en.ts b/packages/app/src/i18n/en.ts
index 1882e11d..368fe42d 100644
--- a/packages/app/src/i18n/en.ts
+++ b/packages/app/src/i18n/en.ts
@@ -1023,6 +1023,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Share session publicly on the web. It will be accessible to anyone with the link.",
   "session.share.action.share": "Share",
+  "session.export.action": "Export snapshot",
+  "session.export.success": "Session snapshot exported",
   "session.share.action.publish": "Publish",
   "session.share.action.publishing": "Publishing...",
   "session.share.action.unpublish": "Unpublish",
@@ -1060,6 +1062,7 @@ export const dict = {
   "common.dismiss": "Dismiss",
   "common.moreCountSuffix": " (+{{count}} more)",
   "common.requestFailed": "Request failed",
+  "common.active": "Active",
   "common.moreOptions": "More options",
   "common.learnMore": "Learn more",
   "common.rename": "Rename",
@@ -1174,6 +1177,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (snapshot)",
+  "settings.import.snapshot.file": "Snapshot bundle",
+  "settings.import.snapshot.file.hint": "Choose an exported session snapshot bundle (.json). It imports as a new continuable session.",
+  "settings.import.snapshot.noFile": "Choose a snapshot bundle file first",
+  "settings.import.snapshot.done": "Snapshot imported as a new continuable session",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
@@ -1483,6 +1491,14 @@ export const dict = {
   "settings.providers.connected.empty": "No connected providers",
   "settings.providers.connected.environmentDescription": "Connected from your environment variables",
   "settings.providers.section.popular": "Popular providers",
+  "settings.providers.section.consoleAccount": "Console account",
+  "settings.providers.console.activeOrg": "Active organization",
+  "settings.providers.console.noOrg": "No organization selected",
+  "settings.providers.console.switchOrg": "Switch organization",
+  "settings.providers.console.empty": "No switchable Console organizations",
+  "settings.providers.console.managedCount": "{{count}} Console-managed providers",
+  "settings.providers.console.switch.toast.title": "Switched Console organization",
+  "settings.providers.console.switch.toast.description": "Now using {{org}}",
   "settings.providers.custom.description": "Add an OpenAI-compatible provider by base URL.",
   "settings.providers.tag.environment": "Environment",
   "settings.providers.tag.config": "Config",
@@ -1601,6 +1617,22 @@ export const dict = {
   "session.context.copyRef": "Copy stable reference",
   "session.context.provenance": "Provenance",
   "session.context.relations": "Relations",
+  "session.stats.title": "Usage & cost",
+  "session.stats.overview": "Overview",
+  "session.stats.sessions": "Sessions",
+  "session.stats.days": "Days",
+  "session.stats.costTokens": "Cost & tokens",
+  "session.stats.totalCost": "Total cost",
+  "session.stats.costPerDay": "Avg cost/day",
+  "session.stats.tokensPerSession": "Avg tokens/session",
+  "session.stats.medianTokens": "Median tokens/session",
+  "session.stats.input": "Input",
+  "session.stats.output": "Output",
+  "session.stats.reasoning": "Reasoning",
+  "session.stats.cacheRead": "Cache read",
+  "session.stats.cacheWrite": "Cache write",
+  "session.stats.modelUsage": "Model usage",
+  "session.stats.noData": "No session usage data yet.",
   "session.context.summary.complete": "Complete",
   "session.context.summary.partial": "Partial",
   "session.context.summary.empty": "Empty",
diff --git a/packages/app/src/i18n/es.ts b/packages/app/src/i18n/es.ts
index 0d6b9085..bdbbf99d 100644
--- a/packages/app/src/i18n/es.ts
+++ b/packages/app/src/i18n/es.ts
@@ -566,6 +566,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Compartir sesión públicamente en la web. Será accesible para cualquiera con el enlace.",
   "session.share.action.share": "Compartir",
+  "session.export.action": "Exportar instantanea",
+  "session.export.success": "Instantanea de sesion exportada",
   "session.share.action.publish": "Publicar",
   "session.share.action.publishing": "Publicando...",
   "session.share.action.unpublish": "Despublicar",
@@ -589,6 +591,7 @@ export const dict = {
   "common.closeTab": "Cerrar pestaña",
   "common.dismiss": "Descartar",
   "common.requestFailed": "Solicitud fallida",
+  "common.active": "Activa",
   "common.moreOptions": "Más opciones",
   "common.learnMore": "Saber más",
   "common.rename": "Renombrar",
@@ -772,6 +775,14 @@ export const dict = {
   "settings.providers.section.connected": "Proveedores conectados",
   "settings.providers.connected.empty": "No hay proveedores conectados",
   "settings.providers.section.popular": "Proveedores populares",
+  "settings.providers.section.consoleAccount": "Cuenta de Console",
+  "settings.providers.console.activeOrg": "Organización activa",
+  "settings.providers.console.noOrg": "Ninguna organización seleccionada",
+  "settings.providers.console.switchOrg": "Cambiar organización",
+  "settings.providers.console.empty": "No hay organizaciones de Console intercambiables",
+  "settings.providers.console.managedCount": "{{count}} proveedores gestionados por Console",
+  "settings.providers.console.switch.toast.title": "Organización de Console cambiada",
+  "settings.providers.console.switch.toast.description": "Ahora usando {{org}}",
   "settings.providers.tag.environment": "Entorno",
   "settings.providers.tag.config": "Configuración",
   "settings.providers.tag.custom": "Personalizado",
@@ -954,6 +965,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (instantanea)",
+  "settings.import.snapshot.file": "Paquete de instantanea",
+  "settings.import.snapshot.file.hint": "Elija un paquete de instantanea de sesion exportado (.json). Se importara como una nueva sesion continuable.",
+  "settings.import.snapshot.noFile": "Elija primero un archivo de paquete de instantanea",
+  "settings.import.snapshot.done": "Instantanea importada como una nueva sesion continuable",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/fr.ts b/packages/app/src/i18n/fr.ts
index 93df50ca..275ec09e 100644
--- a/packages/app/src/i18n/fr.ts
+++ b/packages/app/src/i18n/fr.ts
@@ -510,6 +510,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Partager la session publiquement sur le web. Elle sera accessible à toute personne disposant du lien.",
   "session.share.action.share": "Partager",
+  "session.export.action": "Exporter le snapshot",
+  "session.export.success": "Snapshot de session exporte",
   "session.share.action.publish": "Publier",
   "session.share.action.publishing": "Publication...",
   "session.share.action.unpublish": "Dépublier",
@@ -530,6 +532,7 @@ export const dict = {
   "common.closeTab": "Fermer l'onglet",
   "common.dismiss": "Ignorer",
   "common.requestFailed": "La demande a échoué",
+  "common.active": "Active",
   "common.moreOptions": "Plus d'options",
   "common.learnMore": "En savoir plus",
   "common.rename": "Renommer",
@@ -701,6 +704,14 @@ export const dict = {
   "settings.providers.section.connected": "Fournisseurs connectés",
   "settings.providers.connected.empty": "Aucun fournisseur connecté",
   "settings.providers.section.popular": "Fournisseurs populaires",
+  "settings.providers.section.consoleAccount": "Compte Console",
+  "settings.providers.console.activeOrg": "Organisation active",
+  "settings.providers.console.noOrg": "Aucune organisation sélectionnée",
+  "settings.providers.console.switchOrg": "Changer d'organisation",
+  "settings.providers.console.empty": "Aucune organisation Console commutable",
+  "settings.providers.console.managedCount": "{{count}} fournisseurs gérés par Console",
+  "settings.providers.console.switch.toast.title": "Organisation Console changée",
+  "settings.providers.console.switch.toast.description": "Utilisation de {{org}}",
   "settings.providers.tag.environment": "Environnement",
   "settings.providers.tag.config": "Configuration",
   "settings.providers.tag.custom": "Personnalisé",
@@ -881,6 +892,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (snapshot)",
+  "settings.import.snapshot.file": "Bundle de snapshot",
+  "settings.import.snapshot.file.hint": "Choisissez un bundle de snapshot de session exporte (.json). Il sera importe comme une nouvelle session continuable.",
+  "settings.import.snapshot.noFile": "Choisissez d'abord un fichier de bundle de snapshot",
+  "settings.import.snapshot.done": "Snapshot importe comme une nouvelle session continuable",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/ja.ts b/packages/app/src/i18n/ja.ts
index c79ca0f3..ce79c81d 100644
--- a/packages/app/src/i18n/ja.ts
+++ b/packages/app/src/i18n/ja.ts
@@ -504,6 +504,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "セッションをウェブで公開します。リンクを知っている人なら誰でもアクセスできるようになります。",
   "session.share.action.share": "共有",
+  "session.export.action": "スナップショットをエクスポート",
+  "session.export.success": "セッションスナップショットをエクスポートしました",
   "session.share.action.publish": "公開",
   "session.share.action.publishing": "公開中...",
   "session.share.action.unpublish": "非公開にする",
@@ -524,6 +526,7 @@ export const dict = {
   "common.closeTab": "タブを閉じる",
   "common.dismiss": "閉じる",
   "common.requestFailed": "リクエスト失敗",
+  "common.active": "アクティブ",
   "common.moreOptions": "その他のオプション",
   "common.learnMore": "詳細",
   "common.rename": "名前変更",
@@ -692,6 +695,14 @@ export const dict = {
   "settings.providers.section.connected": "接続済みプロバイダー",
   "settings.providers.connected.empty": "接続済みプロバイダーはありません",
   "settings.providers.section.popular": "人気のプロバイダー",
+  "settings.providers.section.consoleAccount": "Console アカウント",
+  "settings.providers.console.activeOrg": "アクティブな組織",
+  "settings.providers.console.noOrg": "組織が選択されていません",
+  "settings.providers.console.switchOrg": "組織を切り替え",
+  "settings.providers.console.empty": "切り替え可能な Console 組織がありません",
+  "settings.providers.console.managedCount": "Console 管理のプロバイダー {{count}} 件",
+  "settings.providers.console.switch.toast.title": "Console 組織を切り替えました",
+  "settings.providers.console.switch.toast.description": "現在 {{org}} を使用中",
   "settings.providers.tag.environment": "環境",
   "settings.providers.tag.config": "設定",
   "settings.providers.tag.custom": "カスタム",
@@ -867,6 +878,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code（スナップショット）",
+  "settings.import.snapshot.file": "スナップショットバンドル",
+  "settings.import.snapshot.file.hint": "エクスポートされたセッションスナップショットバンドル（.json）を選択してください。継続可能な新しいセッションとしてインポートされます。",
+  "settings.import.snapshot.noFile": "先にスナップショットバンドルファイルを選択してください",
+  "settings.import.snapshot.done": "スナップショットは継続可能な新しいセッションとしてインポートされました",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/ko.ts b/packages/app/src/i18n/ko.ts
index 1b742aee..8d2b4079 100644
--- a/packages/app/src/i18n/ko.ts
+++ b/packages/app/src/i18n/ko.ts
@@ -500,6 +500,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "세션을 웹에 공개적으로 공유합니다. 링크가 있는 누구나 액세스할 수 있습니다.",
   "session.share.action.share": "공유",
+  "session.export.action": "스냅샷 내보내기",
+  "session.export.success": "세션 스냅샷을 내보냈습니다",
   "session.share.action.publish": "게시",
   "session.share.action.publishing": "게시 중...",
   "session.share.action.unpublish": "게시 취소",
@@ -520,6 +522,7 @@ export const dict = {
   "common.closeTab": "탭 닫기",
   "common.dismiss": "닫기",
   "common.requestFailed": "요청 실패",
+  "common.active": "활성",
   "common.moreOptions": "더 많은 옵션",
   "common.learnMore": "더 알아보기",
   "common.rename": "이름 바꾸기",
@@ -685,6 +688,14 @@ export const dict = {
   "settings.providers.section.connected": "연결된 공급자",
   "settings.providers.connected.empty": "연결된 공급자 없음",
   "settings.providers.section.popular": "인기 공급자",
+  "settings.providers.section.consoleAccount": "Console 계정",
+  "settings.providers.console.activeOrg": "활성 조직",
+  "settings.providers.console.noOrg": "선택된 조직 없음",
+  "settings.providers.console.switchOrg": "조직 전환",
+  "settings.providers.console.empty": "전환 가능한 Console 조직 없음",
+  "settings.providers.console.managedCount": "Console 관리 공급자 {{count}}개",
+  "settings.providers.console.switch.toast.title": "Console 조직 전환됨",
+  "settings.providers.console.switch.toast.description": "현재 {{org}} 사용 중",
   "settings.providers.tag.environment": "환경",
   "settings.providers.tag.config": "구성",
   "settings.providers.tag.custom": "사용자 지정",
@@ -860,6 +871,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code(스냅샷)",
+  "settings.import.snapshot.file": "스냅샷 번들",
+  "settings.import.snapshot.file.hint": "내보낸 세션 스냅샷 번들(.json)을 선택하세요. 계속할 수 있는 새 세션으로 가져옵니다.",
+  "settings.import.snapshot.noFile": "먼저 스냅샷 번들 파일을 선택하세요",
+  "settings.import.snapshot.done": "스냅샷을 계속할 수 있는 새 세션으로 가져왔습니다",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/no.ts b/packages/app/src/i18n/no.ts
index d0a87222..fe2a2e81 100644
--- a/packages/app/src/i18n/no.ts
+++ b/packages/app/src/i18n/no.ts
@@ -566,6 +566,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Del sesjonen offentlig på nettet. Den vil være tilgjengelig for alle med lenken.",
   "session.share.action.share": "Del",
+  "session.export.action": "Eksporter snapshot",
+  "session.export.success": "Okt-snapshot eksportert",
   "session.share.action.publish": "Publiser",
   "session.share.action.publishing": "Publiserer...",
   "session.share.action.unpublish": "Avpubliser",
@@ -589,6 +591,7 @@ export const dict = {
   "common.closeTab": "Lukk fane",
   "common.dismiss": "Avvis",
   "common.requestFailed": "Forespørsel mislyktes",
+  "common.active": "Aktiv",
   "common.moreOptions": "Flere alternativer",
   "common.learnMore": "Lær mer",
   "common.rename": "Gi nytt navn",
@@ -766,6 +769,14 @@ export const dict = {
   "settings.providers.section.connected": "Tilkoblede leverandører",
   "settings.providers.connected.empty": "Ingen tilkoblede leverandører",
   "settings.providers.section.popular": "Populære leverandører",
+  "settings.providers.section.consoleAccount": "Console-konto",
+  "settings.providers.console.activeOrg": "Aktiv organisasjon",
+  "settings.providers.console.noOrg": "Ingen organisasjon valgt",
+  "settings.providers.console.switchOrg": "Bytt organisasjon",
+  "settings.providers.console.empty": "Ingen Console-organisasjoner å bytte mellom",
+  "settings.providers.console.managedCount": "{{count}} Console-administrerte leverandører",
+  "settings.providers.console.switch.toast.title": "Console-organisasjon byttet",
+  "settings.providers.console.switch.toast.description": "Bruker nå {{org}}",
   "settings.providers.tag.environment": "Miljø",
   "settings.providers.tag.config": "Konfigurasjon",
   "settings.providers.tag.custom": "Tilpasset",
@@ -953,6 +964,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (snapshot)",
+  "settings.import.snapshot.file": "Snapshot-bundle",
+  "settings.import.snapshot.file.hint": "Velg en eksportert okt-snapshot-bundle (.json). Den importeres som en ny fortsettbar okt.",
+  "settings.import.snapshot.noFile": "Velg foerst en snapshot-bundle-fil",
+  "settings.import.snapshot.done": "Snapshot importert som en ny fortsettbar okt",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/pl.ts b/packages/app/src/i18n/pl.ts
index ea9daff2..76ed195a 100644
--- a/packages/app/src/i18n/pl.ts
+++ b/packages/app/src/i18n/pl.ts
@@ -504,6 +504,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Udostępnij sesję publicznie w sieci. Będzie dostępna dla każdego, kto posiada link.",
   "session.share.action.share": "Udostępnij",
+  "session.export.action": "Eksportuj migawke",
+  "session.export.success": "Migawka sesji wyeksportowana",
   "session.share.action.publish": "Opublikuj",
   "session.share.action.publishing": "Publikowanie...",
   "session.share.action.unpublish": "Cofnij publikację",
@@ -524,6 +526,7 @@ export const dict = {
   "common.closeTab": "Zamknij kartę",
   "common.dismiss": "Odrzuć",
   "common.requestFailed": "Żądanie nie powiodło się",
+  "common.active": "Aktywna",
   "common.moreOptions": "Więcej opcji",
   "common.learnMore": "Dowiedz się więcej",
   "common.rename": "Zmień nazwę",
@@ -693,6 +696,14 @@ export const dict = {
   "settings.providers.section.connected": "Połączeni dostawcy",
   "settings.providers.connected.empty": "Brak połączonych dostawców",
   "settings.providers.section.popular": "Popularni dostawcy",
+  "settings.providers.section.consoleAccount": "Konto Console",
+  "settings.providers.console.activeOrg": "Aktywna organizacja",
+  "settings.providers.console.noOrg": "Nie wybrano organizacji",
+  "settings.providers.console.switchOrg": "Przełącz organizację",
+  "settings.providers.console.empty": "Brak organizacji Console do przełączenia",
+  "settings.providers.console.managedCount": "{{count}} dostawców zarządzanych przez Console",
+  "settings.providers.console.switch.toast.title": "Przełączono organizację Console",
+  "settings.providers.console.switch.toast.description": "Teraz używany jest {{org}}",
   "settings.providers.tag.environment": "Środowisko",
   "settings.providers.tag.config": "Konfiguracja",
   "settings.providers.tag.custom": "Niestandardowe",
@@ -870,6 +881,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (migawka)",
+  "settings.import.snapshot.file": "Pakiet migawki",
+  "settings.import.snapshot.file.hint": "Wybierz wyeksportowany pakiet migawki sesji (.json). Zostanie zaimportowany jako nowa kontynuowalna sesja.",
+  "settings.import.snapshot.noFile": "Najpierw wybierz plik pakietu migawki",
+  "settings.import.snapshot.done": "Migawka zaimportowana jako nowa kontynuowalna sesja",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/ru.ts b/packages/app/src/i18n/ru.ts
index 7e599757..20609699 100644
--- a/packages/app/src/i18n/ru.ts
+++ b/packages/app/src/i18n/ru.ts
@@ -562,6 +562,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Опубликуйте сессию в интернете. Доступ к ней сможет получить любой, у кого есть ссылка.",
   "session.share.action.share": "Поделиться",
+  "session.export.action": "Экспортировать снапшот",
+  "session.export.success": "Снапшот сессии экспортирован",
   "session.share.action.publish": "Опубликовать",
   "session.share.action.publishing": "Публикация...",
   "session.share.action.unpublish": "Отменить публикацию",
@@ -585,6 +587,7 @@ export const dict = {
   "common.closeTab": "Закрыть вкладку",
   "common.dismiss": "Закрыть",
   "common.requestFailed": "Запрос не выполнен",
+  "common.active": "Активна",
   "common.moreOptions": "Дополнительные опции",
   "common.learnMore": "Подробнее",
   "common.rename": "Переименовать",
@@ -767,6 +770,14 @@ export const dict = {
   "settings.providers.section.connected": "Подключённые провайдеры",
   "settings.providers.connected.empty": "Нет подключённых провайдеров",
   "settings.providers.section.popular": "Популярные провайдеры",
+  "settings.providers.section.consoleAccount": "Аккаунт Console",
+  "settings.providers.console.activeOrg": "Активная организация",
+  "settings.providers.console.noOrg": "Организация не выбрана",
+  "settings.providers.console.switchOrg": "Сменить организацию",
+  "settings.providers.console.empty": "Нет доступных для переключения организаций Console",
+  "settings.providers.console.managedCount": "Провайдеров под управлением Console: {{count}}",
+  "settings.providers.console.switch.toast.title": "Организация Console изменена",
+  "settings.providers.console.switch.toast.description": "Теперь используется {{org}}",
   "settings.providers.tag.environment": "Среда",
   "settings.providers.tag.config": "Конфигурация",
   "settings.providers.tag.custom": "Пользовательский",
@@ -950,6 +961,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (снапшот)",
+  "settings.import.snapshot.file": "Пакет снапшота",
+  "settings.import.snapshot.file.hint": "Выберите экспортированный пакет снапшота сессии (.json). Он будет импортирован как новая возобновляемая сессия.",
+  "settings.import.snapshot.noFile": "Сначала выберите файл пакета снапшота",
+  "settings.import.snapshot.done": "Снапшот импортирован как новая возобновляемая сессия",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/th.ts b/packages/app/src/i18n/th.ts
index 8cea2edd..d156dc80 100644
--- a/packages/app/src/i18n/th.ts
+++ b/packages/app/src/i18n/th.ts
@@ -558,6 +558,8 @@ export const dict = {
   "session.share.popover.description.shared": "เซสชันนี้เป็นสาธารณะบนเว็บ สามารถเข้าถึงได้โดยผู้ที่มีลิงก์",
   "session.share.popover.description.unshared": "แชร์เซสชันสาธารณะบนเว็บ จะเข้าถึงได้โดยผู้ที่มีลิงก์",
   "session.share.action.share": "แชร์",
+  "session.export.action": "ส่งออกสแนปชอต",
+  "session.export.success": "ส่งออกสแนปชอตเซสชันแล้ว",
   "session.share.action.publish": "เผยแพร่",
   "session.share.action.publishing": "กำลังเผยแพร่...",
   "session.share.action.unpublish": "ยกเลิกการเผยแพร่",
@@ -580,6 +582,7 @@ export const dict = {
   "common.closeTab": "ปิดแท็บ",
   "common.dismiss": "ปิด",
   "common.requestFailed": "คำขอล้มเหลว",
+  "common.active": "ใช้งานอยู่",
   "common.moreOptions": "ตัวเลือกเพิ่มเติม",
   "common.learnMore": "เรียนรู้เพิ่มเติม",
   "common.rename": "เปลี่ยนชื่อ",
@@ -756,6 +759,14 @@ export const dict = {
   "settings.providers.section.connected": "ผู้ให้บริการที่เชื่อมต่อ",
   "settings.providers.connected.empty": "ไม่มีผู้ให้บริการที่เชื่อมต่อ",
   "settings.providers.section.popular": "ผู้ให้บริการยอดนิยม",
+  "settings.providers.section.consoleAccount": "บัญชี Console",
+  "settings.providers.console.activeOrg": "องค์กรที่ใช้งาน",
+  "settings.providers.console.noOrg": "ยังไม่ได้เลือกองค์กร",
+  "settings.providers.console.switchOrg": "สลับองค์กร",
+  "settings.providers.console.empty": "ไม่มีองค์กร Console ที่สลับได้",
+  "settings.providers.console.managedCount": "ผู้ให้บริการที่จัดการโดย Console {{count}} ราย",
+  "settings.providers.console.switch.toast.title": "สลับองค์กร Console แล้ว",
+  "settings.providers.console.switch.toast.description": "กำลังใช้ {{org}}",
   "settings.providers.tag.environment": "สภาพแวดล้อม",
   "settings.providers.tag.config": "กำหนดค่า",
   "settings.providers.tag.custom": "กำหนดเอง",
@@ -937,6 +948,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (สแนปชอต)",
+  "settings.import.snapshot.file": "ชุดสแนปชอต",
+  "settings.import.snapshot.file.hint": "เลือกชุดสแนปชอตเซสชันที่ส่งออก (.json) จะนำเข้าเป็นเซสชันใหม่ที่ทำงานต่อได้",
+  "settings.import.snapshot.noFile": "เลือกไฟล์ชุดสแนปชอตก่อน",
+  "settings.import.snapshot.done": "นำเข้าสแนปชอตเป็นเซสชันใหม่ที่ทำงานต่อแล้ว",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/tr.ts b/packages/app/src/i18n/tr.ts
index e4abc007..51ad08cb 100644
--- a/packages/app/src/i18n/tr.ts
+++ b/packages/app/src/i18n/tr.ts
@@ -568,6 +568,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Oturumu web'de herkese açık olarak paylaşın. Bağlantıya sahip herkes erişebilecek.",
   "session.share.action.share": "Paylaş",
+  "session.export.action": "Anlık goruntuyu disa aktar",
+  "session.export.success": "Oturum anlık goruntusu disa aktarıldı",
   "session.share.action.publish": "Yayınla",
   "session.share.action.publishing": "Yayınlanıyor...",
   "session.share.action.unpublish": "Yayından kaldır",
@@ -591,6 +593,7 @@ export const dict = {
   "common.closeTab": "Sekmeyi kapat",
   "common.dismiss": "Kapat",
   "common.requestFailed": "İstek başarısız",
+  "common.active": "Etkin",
   "common.moreOptions": "Daha fazla seçenek",
   "common.learnMore": "Daha fazla bilgi",
   "common.rename": "Yeniden adlandır",
@@ -775,6 +778,14 @@ export const dict = {
   "settings.providers.section.connected": "Bağlı sağlayıcılar",
   "settings.providers.connected.empty": "Bağlı sağlayıcı yok",
   "settings.providers.section.popular": "Popüler sağlayıcılar",
+  "settings.providers.section.consoleAccount": "Console hesabı",
+  "settings.providers.console.activeOrg": "Etkin kuruluş",
+  "settings.providers.console.noOrg": "Kuruluş seçilmedi",
+  "settings.providers.console.switchOrg": "Kuruluş değiştir",
+  "settings.providers.console.empty": "Değiştirilebilir Console kuruluşu yok",
+  "settings.providers.console.managedCount": "Console tarafından yönetilen {{count}} sağlayıcı",
+  "settings.providers.console.switch.toast.title": "Console kuruluşu değiştirildi",
+  "settings.providers.console.switch.toast.description": "Şimdi {{org}} kullanılıyor",
   "settings.providers.tag.environment": "Ortam",
   "settings.providers.tag.config": "Yapılandırma",
   "settings.providers.tag.custom": "Özel",
@@ -960,6 +971,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (anlık goruntu)",
+  "settings.import.snapshot.file": "Anlık goruntu paketi",
+  "settings.import.snapshot.file.hint": "Disa aktarılmıs bir oturum anlık goruntu paketi (.json) secin. Devam edilebilir yeni bir oturum olarak ice aktarılır.",
+  "settings.import.snapshot.noFile": "Once bir anlık goruntu paketi dosyası secin",
+  "settings.import.snapshot.done": "Anlık goruntu devam edilebilir yeni bir oturum olarak ice aktarıldı",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/uk.ts b/packages/app/src/i18n/uk.ts
index 7a82b2a5..b8c8d2d9 100644
--- a/packages/app/src/i18n/uk.ts
+++ b/packages/app/src/i18n/uk.ts
@@ -616,6 +616,8 @@ export const dict = {
   "session.share.popover.description.unshared":
     "Опублікуйте сесію публічно в інтернеті. Вона буде доступна будь-кому за посиланням.",
   "session.share.action.share": "Поділитися",
+  "session.export.action": "Експортувати знімок",
+  "session.export.success": "Знімок сеансу експортовано",
   "session.share.action.publish": "Опублікувати",
   "session.share.action.publishing": "Публікація...",
   "session.share.action.unpublish": "Скасувати публікацію",
@@ -641,6 +643,7 @@ export const dict = {
   "common.dismiss": "Відхилити",
   "common.moreCountSuffix": " (ще {{count}})",
   "common.requestFailed": "Запит не виконано",
+  "common.active": "Активна",
   "common.moreOptions": "Більше опцій",
   "common.learnMore": "Дізнатися більше",
   "common.rename": "Перейменувати",
@@ -887,6 +890,14 @@ export const dict = {
   "settings.providers.connected.empty": "Немає підключених провайдерів",
   "settings.providers.connected.environmentDescription": "Підключено зі змінних середовища",
   "settings.providers.section.popular": "Популярні провайдери",
+  "settings.providers.section.consoleAccount": "Обліковий запис Console",
+  "settings.providers.console.activeOrg": "Активна організація",
+  "settings.providers.console.noOrg": "Організацію не вибрано",
+  "settings.providers.console.switchOrg": "Змінити організацію",
+  "settings.providers.console.empty": "Немає організацій Console для перемикання",
+  "settings.providers.console.managedCount": "Провайдерів під керуванням Console: {{count}}",
+  "settings.providers.console.switch.toast.title": "Організацію Console змінено",
+  "settings.providers.console.switch.toast.description": "Тепер використовується {{org}}",
   "settings.providers.custom.description": "Додайте провайдера, сумісного з OpenAI, за базовим URL.",
   "settings.providers.tag.environment": "Середовище",
   "settings.providers.tag.config": "Конфігурація",
@@ -981,6 +992,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "Custom",
+  "settings.import.preset.deepagent": "DeepAgent Code (знімок)",
+  "settings.import.snapshot.file": "Пакет знімка",
+  "settings.import.snapshot.file.hint": "Виберіть експортований пакет знімка сеансу (.json). Його буде імпортовано як нову продовжувану сесію.",
+  "settings.import.snapshot.noFile": "Спочатку виберіть файл пакета знімка",
+  "settings.import.snapshot.done": "Знімок імпортовано як нову продовжувану сесію",
   "settings.import.customPath": "Path",
   "settings.import.customPath.hint": "Absolute path to the agent data directory.",
   "settings.import.scope": "What to import",
diff --git a/packages/app/src/i18n/zh.ts b/packages/app/src/i18n/zh.ts
index 7baf438a..955a4e55 100644
--- a/packages/app/src/i18n/zh.ts
+++ b/packages/app/src/i18n/zh.ts
@@ -894,6 +894,8 @@ export const dict = {
   "session.share.popover.description.shared": "此会话已在网页上公开。任何拥有链接的人都可以访问。",
   "session.share.popover.description.unshared": "在网页上公开分享此会话。任何拥有链接的人都可以访问。",
   "session.share.action.share": "分享",
+  "session.export.action": "导出快照",
+  "session.export.success": "会话快照已导出",
   "session.share.action.publish": "发布",
   "session.share.action.publishing": "正在发布...",
   "session.share.action.unpublish": "取消发布",
@@ -929,6 +931,7 @@ export const dict = {
   "common.closeTab": "关闭标签页",
   "common.dismiss": "忽略",
   "common.requestFailed": "请求失败",
+  "common.active": "当前",
   "common.moreOptions": "更多选项",
   "common.learnMore": "了解更多",
   "common.rename": "重命名",
@@ -1203,6 +1206,14 @@ export const dict = {
   "settings.providers.section.connected": "已连接的提供商",
   "settings.providers.connected.empty": "没有已连接的提供商",
   "settings.providers.section.popular": "热门提供商",
+  "settings.providers.section.consoleAccount": "Console 账号",
+  "settings.providers.console.activeOrg": "当前组织",
+  "settings.providers.console.noOrg": "未选择组织",
+  "settings.providers.console.switchOrg": "切换组织",
+  "settings.providers.console.empty": "没有可切换的 Console 组织",
+  "settings.providers.console.managedCount": "{{count}} 个 Console 托管的提供商",
+  "settings.providers.console.switch.toast.title": "已切换 Console 组织",
+  "settings.providers.console.switch.toast.description": "当前使用 {{org}}",
   "settings.providers.tag.environment": "环境",
   "settings.providers.tag.config": "配置",
   "settings.providers.tag.custom": "自定义",
@@ -1403,6 +1414,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "自定义",
+  "settings.import.preset.deepagent": "DeepAgent Code（快照）",
+  "settings.import.snapshot.file": "快照包",
+  "settings.import.snapshot.file.hint": "选择导出的会话快照包（.json），将导入为新的可续跑会话。",
+  "settings.import.snapshot.noFile": "请先选择快照包文件",
+  "settings.import.snapshot.done": "快照已导入为新的可续跑会话",
   "settings.import.customPath": "路径",
   "settings.import.customPath.hint": "Agent 数据目录的绝对路径。",
   "settings.import.scope": "导入内容",
@@ -1543,6 +1559,22 @@ export const dict = {
   "session.context.copyRef": "复制稳定引用",
   "session.context.provenance": "来源",
   "session.context.relations": "关联",
+  "session.stats.title": "用量与成本",
+  "session.stats.overview": "概览",
+  "session.stats.sessions": "会话数",
+  "session.stats.days": "天数",
+  "session.stats.costTokens": "成本与 Token",
+  "session.stats.totalCost": "总成本",
+  "session.stats.costPerDay": "日均成本",
+  "session.stats.tokensPerSession": "平均 Token/会话",
+  "session.stats.medianTokens": "中位 Token/会话",
+  "session.stats.input": "输入",
+  "session.stats.output": "输出",
+  "session.stats.reasoning": "推理",
+  "session.stats.cacheRead": "缓存读取",
+  "session.stats.cacheWrite": "缓存写入",
+  "session.stats.modelUsage": "模型用量",
+  "session.stats.noData": "暂无会话用量数据。",
   "session.context.summary.complete": "完整",
   "session.context.summary.partial": "部分",
   "session.context.summary.empty": "空",
diff --git a/packages/app/src/i18n/zht.ts b/packages/app/src/i18n/zht.ts
index 745deeb7..51f35cda 100644
--- a/packages/app/src/i18n/zht.ts
+++ b/packages/app/src/i18n/zht.ts
@@ -699,6 +699,8 @@ export const dict = {
   "session.share.popover.description.shared": "此工作階段已在網頁上公開。任何擁有連結的人都可以存取。",
   "session.share.popover.description.unshared": "在網頁上公開分享此工作階段。任何擁有連結的人都可以存取。",
   "session.share.action.share": "分享",
+  "session.export.action": "匯出快照",
+  "session.export.success": "工作階段快照已匯出",
   "session.share.action.publish": "發佈",
   "session.share.action.publishing": "正在發佈...",
   "session.share.action.unpublish": "取消發佈",
@@ -721,6 +723,7 @@ export const dict = {
   "common.closeTab": "關閉標籤頁",
   "common.dismiss": "忽略",
   "common.requestFailed": "要求失敗",
+  "common.active": "目前",
   "common.moreOptions": "更多選項",
   "common.learnMore": "深入了解",
   "common.rename": "重新命名",
@@ -920,6 +923,14 @@ export const dict = {
   "settings.providers.section.connected": "已連線的提供商",
   "settings.providers.connected.empty": "沒有已連線的提供商",
   "settings.providers.section.popular": "熱門提供商",
+  "settings.providers.section.consoleAccount": "Console 帳號",
+  "settings.providers.console.activeOrg": "目前組織",
+  "settings.providers.console.noOrg": "未選擇組織",
+  "settings.providers.console.switchOrg": "切換組織",
+  "settings.providers.console.empty": "沒有可切換的 Console 組織",
+  "settings.providers.console.managedCount": "{{count}} 個 Console 託管的供應商",
+  "settings.providers.console.switch.toast.title": "已切換 Console 組織",
+  "settings.providers.console.switch.toast.description": "目前使用 {{org}}",
   "settings.providers.tag.environment": "環境",
   "settings.providers.tag.config": "配置",
   "settings.providers.tag.custom": "自訂",
@@ -1104,6 +1115,11 @@ export const dict = {
   "settings.import.preset.codex": "Codex",
   "settings.import.preset.claude": "Claude Code",
   "settings.import.preset.custom": "自訂",
+  "settings.import.preset.deepagent": "DeepAgent Code（快照）",
+  "settings.import.snapshot.file": "快照包",
+  "settings.import.snapshot.file.hint": "選擇匯出的工作階段快照包（.json），將匯入為新的可接續工作階段。",
+  "settings.import.snapshot.noFile": "請先選擇快照包檔案",
+  "settings.import.snapshot.done": "快照已匯入為新的可接續工作階段",
   "settings.import.customPath": "路徑",
   "settings.import.customPath.hint": "Agent 資料目錄的絕對路徑。",
   "settings.import.scope": "匯入內容",
diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx
index 96f2616c..259c20e9 100644
--- a/packages/app/src/pages/session.tsx
+++ b/packages/app/src/pages/session.tsx
@@ -74,6 +74,7 @@ import { useSessionCommands } from "@/pages/session/use-session-commands"
 import { useSessionHashScroll } from "@/pages/session/use-session-hash-scroll"
 import { Identifier } from "@/utils/id"
 import { diffs as list } from "@/utils/diffs"
+import { messageOrderKey } from "@/utils/message-order"
 import { Persist, persisted } from "@/utils/persist"
 import { extractPromptFromParts } from "@/utils/prompt"
 import { same } from "@/utils/same"
@@ -384,6 +385,14 @@ export default function Page() {
     () => {
       const revert = revertMessageID()
       if (!revert) return userMessages()
+      // BUG-407-012 root cause B: the revert boundary is the TARGET message's time, not its ID —
+      // ID lexicographic order flips across the 6-byte ID time wrap. If the target is not in the
+      // loaded window, degrade to the legacy ID boundary instead of guessing a time.
+      const target = messages().find((m) => m.id === revert)
+      if (target) {
+        const bound = messageOrderKey(target)
+        return userMessages().filter((m) => messageOrderKey(m) < bound)
+      }
       return userMessages().filter((m) => m.id < revert)
     },
     emptyUserMessages,
@@ -391,6 +400,8 @@ export default function Page() {
       equals: same,
     },
   )
+  // The timeline arrays are maintained in (time, id) chronological order, so the last element is
+  // the latest message even when its wrapped `msg_00...` ID sorts before older `msg_ff...` IDs.
   const lastUserMessage = createMemo(() => visibleUserMessages().at(-1))
 
   createEffect(() => {
@@ -718,9 +729,14 @@ export default function Page() {
 
   createEffect(
     on(
-      () => visibleUserMessages().at(-1)?.id,
-      (lastId, prevLastId) => {
-        if (lastId && prevLastId && lastId > prevLastId) {
+      // BUG-407-012 root cause B: compare (time, id) order keys, not raw IDs — a wrapped
+      // `msg_00...` newest message is lexicographically smaller than the previous `msg_ff...` one.
+      () => {
+        const last = visibleUserMessages().at(-1)
+        return last ? messageOrderKey(last) : undefined
+      },
+      (lastOrder, prevOrder) => {
+        if (lastOrder && prevOrder && lastOrder > prevOrder) {
           setStore("messageId", undefined)
         }
       },
diff --git a/packages/app/src/pages/session/message-timeline-virtualize.test.ts b/packages/app/src/pages/session/message-timeline-virtualize.test.ts
new file mode 100644
index 00000000..5a60fac9
--- /dev/null
+++ b/packages/app/src/pages/session/message-timeline-virtualize.test.ts
@@ -0,0 +1,172 @@
+import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test"
+import type { Part, ToolPart, ToolStateCompleted } from "@deepagent-code/sdk/v2"
+
+let shouldVirtualizeToolDiff: typeof import("./message-timeline").shouldVirtualizeToolDiff
+let toolDiffPayloadSize: typeof import("./message-timeline").toolDiffPayloadSize
+
+beforeAll(async () => {
+  // Bun test resolves solid-js through the "worker" condition (SSR build). Several
+  // packages in message-timeline's import graph assume the client build at module scope:
+  // virtua/solid imports a web-only export, and @solidjs/router / @kobalte/core chunks
+  // call client-only solid APIs on load. Stub those packages (nothing renders here, the
+  // functions under test are pure) while keeping solid-js itself on the single SSR build
+  // used by every other test file - mixing client/server solid builds in one process
+  // deadlocks the reactive scheduler.
+  const componentStub: any = new Proxy(() => null, { get: () => componentStub })
+  mock.module("virtua/solid", () => ({ Virtualizer: componentStub }))
+  // Keep the real (Kobalte-backed) message-part out of the module cache: other tests
+  // (message-timeline.data.test.ts) mock this module and bun re-links cached importers
+  // against the real one otherwise.
+  mock.module("@deepagent-code/ui/message-part", () => ({
+    ContextToolGroup: componentStub,
+    Message: componentStub,
+    MessageDivider: componentStub,
+    Part: componentStub,
+    partDefaultOpen: () => false,
+    groupParts: () => [],
+    renderable: () => true,
+  }))
+  mock.module("@solidjs/router", () => ({
+    A: componentStub,
+    Navigate: componentStub,
+    Route: componentStub,
+    Router: componentStub,
+    useIsRouting: () => () => false,
+    useLocation: () => ({ pathname: "/" }),
+    useNavigate: () => () => undefined,
+    useParams: () => ({}),
+    useSearchParams: () => ({}),
+  }))
+  const kobalte: Record<string, Record<string, unknown>> = {
+    "@kobalte/core/accordion": { Accordion: componentStub },
+    "@kobalte/core/button": { Button: componentStub },
+    "@kobalte/core/checkbox": { Checkbox: componentStub },
+    "@kobalte/core/collapsible": { Collapsible: componentStub },
+    "@kobalte/core/context-menu": { ContextMenu: componentStub },
+    "@kobalte/core/dialog": { Dialog: componentStub },
+    "@kobalte/core/dropdown-menu": { DropdownMenu: componentStub },
+    "@kobalte/core/hover-card": { HoverCard: componentStub },
+    "@kobalte/core/popover": { Popover: componentStub },
+    "@kobalte/core/progress": { Progress: componentStub },
+    "@kobalte/core/radio-group": { RadioGroup: componentStub },
+    "@kobalte/core/segmented-control": { SegmentedControl: componentStub },
+    "@kobalte/core/select": { Select: componentStub },
+    "@kobalte/core/switch": { Switch: componentStub },
+    "@kobalte/core/tabs": { Tabs: componentStub },
+    "@kobalte/core/text-field": { TextField: componentStub },
+    "@kobalte/core/toast": { Toast: componentStub, toaster: componentStub },
+    "@kobalte/core/tooltip": { Tooltip: componentStub },
+  }
+  for (const [name, exports] of Object.entries(kobalte)) {
+    mock.module(name, () => exports)
+  }
+
+  const mod = await import("./message-timeline")
+  shouldVirtualizeToolDiff = mod.shouldVirtualizeToolDiff
+  toolDiffPayloadSize = mod.toolDiffPayloadSize
+})
+
+// Drop the stubs once this file's tests are done so later files link the real modules;
+// the modules loaded above stay cached but are harmless (other test files that need
+// them, e.g. message-timeline.data.test.ts, register their own mocks).
+afterAll(() => mock.restore())
+
+const large = "x".repeat(500_001)
+const small = "x".repeat(100)
+
+function completedTool(overrides: Partial<Omit<ToolStateCompleted, "status">> = {}, tool = "edit"): ToolPart {
+  return {
+    id: "part-1",
+    sessionID: "session-1",
+    messageID: "message-1",
+    type: "tool",
+    callID: "call-1",
+    tool,
+    state: {
+      status: "completed",
+      input: {},
+      output: small,
+      title: "done",
+      metadata: {},
+      time: { start: 1, end: 2 },
+      ...overrides,
+    },
+  }
+}
+
+describe("shouldVirtualizeToolDiff (UX-001)", () => {
+  test("non-tool parts never virtualize", () => {
+    const part = {
+      id: "part-1",
+      sessionID: "session-1",
+      messageID: "message-1",
+      type: "text",
+      text: large,
+    } satisfies Part
+    expect(toolDiffPayloadSize(part)).toBe(0)
+    expect(shouldVirtualizeToolDiff(part)).toBe(false)
+  })
+
+  test("streaming (pending/running) parts never virtualize even with large payloads", () => {
+    const running: ToolPart = {
+      id: "part-1",
+      sessionID: "session-1",
+      messageID: "message-1",
+      type: "tool",
+      callID: "call-1",
+      tool: "edit",
+      state: { status: "running", input: {}, metadata: { filediff: { after: large } }, time: { start: 1 } },
+    }
+    expect(shouldVirtualizeToolDiff(running)).toBe(false)
+
+    const pending: ToolPart = { ...running, state: { status: "pending", input: {}, raw: large } }
+    expect(shouldVirtualizeToolDiff(pending)).toBe(false)
+  })
+
+  test("error parts never virtualize", () => {
+    const errored: ToolPart = {
+      id: "part-1",
+      sessionID: "session-1",
+      messageID: "message-1",
+      type: "tool",
+      callID: "call-1",
+      tool: "edit",
+      state: { status: "error", input: {}, error: large, time: { start: 1, end: 2 } },
+    }
+    expect(shouldVirtualizeToolDiff(errored)).toBe(false)
+  })
+
+  test("small completed diffs stay non-virtualized", () => {
+    expect(shouldVirtualizeToolDiff(completedTool())).toBe(false)
+    expect(shouldVirtualizeToolDiff(completedTool({ output: small, metadata: { filediff: { after: small } } }))).toBe(
+      false,
+    )
+  })
+
+  test("completed edit tool with large filediff payload virtualizes", () => {
+    expect(shouldVirtualizeToolDiff(completedTool({ metadata: { filediff: { after: large } } }))).toBe(true)
+    expect(shouldVirtualizeToolDiff(completedTool({ metadata: { filediff: { before: large } } }))).toBe(true)
+    expect(shouldVirtualizeToolDiff(completedTool({ metadata: { filediff: { patch: large } } }))).toBe(true)
+  })
+
+  test("completed apply_patch with large per-file patch virtualizes", () => {
+    const part = completedTool({ metadata: { files: [{ filePath: "a.ts", patch: large }] } }, "apply_patch")
+    expect(shouldVirtualizeToolDiff(part)).toBe(true)
+
+    const multi = completedTool(
+      { metadata: { files: [{ filePath: "a.ts", patch: small }, { filePath: "b.ts", diff: large }] } },
+      "apply_patch",
+    )
+    expect(shouldVirtualizeToolDiff(multi)).toBe(true)
+  })
+
+  test("falls back to output length proxy when no diff metadata exists", () => {
+    expect(shouldVirtualizeToolDiff(completedTool({ output: large }))).toBe(true)
+    expect(toolDiffPayloadSize(completedTool({ output: large }))).toBe(large.length)
+  })
+
+  test("threshold boundary is strict (> 500KB)", () => {
+    const exact = completedTool({ output: "x".repeat(500_000) })
+    expect(shouldVirtualizeToolDiff(exact)).toBe(false)
+  })
+})
diff --git a/packages/app/src/pages/session/message-timeline.bug407008.test.ts b/packages/app/src/pages/session/message-timeline.bug407008.test.ts
new file mode 100644
index 00000000..24b581ac
--- /dev/null
+++ b/packages/app/src/pages/session/message-timeline.bug407008.test.ts
@@ -0,0 +1,369 @@
+/**
+ * BUG-407-008 — spec §7.2 App projection deterministic regression tests (scenarios 18-29,
+ * timeline-layer subset: 18, 19, 26, 27, 28, 29).
+ *
+ * Harness/fixture style mirrors ./message-timeline.data.test.ts (same `@deepagent-code/ui/message-part`
+ * mock, same `Timeline.constructMessageRows` invocation shape).
+ *
+ * Fix-E (spec §5 Fix-E — per-Activity latest-revision convergence) is RESTORED here: commit
+ * 1ae96499 ("fix(app): preserve activity progress history") had removed it, but the adjudicated
+ * decision is to converge to the latest revision (hide superseded older revisions). These tests
+ * assert the spec-compliant convergence behavior.
+ */
+import { afterAll, describe, expect, mock, spyOn, test } from "bun:test"
+import type { AssistantMessage, Part, UserMessage } from "@deepagent-code/sdk/v2/client"
+import type { TimelineRow } from "./message-timeline.data"
+
+mock.module("@deepagent-code/ui/message-part", () => ({
+  groupParts: (refs: { messageID: string; part: Part }[]) =>
+    refs.map((item) => ({
+      key: `part:${item.messageID}:${item.part.id}`,
+      type: "part",
+      ref: { messageID: item.messageID, partID: item.part.id },
+    })),
+  renderable: (part: Part, showReasoningSummaries = true) =>
+    part.type !== "reasoning" || showReasoningSummaries,
+}))
+
+afterAll(() => mock.restore())
+
+// ---------------------------------------------------------------------------
+// Precise incident fixture (docs/bug-407-008.md §2.1/§2.2):
+//   activity  a6d06b2a...c5e5a9
+//   revision 8  msg_ff200fab7001lSTuDLJcykJfn6  reasoning prt_ff2010818001nSfs68M6HUBq2E
+//               + tool call tool_sd47zQa3WQeOSa1BKPhv6mF1 (bash, ordinal 548)
+//   revision 9  msg_ff2015000001RBapgqkQdqoqQI  reasoning prt_ff2015c8e00132UPp8LegJCQQ0
+//               + tool call tool_ZSTCdihDT0jY74tJVeAZLZ45 (bash, ordinal 549)
+//   revision 10 msg_ff2019410001interrupted      zero renderable parts, state=interrupted
+// Both reasoning texts are 1,668 chars and byte-identical (SHA-256 5bc40233...d37b).
+// ---------------------------------------------------------------------------
+
+const INCIDENT_ACTIVITY = "a6d06b2a82ef234ab9dc71e3fd940292a21b34f4732f28aa19ba8416c4c5e5a9"
+// Representative verbatim-identical reasoning body (real incident text is 1,668 chars).
+const INCIDENT_REASONING = `Check the stress log tail and whether w70_stress is still running. ${"user0/user1/user3 FINAL observed; user2 FINAL still missing. ".repeat(20)}`.trim()
+
+const user = {
+  id: "msg_user_incident",
+  sessionID: "ses_0149b8afffffWlu80cVGdzFI9s",
+  role: "user",
+  agent: "build",
+  model: { providerID: "deepseek", modelID: "deepseek-chat" },
+  time: { created: 1 },
+} as UserMessage
+
+const assistant = (id: string, activityProgress?: AssistantMessage["activityProgress"]) =>
+  ({
+    id,
+    sessionID: user.sessionID,
+    parentID: user.id,
+    role: "assistant",
+    mode: "build",
+    agent: "build",
+    modelID: "deepseek-chat",
+    providerID: "deepseek",
+    path: { cwd: "/project", root: "/project" },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: { created: 1, completed: 2 },
+    finish: "tool-calls",
+    activityProgress,
+  }) as AssistantMessage
+
+const reasoningPart = (messageID: string, id: string, text: string) =>
+  ({ id, sessionID: user.sessionID, messageID, type: "reasoning", text }) as Part
+
+const toolPart = (messageID: string, id: string, callID: string, command: string) =>
+  ({
+    id,
+    sessionID: user.sessionID,
+    messageID,
+    type: "tool",
+    callID,
+    tool: "bash",
+    state: {
+      status: "completed",
+      input: { command },
+      output: command,
+      title: command,
+      metadata: {},
+      time: { start: 1, end: 2 },
+    },
+  }) as Part
+
+const legacyMarkerPart = (
+  messageID: string,
+  id: string,
+  text: string,
+  marker: { activity_id: string; revision: number; state: string },
+) =>
+  ({
+    id,
+    sessionID: user.sessionID,
+    messageID,
+    type: "text",
+    text,
+    metadata: { deepagent_activity_progress: marker },
+  }) as Part
+
+const partIDs = (rows: TimelineRow.TimelineRow[]): string[] =>
+  rows.flatMap((row) => (row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : []))
+
+describe("BUG-407-008 §7.2 App projection — incident fixture (timeline layer)", () => {
+  test("18: precise incident fixture — revision 8/9 reasoning+tool with identical reasoning", async () => {
+    const { Timeline } = await import("./message-timeline.data")
+    // Spec §7.2 (18): with Fix-E restored, the App shows ONLY the latest revision's (9) renderable
+    // parts; the superseded revision 8 (identical reasoning + earlier tool) is hidden.
+    const msg8 = assistant("msg_ff200fab7001lSTuDLJcykJfn6", {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 8,
+      state: "progress",
+    })
+    const msg9 = assistant("msg_ff2015000001RBapgqkQdqoqQI", {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 9,
+      state: "progress",
+    })
+    const parts = new Map<string, Part[]>([
+      [
+        msg8.id,
+        [
+          reasoningPart(msg8.id, "prt_ff2010818001nSfs68M6HUBq2E", INCIDENT_REASONING),
+          toolPart(msg8.id, "prt_tool_rev8", "tool_sd47zQa3WQeOSa1BKPhv6mF1", "tail stress.log; pgrep w70_stress"),
+        ],
+      ],
+      [
+        msg9.id,
+        [
+          // Verbatim-identical reasoning text (SHA-256 match in the real incident).
+          reasoningPart(msg9.id, "prt_ff2015c8e00132UPp8LegJCQQ0", INCIDENT_REASONING),
+          toolPart(msg9.id, "prt_tool_rev9", "tool_ZSTCdihDT0jY74tJVeAZLZ45", "tail stress.log; wait user2 FINAL"),
+        ],
+      ],
+    ])
+
+    const rows = Timeline.constructMessageRows(user, (id) => parts.get(id) ?? [], [msg8, msg9], 0, true, "idle", false)
+    const visible = partIDs(rows)
+
+    // Only the latest revision (9) renders; superseded revision 8 is hidden.
+    expect(visible).toContain("prt_ff2015c8e00132UPp8LegJCQQ0")
+    expect(visible).toContain("prt_tool_rev9")
+    expect(visible).not.toContain("prt_ff2010818001nSfs68M6HUBq2E")
+    expect(visible).not.toContain("prt_tool_rev8")
+    expect(visible).toEqual(["prt_ff2015c8e00132UPp8LegJCQQ0", "prt_tool_rev9"])
+  })
+
+  test("19: terminal revision 10 has zero parts and state=interrupted", async () => {
+    const { Timeline } = await import("./message-timeline.data")
+    // Spec §7.2 (19): with Fix-E restored, once the zero-part terminal revision 10 (interrupted)
+    // arrives, it supersedes revisions 8/9 (terminal beats non-terminal), so 8/9 are fully hidden;
+    // the zero-part terminal contributes no part rows of its own. The interrupted TurnDivider
+    // contract stays driven by MessageAbortedError (existing UI preserved).
+    const msg8 = assistant("msg_ff200fab7001lSTuDLJcykJfn6", {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 8,
+      state: "progress",
+    })
+    const msg9 = assistant("msg_ff2015000001RBapgqkQdqoqQI", {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 9,
+      state: "progress",
+    })
+    const msg10 = assistant("msg_ff2019410001interrupted", {
+      activityID: INCIDENT_ACTIVITY,
+      revision: 10,
+      state: "interrupted",
+      terminalReason: "user_abort",
+    })
+    const parts = new Map<string, Part[]>([
+      [
+        msg8.id,
+        [
+          reasoningPart(msg8.id, "prt_ff2010818001nSfs68M6HUBq2E", INCIDENT_REASONING),
+          toolPart(msg8.id, "prt_tool_rev8", "tool_sd47zQa3WQeOSa1BKPhv6mF1", "tail stress.log"),
+        ],
+      ],
+      [
+        msg9.id,
+        [
+          reasoningPart(msg9.id, "prt_ff2015c8e00132UPp8LegJCQQ0", INCIDENT_REASONING),
+          toolPart(msg9.id, "prt_tool_rev9", "tool_ZSTCdihDT0jY74tJVeAZLZ45", "tail stress.log again"),
+        ],
+      ],
+      // revision 10: zero parts on purpose (provider-backed interrupted row).
+      [msg10.id, []],
+    ])
+
+    const rows = Timeline.constructMessageRows(
+      user,
+      (id) => parts.get(id) ?? [],
+      [msg8, msg9, msg10],
+      0,
+      true,
+      "idle",
+      false,
+    )
+    const visible = partIDs(rows)
+
+    // Revision 8/9 are hidden once the terminal revision 10 arrives; nothing renderable remains.
+    expect(visible).toEqual([])
+    // The zero-part terminal message contributes no part rows ...
+    expect(rows.some((row) => row._tag === "AssistantPart" && row.group.key.includes(msg10.id))).toBe(false)
+    // ... and (without a MessageAbortedError) no extra "interrupted" divider is synthesized:
+    // the existing interrupted UI contract is driven solely by MessageAbortedError.
+    expect(rows.filter((row) => row._tag === "TurnDivider" && row.label === "interrupted")).toEqual([])
+  })
+
+  test("26: a message with multiple reasoning/text/tool parts is shown or hidden as a whole group", async () => {
+    const { Timeline } = await import("./message-timeline.data")
+    // DEV-407008-E3: spec §7.2 (26) requires whole-group show/hide and forbids hiding only the
+    // part whose text matches a marker. Fix-E removal means NOTHING is hidden today, which
+    // trivially satisfies "no partial hiding": every part of the group is rendered together.
+    const message = assistant("msg_group", {
+      activityID: "activity-group",
+      revision: 3,
+      state: "progress",
+    })
+    const parts = new Map<string, Part[]>([
+      [
+        message.id,
+        [
+          reasoningPart(message.id, "prt_group_reasoning", INCIDENT_REASONING),
+          legacyMarkerPart(message.id, "prt_group_marker", `revision 3`, {
+            activity_id: "activity-group",
+            revision: 3,
+            state: "progress",
+          }),
+          {
+            id: "prt_group_text",
+            sessionID: user.sessionID,
+            messageID: message.id,
+            type: "text",
+            text: INCIDENT_REASONING, // same body as the reasoning part — must NOT be singled out
+          } as Part,
+          toolPart(message.id, "prt_group_tool", "call_group", "ls -la"),
+        ],
+      ],
+    ])
+
+    const rows = Timeline.constructMessageRows(user, (id) => parts.get(id) ?? [], [message], 0, true, "idle", false)
+    const visible = partIDs(rows)
+
+    // Whole-group visibility: all four parts render; no part is individually hidden.
+    expect(visible).toEqual(["prt_group_reasoning", "prt_group_marker", "prt_group_text", "prt_group_tool"])
+  })
+
+  test("27: identical reasoning text in two different Activities shows in both (no cross-activity dedup)", async () => {
+    const { Timeline } = await import("./message-timeline.data")
+    const first = assistant("msg_activity_a", { activityID: "activity-A", revision: 0, state: "progress" })
+    const second = assistant("msg_activity_b", { activityID: "activity-B", revision: 0, state: "progress" })
+    const parts = new Map<string, Part[]>([
+      [first.id, [reasoningPart(first.id, "prt_reasoning_A", INCIDENT_REASONING)]],
+      // Byte-identical reasoning text in a DIFFERENT activity.
+      [second.id, [reasoningPart(second.id, "prt_reasoning_B", INCIDENT_REASONING)]],
+    ])
+
+    const rows = Timeline.constructMessageRows(
+      user,
+      (id) => parts.get(id) ?? [],
+      [first, second],
+      0,
+      true,
+      "idle",
+      false,
+    )
+    const visible = partIDs(rows)
+
+    // Both activities keep their reasoning — content-hash dedup across activities never happens.
+    expect(visible).toEqual(["prt_reasoning_A", "prt_reasoning_B"])
+  })
+
+  test("28: legacy server with text-metadata markers only (no computed projection)", async () => {
+    const { Timeline } = await import("./message-timeline.data")
+    // Spec §7.2 (28): with Fix-E restored, legacy text-metadata markers (no computed
+    // `activityProgress` on messages) still converge per the old rules — the latest revision wins.
+    const first = assistant("msg_legacy_0")
+    const second = assistant("msg_legacy_1")
+    const parts = new Map<string, Part[]>([
+      [
+        first.id,
+        [
+          legacyMarkerPart(first.id, "prt_legacy_marker_0", "revision 0", {
+            activity_id: "activity-legacy",
+            revision: 0,
+            state: "progress",
+          }),
+        ],
+      ],
+      [
+        second.id,
+        [
+          legacyMarkerPart(second.id, "prt_legacy_marker_1", "revision 1", {
+            activity_id: "activity-legacy",
+            revision: 1,
+            state: "progress",
+          }),
+        ],
+      ],
+    ])
+
+    const rows = Timeline.constructMessageRows(
+      user,
+      (id) => parts.get(id) ?? [],
+      [first, second],
+      0,
+      false,
+      "idle",
+      false,
+    )
+    const visible = partIDs(rows)
+
+    // Legacy markers converge: the latest revision (1) is shown, the superseded revision (0) hidden.
+    expect(visible).toEqual(["prt_legacy_marker_1"])
+  })
+
+  test("29: message projection vs legacy marker conflict — projection source wins; diagnostic status", async () => {
+    const { Timeline } = await import("./message-timeline.data")
+    // Spec §7.2 (29): with Fix-E restored, the message-owned projection wins over a conflicting
+    // legacy text marker, and a projection-conflict diagnostic is emitted (console.error).
+    const errorSpy = spyOn(console, "error")
+    try {
+      const message = assistant("msg_conflict", {
+        activityID: "activity-conflict",
+        revision: 9, // message-owned projection says revision 9
+        state: "progress",
+      })
+      const parts = new Map<string, Part[]>([
+        [
+          message.id,
+          [
+            // Legacy marker disagrees: same activity but revision 8.
+            legacyMarkerPart(message.id, "prt_conflict_marker", "revision 8", {
+              activity_id: "activity-conflict",
+              revision: 8,
+              state: "progress",
+            }),
+            reasoningPart(message.id, "prt_conflict_reasoning", INCIDENT_REASONING),
+          ],
+        ],
+      ])
+
+      const rows = Timeline.constructMessageRows(
+        user,
+        (id) => parts.get(id) ?? [],
+        [message],
+        0,
+        true,
+        "idle",
+        false,
+      )
+      const visible = partIDs(rows)
+
+      // The owning message's parts are rendered (projection-bearing message is not dropped).
+      expect(visible).toEqual(["prt_conflict_marker", "prt_conflict_reasoning"])
+      // The projection-vs-legacy-marker conflict is diagnosed at the timeline layer.
+      expect(errorSpy).toHaveBeenCalled()
+    } finally {
+      errorSpy.mockRestore()
+    }
+  })
+})
diff --git a/packages/app/src/pages/session/message-timeline.data.test.ts b/packages/app/src/pages/session/message-timeline.data.test.ts
index 2206a80b..a2a64d49 100644
--- a/packages/app/src/pages/session/message-timeline.data.test.ts
+++ b/packages/app/src/pages/session/message-timeline.data.test.ts
@@ -8,8 +8,7 @@ mock.module("@deepagent-code/ui/message-part", () => ({
       type: "part",
       ref: { messageID: item.messageID, partID: item.part.id },
     })),
-  renderable: (part: Part, showReasoningSummaries = true) =>
-    part.type !== "reasoning" || showReasoningSummaries,
+  renderable: () => true,
 }))
 
 afterAll(() => mock.restore())
@@ -123,7 +122,7 @@ describe("message timeline activity progress", () => {
       },
     }) as Part
 
-  test("renders every progress revision for one activity", async () => {
+  test("shows only the latest settled progress for one activity", async () => {
     const { Timeline } = await import("./message-timeline.data")
     const messages = [assistant("msg_a0"), assistant("msg_a1")]
     const parts = new Map([
@@ -134,10 +133,10 @@ describe("message timeline activity progress", () => {
     const rows = Timeline.constructMessageRows(user, (id) => parts.get(id) ?? [], messages, 0, false, "idle", false)
     expect(
       rows.flatMap((row) => (row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : [])),
-    ).toEqual(["prt_progress_0", "prt_progress_1"])
+    ).toEqual(["prt_progress_1"])
   })
 
-  test("keeps progress revisions when the activity final arrives", async () => {
+  test("replaces settled progress with the activity final", async () => {
     const { Timeline } = await import("./message-timeline.data")
     const messages = [assistant("msg_a0"), assistant("msg_a1"), { ...assistant("msg_a2"), finish: "stop" }]
     const parts = new Map([
@@ -149,10 +148,10 @@ describe("message timeline activity progress", () => {
     const rows = Timeline.constructMessageRows(user, (id) => parts.get(id) ?? [], messages, 0, false, "idle", false)
     expect(
       rows.flatMap((row) => (row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : [])),
-    ).toEqual(["prt_progress_0", "prt_progress_1", "prt_final_2"])
+    ).toEqual(["prt_final_2"])
   })
 
-  test("keeps text parts across separate parent user rows", async () => {
+  test("collapses every text part in one activity across separate parent user rows", async () => {
     const { Timeline } = await import("./message-timeline.data")
     const user2 = { ...user, id: "msg_user_2" }
     const firstAssistant = assistant("msg_cross_a0")
@@ -174,6 +173,7 @@ describe("message timeline activity progress", () => {
       ],
     ])
     const getParts = (id: string) => parts.get(id) ?? []
+    const visibility = Timeline.activityProgressVisibility(messages, getParts)
     const firstRows = Timeline.constructMessageRows(
       user,
       getParts,
@@ -182,6 +182,7 @@ describe("message timeline activity progress", () => {
       false,
       "idle",
       false,
+      visibility,
     )
     const secondRows = Timeline.constructMessageRows(
       user2,
@@ -191,12 +192,9 @@ describe("message timeline activity progress", () => {
       false,
       "idle",
       false,
+      visibility,
     )
-    expect(
-      firstRows.flatMap((row) =>
-        row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : [],
-      ),
-    ).toEqual(["prt_progress_0", "prt_cross_old_plain"])
+    expect(firstRows.some((row) => row._tag === "AssistantPart")).toBe(false)
     expect(
       secondRows.flatMap((row) =>
         row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : [],
@@ -204,7 +202,7 @@ describe("message timeline activity progress", () => {
     ).toEqual(["prt_progress_1", "prt_cross_latest_plain"])
   })
 
-  test("keeps every text part in every revision", async () => {
+  test("applies one revision marker to every text part in the assistant message", async () => {
     const { Timeline } = await import("./message-timeline.data")
     const messages = [assistant("msg_multi_a0"), { ...assistant("msg_multi_a1"), finish: "stop" }]
     const plain = (messageID: string, id: string, text: string) =>
@@ -221,10 +219,10 @@ describe("message timeline activity progress", () => {
 
     expect(
       rows.flatMap((row) => (row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : [])),
-    ).toEqual(["prt_progress_0", "prt_old_plain", "prt_final_1", "prt_final_plain"])
+    ).toEqual(["prt_final_1", "prt_final_plain"])
   })
 
-  test("keeps reasoning summaries from every revision when enabled", async () => {
+  test("uses the message marker to collapse reasoning-only revisions", async () => {
     const { Timeline } = await import("./message-timeline.data")
     const messages = [
       {
@@ -247,34 +245,19 @@ describe("message timeline activity progress", () => {
 
     expect(
       rows.flatMap((row) => (row._tag === "AssistantPart" && row.group.type === "part" ? [row.group.ref.partID] : [])),
-    ).toEqual(["prt_reasoning_old", "prt_reasoning_latest"])
+    ).toEqual(["prt_reasoning_latest"])
   })
 
-  test("uses showReasoning as the explicit reasoning visibility control", async () => {
-    const { Timeline } = await import("./message-timeline.data")
-    const message = assistant("msg_reasoning_setting")
-    const reasoning = {
-      id: "prt_reasoning_setting",
-      sessionID: user.sessionID,
-      messageID: message.id,
-      type: "reasoning",
-      text: "summary",
-    } as Part
-    const getParts = () => [reasoning]
-
-    const hidden = Timeline.constructMessageRows(user, getParts, [message], 0, false, "idle", false)
-    const shown = Timeline.constructMessageRows(user, getParts, [message], 0, true, "idle", false)
-
-    expect(hidden.some((row) => row._tag === "AssistantPart")).toBe(false)
-    expect(shown.some((row) => row._tag === "AssistantPart")).toBe(true)
-  })
-
-  test("keeps an older tool revision when a later terminal message has no renderable parts", async () => {
+  test("hides an older tool revision when the latest terminal message has no renderable parts", async () => {
     const { Timeline } = await import("./message-timeline.data")
     const old = {
       ...assistant("msg_tool_old"),
       activityProgress: { activityID: "activity-tool", revision: 0, state: "progress" as const },
     }
+    const terminal = {
+      ...assistant("msg_tool_terminal"),
+      activityProgress: { activityID: "activity-tool", revision: 1, state: "final" as const },
+    }
     const tool = {
       id: "prt_tool_old",
       sessionID: user.sessionID,
@@ -285,8 +268,10 @@ describe("message timeline activity progress", () => {
       state: { status: "completed", input: {}, output: "pending", title: "poll", time: { start: 1, end: 2 } },
     } as Part
     const parts = new Map([[old.id, [tool]]])
-    const rows = Timeline.constructMessageRows(user, (id) => parts.get(id) ?? [], [old], 0, true, "idle", false)
+    const visibility = Timeline.activityProgressVisibility([old, terminal], (id) => parts.get(id) ?? [])
+
+    const rows = Timeline.constructMessageRows(user, (id) => parts.get(id) ?? [], [old], 0, true, "idle", false, visibility)
 
-    expect(rows.some((row) => row._tag === "AssistantPart")).toBe(true)
+    expect(rows.some((row) => row._tag === "AssistantPart")).toBe(false)
   })
 })
diff --git a/packages/app/src/pages/session/message-timeline.data.ts b/packages/app/src/pages/session/message-timeline.data.ts
index cf4b98d9..ea793845 100644
--- a/packages/app/src/pages/session/message-timeline.data.ts
+++ b/packages/app/src/pages/session/message-timeline.data.ts
@@ -147,6 +147,7 @@ export namespace Timeline {
     showReasoning: boolean,
     status: SessionStatus["type"],
     isActive: boolean,
+    activityProgressVisibility?: ReadonlySet<string>,
   ) {
     const rows: TimelineRow.TimelineRow[] = []
 
@@ -158,10 +159,14 @@ export namespace Timeline {
     const interrupted = interruptedMessageIndex !== -1
     const error = assistantMessages.find((m) => m.error && m.error.name !== "MessageAbortedError")?.error
 
-    const assistantPartRefs = assistantMessages.flatMap((message, messageIndex) =>
-      getMessageParts(message.id)
-        .filter((part) => renderable(part, showReasoning))
-        .map((part) => ({ messageID: message.id, messageIndex, part })),
+    const assistantPartRefs = latestActivityProgress(
+      assistantMessages,
+      assistantMessages.flatMap((message, messageIndex) =>
+        getMessageParts(message.id)
+          .filter((part) => renderable(part, showReasoning))
+          .map((part) => ({ messageID: message.id, messageIndex, part })),
+      ),
+      activityProgressVisibility,
     )
     const assistantItems =
       interrupted && !compaction
@@ -286,6 +291,100 @@ export namespace Timeline {
     return rows
   }
 
+  // BUG-407-008 Fix-E (restored after 1ae96499 removed it): per-Activity revision convergence. For
+  // each activityID, only the LATEST revision's parts are rendered (a terminal state beats a
+  // non-terminal one; among equal terminality the higher revision wins). Superseded older revisions
+  // are hidden, so identical reasoning re-emitted across revisions is shown once.
+  export function activityProgressVisibility(
+    assistantMessages: AssistantMessage[],
+    getMessageParts: (messageID: string) => Part[],
+  ) {
+    const refs = assistantMessages.flatMap((message, messageIndex) =>
+      getMessageParts(message.id).map((part) => ({ messageID: message.id, messageIndex, part })),
+    )
+    return new Set(latestActivityProgress(assistantMessages, refs).map((ref) => `${ref.messageID}:${ref.part.id}`))
+  }
+
+  function latestActivityProgress<T extends { messageID: string; part: Part }>(
+    assistantMessages: AssistantMessage[],
+    refs: T[],
+    visibility?: ReadonlySet<string>,
+  ) {
+    const progressByMessage = new Map<string, NonNullable<ReturnType<typeof messageActivityProgress>>>()
+    assistantMessages.forEach((message) => {
+      const marker = messageActivityProgress(message)
+      if (marker) progressByMessage.set(message.id, marker)
+    })
+    refs.forEach((ref) => {
+      const marker = partActivityProgress(ref.part)
+      const projected = progressByMessage.get(ref.messageID)
+      if (
+        marker &&
+        projected &&
+        (marker.activityID !== projected.activityID || marker.revision !== projected.revision)
+      )
+        console.error("Conflicting activity progress projection", {
+          messageID: ref.messageID,
+          projected,
+          legacy: marker,
+        })
+      if (projected) return
+      if (marker) progressByMessage.set(ref.messageID, marker)
+    })
+    const markerFor = (ref: T) => progressByMessage.get(ref.messageID) ?? partActivityProgress(ref.part)
+    if (visibility)
+      return refs.filter((ref) => {
+        if (!markerFor(ref)) return true
+        return visibility.has(`${ref.messageID}:${ref.part.id}`)
+      })
+    const selected = new Map<string, { revision: number; terminal: boolean }>()
+    progressByMessage.forEach((marker) => {
+      if (!marker) return
+      const terminal = marker.state !== "provisional" && marker.state !== "progress"
+      const current = selected.get(marker.activityID)
+      if (
+        current &&
+        ((current.terminal && !terminal) || (current.terminal === terminal && current.revision > marker.revision))
+      )
+        return
+      selected.set(marker.activityID, { revision: marker.revision, terminal })
+    })
+    return refs.filter((ref) => {
+      const marker = markerFor(ref)
+      if (!marker) return true
+      const current = selected.get(marker.activityID)
+      return (
+        current?.revision === marker.revision &&
+        current.terminal === (marker.state !== "provisional" && marker.state !== "progress")
+      )
+    })
+  }
+
+  function messageActivityProgress(message: AssistantMessage) {
+    const marker = message.activityProgress
+    if (!marker) return
+    if (!marker.activityID || !Number.isInteger(marker.revision) || marker.revision < 0) return
+    if (!["provisional", "progress", "final", "interrupted", "recovery_required", "failed"].includes(marker.state))
+      return
+    return marker
+  }
+
+  function partActivityProgress(part: Part) {
+    if (part.type !== "text") return
+    const value = part.metadata?.deepagent_activity_progress
+    if (!value || typeof value !== "object") return
+    const marker = value as Record<string, unknown>
+    if (typeof marker.activity_id !== "string" || marker.activity_id.length === 0) return
+    if (typeof marker.revision !== "number" || !Number.isInteger(marker.revision) || marker.revision < 0) return
+    if (!["provisional", "progress", "final", "interrupted", "recovery_required"].includes(String(marker.state)))
+      return
+    return {
+      activityID: marker.activity_id,
+      revision: marker.revision,
+      state: marker.state as "provisional" | "progress" | "final" | "interrupted" | "recovery_required",
+    }
+  }
+
   function isSummaryDiff(value: SnapshotFileDiff): value is SummaryDiff {
     return typeof value.file === "string"
   }
diff --git a/packages/app/src/pages/session/message-timeline.tsx b/packages/app/src/pages/session/message-timeline.tsx
index b3ee9d86..05018db1 100644
--- a/packages/app/src/pages/session/message-timeline.tsx
+++ b/packages/app/src/pages/session/message-timeline.tsx
@@ -89,6 +89,58 @@ const emptyTools: ToolPart[] = []
 const emptyAssistantMessages: AssistantMessage[] = []
 const idle = { type: "idle" as const }
 
+// ---------------------------------------------------------------------------
+// UX-001: only virtualize large, completed tool diffs.
+// ---------------------------------------------------------------------------
+
+// Threshold semantics mirror VIRTUALIZE_BYTES (500KB) in packages/ui/src/components/file.tsx.
+const TOOL_DIFF_VIRTUALIZE_BYTES = 500_000
+
+function payloadStringLength(value: unknown) {
+  return typeof value === "string" ? value.length : 0
+}
+
+// Tool parts carry no dedicated "diff size" field and we intentionally avoid adding
+// schema/persistence for this, so the size is estimated conservatively from existing
+// string payloads on the completed part:
+//   1. state.metadata.filediff before/after/patch lengths (edit tool diff source)
+//   2. state.metadata.files[].patch/diff/before/after lengths (apply_patch diff source)
+//   3. fallback: state.output length as a coarse proxy (only universally available signal)
+export function toolDiffPayloadSize(part: PartType): number {
+  if (part.type !== "tool") return 0
+  const state = part.state
+  // Streaming (pending/running) and error parts have no stable size; virtualizing them
+  // would force repeated viewer resets as content grows (see file.tsx render reset logic).
+  if (state.status !== "completed") return 0
+  const metadata: Record<string, unknown> = state.metadata
+  let size = 0
+  const filediff = metadata.filediff
+  if (filediff && typeof filediff === "object") {
+    const fd = filediff as Record<string, unknown>
+    size = Math.max(size, payloadStringLength(fd.patch), payloadStringLength(fd.before), payloadStringLength(fd.after))
+  }
+  const files = metadata.files
+  if (Array.isArray(files)) {
+    for (const item of files) {
+      if (!item || typeof item !== "object") continue
+      const file = item as Record<string, unknown>
+      size = Math.max(
+        size,
+        payloadStringLength(file.patch),
+        payloadStringLength(file.diff),
+        payloadStringLength(file.before),
+        payloadStringLength(file.after),
+      )
+    }
+  }
+  if (size === 0) size = payloadStringLength(state.output)
+  return size
+}
+
+export function shouldVirtualizeToolDiff(part: PartType): boolean {
+  return toolDiffPayloadSize(part) > TOOL_DIFF_VIRTUALIZE_BYTES
+}
+
 // ForkBanner and BottomSpacer render their own top-level container (no TimelineRowFrame, which
 // assumes a per-turn `userMessageID`), so they're excluded from the framed-row union.
 type FramedTimelineRow = Exclude<TimelineRow.TimelineRow, { _tag: "BottomSpacer" | "ForkBanner" }>
@@ -436,6 +488,10 @@ function TimelineDiffView(props: { diff: SummaryDiff }) {
 
   return (
     <div data-slot="session-turn-diff-view" data-scrollable>
+      {/* UX-001: summary diffs stay non-virtualized. SummaryDiff only carries patch/addition
+          counts (no reliable size signal), the wrapper has overflow-y:auto but no bounded
+          height, so an inner virtualizer would still share the outer row-level scroll root.
+          Keeping virtualize={false} conservatively. */}
       <Dynamic component={fileComponent} mode="diff" virtualize={false} fileDiff={view.fileDiff} />
     </div>
   )
@@ -586,6 +642,12 @@ export function MessageTimeline(props: {
   })
   const parentTitle = createMemo(() => sessionTitle(parent()?.title) ?? language.t("command.session.new"))
   const getMsgParts = (msgId: string) => sync.data.part[msgId] ?? emptyParts
+  const activityProgressVisibility = createMemo(() =>
+    Timeline.activityProgressVisibility(
+      sessionMessages().filter((message): message is AssistantMessage => message.role === "assistant"),
+      getMsgParts,
+    ),
+  )
   const childTaskDescription = createMemo(() => {
     const id = sessionID()
     if (!id) return
@@ -616,6 +678,7 @@ export function MessageTimeline(props: {
             settings.general.showReasoningSummaries(),
             sessionStatus().type,
             activeMessageID() === userMessage.id,
+            activityProgressVisibility(),
           )
 
           return reuseTimelineRows(previous, rows)
@@ -1050,6 +1113,31 @@ export function MessageTimeline(props: {
     navigate(`/${params.dir}/session`)
   }
 
+  const exportSession = async (sessionID: string) => {
+    const session = sync.session.get(sessionID)
+    const base = (session?.title || sessionID).replace(/[^\w\u4e00-\u9fff-]+/g, "-").slice(0, 60) || sessionID
+    try {
+      const res = await sdk.client.session.exportSnapshot({ sessionID }, { throwOnError: true })
+      const bundle = typeof res.data === "string" ? res.data : JSON.stringify(res.data ?? {})
+      const url = URL.createObjectURL(new Blob([bundle], { type: "application/json" }))
+      const anchor = document.createElement("a")
+      anchor.href = url
+      anchor.download = `${base}-snapshot.json`
+      document.body.appendChild(anchor)
+      anchor.click()
+      anchor.remove()
+      URL.revokeObjectURL(url)
+      showToast({
+        variant: "success",
+        icon: "circle-check",
+        title: language.t("session.export.success"),
+      })
+    } catch (err) {
+      console.error("Failed to export session snapshot", err)
+      showToast({ title: language.t("common.requestFailed") })
+    }
+  }
+
   const archiveSession = async (sessionID: string) => {
     const session = sync.session.get(sessionID)
     if (!session) return
@@ -1304,7 +1392,8 @@ export function MessageTimeline(props: {
                 toolOpen={toolOpen[part().id] ?? defaultOpen()}
                 onToolOpenChange={(open) => setToolOpen(part().id, open)}
                 deferToolContent={false}
-                virtualizeDiff={false}
+                // UX-001: only completed + large tool diffs get virtualized; streaming parts stay false.
+                virtualizeDiff={shouldVirtualizeToolDiff(part())}
                 onFork={props.actions?.fork}
               />
             )}
@@ -1816,6 +1905,9 @@ export function MessageTimeline(props: {
                                 </DropdownMenu.ItemLabel>
                               </DropdownMenu.Item>
                             </Show>
+                            <DropdownMenu.Item onSelect={() => void exportSession(id)}>
+                              <DropdownMenu.ItemLabel>{language.t("session.export.action")}</DropdownMenu.ItemLabel>
+                            </DropdownMenu.Item>
                             <DropdownMenu.Item onSelect={() => void archiveSession(id)}>
                               <DropdownMenu.ItemLabel>{language.t("common.archive")}</DropdownMenu.ItemLabel>
                             </DropdownMenu.Item>
diff --git a/packages/app/src/pages/session/session-side-panel.tsx b/packages/app/src/pages/session/session-side-panel.tsx
index 9a3e7695..2332de65 100644
--- a/packages/app/src/pages/session/session-side-panel.tsx
+++ b/packages/app/src/pages/session/session-side-panel.tsx
@@ -43,6 +43,7 @@ import { SidePanelDebug } from "@/pages/session/side-panel-debug"
 import { SidePanelProfile } from "@/pages/session/side-panel-profile"
 import { SidePanelIM } from "@/pages/session/side-panel-im"
 import { SidePanelContext } from "@/pages/session/side-panel-context"
+import { SidePanelStats } from "@/pages/session/side-panel-stats"
 import { SidePanelDockHeader, SidePanelTerminal, SidePanelDebugConsole } from "@/pages/session/side-panel-terminal"
 import { ProblemsPanel } from "@/pages/session/problems-panel"
 import { PanelErrorBoundary } from "@/pages/session/panel-error-boundary"
@@ -65,6 +66,7 @@ type PanelMode =
   | "plugins"
   | "debug"
   | "profile"
+  | "stats"
   | "terminal"
   | "debug-console"
   | "problems"
@@ -117,6 +119,8 @@ const PANELS: readonly PanelDef[] = [
   { mode: "plugins", icon: "plugin", titleKey: "status.popover.tab.plugins", group: "dev", bucket: "narrow" },
   { mode: "debug", icon: "debug", titleKey: "session.panel.debug", group: "dev", bucket: "narrow" },
   { mode: "profile", icon: "profile", titleKey: "session.panel.profile", group: "dev", bucket: "narrow" },
+  // PARITY-001: cross-session cost/token overview aggregated from the synced session store.
+  { mode: "stats", icon: "dash", titleKey: "session.stats.title", group: "dev", bucket: "narrow" },
   // Dock — the movable panels; only surface here when docked to the side (see gating below).
   {
     mode: "terminal",
@@ -693,6 +697,9 @@ export function SessionSidePanel(props: {
                 <Match when={isActive("profile")}>
                   <SidePanelProfile onClose={closePanel} />
                 </Match>
+                <Match when={isActive("stats")}>
+                  <SidePanelStats onClose={closePanel} />
+                </Match>
                 <Match when={isActive("im")}>
                   <SidePanelIM onClose={closePanel} />
                 </Match>
diff --git a/packages/app/src/pages/session/side-panel-stats.tsx b/packages/app/src/pages/session/side-panel-stats.tsx
new file mode 100644
index 00000000..63ac6ff9
--- /dev/null
+++ b/packages/app/src/pages/session/side-panel-stats.tsx
@@ -0,0 +1,129 @@
+// PARITY-001: GUI cross-session cost/token overview.
+//
+// The CLI `stats` command aggregates the whole database in-process; the GUI only had per-session
+// context diagnostics (side-panel-context.tsx). This panel aggregates the sessions already synced
+// into the directory store (sync.data.session — the same list the session drawer renders) into a
+// per-session cost/token/model overview. Zero new API endpoints: the SDK Session type carries
+// `cost`, `tokens` and `model` rollups.
+import { Icon } from "@deepagent-code/ui/icon"
+import { IconButton } from "@deepagent-code/ui/icon-button"
+import { For, Show, createMemo, type Component, type JSX } from "solid-js"
+import { useLanguage } from "@/context/language"
+import { useSync } from "@/context/sync"
+import {
+  aggregateSessionStats,
+  formatCost,
+  formatTokenCount,
+  sortModelUsage,
+} from "@/utils/session-stats"
+
+export const SidePanelStats: Component<{ onClose: () => void }> = (props) => {
+  const sync = useSync()
+  const language = useLanguage()
+
+  // The synced session list for the current directory; events keep it live, so the memo
+  // re-aggregates automatically as session cost/tokens rollups update.
+  const stats = createMemo(() => aggregateSessionStats(sync.data.session))
+  const models = createMemo(() => sortModelUsage(stats().modelUsage))
+
+  const Row = (row: { label: string; value: string }) => (
+    <div class="py-1 flex items-center gap-2 text-11-regular">
+      <span class="flex-1 min-w-0 text-text-weak truncate">{row.label}</span>
+      <span class="shrink-0 text-text-strong font-mono">{row.value}</span>
+    </div>
+  )
+
+  const Section = (section: { title: string; children?: JSX.Element }) => (
+    <div class="px-3 py-2.5 border-b border-border-weaker-base">
+      <div class="text-11-medium text-text-weak uppercase">{section.title}</div>
+      <div class="mt-1.5">{section.children}</div>
+    </div>
+  )
+
+  return (
+    <section class="size-full min-w-0 flex flex-col overflow-hidden bg-background-base" data-testid="side-panel-stats">
+      <header class="h-10 shrink-0 px-2 flex items-center gap-2 border-b border-border-weaker-base">
+        <Icon name="dash" size="small" class="text-icon-base" />
+        <div class="min-w-0 flex-1 text-13-medium text-text-strong truncate">
+          {language.t("session.stats.title")}
+        </div>
+        <IconButton
+          icon="close-small"
+          variant="ghost"
+          class="h-7 w-7 rounded-md"
+          onClick={props.onClose}
+          aria-label={language.t("common.close")}
+        />
+      </header>
+
+      <div class="flex-1 min-h-0 overflow-y-auto">
+        <Show
+          when={stats().totalSessions > 0}
+          fallback={<div class="p-3 text-13-regular text-text-weak">{language.t("session.stats.noData")}</div>}
+        >
+          <Section title={language.t("session.stats.overview")}>
+            <Row label={language.t("session.stats.sessions")} value={stats().totalSessions.toLocaleString()} />
+            <Row label={language.t("session.stats.days")} value={String(stats().days)} />
+          </Section>
+
+          <Section title={language.t("session.stats.costTokens")}>
+            <Row label={language.t("session.stats.totalCost")} value={formatCost(stats().totalCost)} />
+            <Row label={language.t("session.stats.costPerDay")} value={formatCost(stats().costPerDay)} />
+            <Row
+              label={language.t("session.stats.tokensPerSession")}
+              value={formatTokenCount(stats().tokensPerSession)}
+            />
+            <Row
+              label={language.t("session.stats.medianTokens")}
+              value={formatTokenCount(stats().medianTokensPerSession)}
+            />
+            <Row label={language.t("session.stats.input")} value={formatTokenCount(stats().totalTokens.input)} />
+            <Row label={language.t("session.stats.output")} value={formatTokenCount(stats().totalTokens.output)} />
+            <Row
+              label={language.t("session.stats.reasoning")}
+              value={formatTokenCount(stats().totalTokens.reasoning)}
+            />
+            <Row
+              label={language.t("session.stats.cacheRead")}
+              value={formatTokenCount(stats().totalTokens.cache.read)}
+            />
+            <Row
+              label={language.t("session.stats.cacheWrite")}
+              value={formatTokenCount(stats().totalTokens.cache.write)}
+            />
+          </Section>
+
+          <Show when={models().length > 0}>
+            <Section title={`${language.t("session.stats.modelUsage")} · ${models().length}`}>
+              <For each={models()}>
+                {([model, usage]) => (
+                  <div class="py-1.5 border-t border-border-weaker-base first:border-t-0 first:pt-0">
+                    <div class="flex items-center gap-2">
+                      <span class="flex-1 min-w-0 text-11-medium text-text-strong truncate" title={model}>
+                        {model}
+                      </span>
+                      <span class="shrink-0 text-10-regular text-text-weaker font-mono">
+                        {formatCost(usage.cost, 4)}
+                      </span>
+                    </div>
+                    <div class="mt-0.5 flex items-center gap-2 text-10-regular text-text-weaker">
+                      <span>
+                        {language.t("session.stats.sessions")}: {usage.sessions.toLocaleString()}
+                      </span>
+                      <span class="font-mono">
+                        {formatTokenCount(usage.tokens.input)}↑ {formatTokenCount(usage.tokens.output)}↓
+                      </span>
+                      <span class="ml-auto font-mono">
+                        {language.t("session.stats.cacheRead")} {formatTokenCount(usage.tokens.cache.read)}
+                      </span>
+                    </div>
+                  </div>
+                )}
+              </For>
+            </Section>
+          </Show>
+        </Show>
+      </div>
+    </section>
+  )
+}
diff --git a/packages/app/src/utils/message-order.test.ts b/packages/app/src/utils/message-order.test.ts
new file mode 100644
index 00000000..85927655
--- /dev/null
+++ b/packages/app/src/utils/message-order.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test"
+import type { Message, Part } from "@deepagent-code/sdk/v2/client"
+import {
+  compareMessages,
+  compareParts,
+  findMessageIndex,
+  locateMessage,
+  locatePart,
+  messageOrderKey,
+  messageTime,
+  partOrderKey,
+  partTime,
+} from "./message-order"
+
+// Regression fixture from BUG-407-012: the 26th wrap of the 6-byte ID time field happened on
+// 2026-08-14, so the chronologically NEWER message carries a lexicographically SMALLER ID.
+const WRAP_OLD_ID = "msg_ffa88f0840015Xj7vIrcdNEJJB" // 2026-08-13 17:51:46, before the wrap
+const WRAP_NEW_ID = "msg_00d62a3c4001KqYw3o8wBBH6qm" // 2026-08-17 09:42:43, after the wrap
+const WRAP_OLD_TIME = 1786614706000
+const WRAP_NEW_TIME = 1786930963000
+
+const userMessage = (id: string, created: number) =>
+  ({
+    id,
+    sessionID: "ses_1",
+    role: "user",
+    time: { created },
+    agent: "assistant",
+    model: { providerID: "openai", modelID: "gpt" },
+  }) as Message
+
+const textPart = (id: string, start?: number) =>
+  ({
+    id,
+    sessionID: "ses_1",
+    messageID: "msg_1",
+    type: "text",
+    text: id,
+    ...(start === undefined ? {} : { time: { start } }),
+  }) as Part
+
+describe("message order (BUG-407-012 root cause B)", () => {
+  test("orders messages by time.created first, then by ID", () => {
+    const older = userMessage(WRAP_OLD_ID, WRAP_OLD_TIME)
+    const newer = userMessage(WRAP_NEW_ID, WRAP_NEW_TIME)
+    expect(WRAP_NEW_ID < WRAP_OLD_ID).toBe(true) // sanity: raw ID order is reversed
+    expect(compareMessages(newer, older)).toBeGreaterThan(0)
+    expect(compareMessages(older, newer)).toBeLessThan(0)
+    expect(messageOrderKey(older) < messageOrderKey(newer)).toBe(true)
+    expect([newer, older].sort((a, b) => compareMessages(a, b)).map((m) => m.id)).toEqual([
+      WRAP_OLD_ID,
+      WRAP_NEW_ID,
+    ])
+  })
+
+  test("falls back to ID order when time.created is equal or missing", () => {
+    const a = userMessage("msg_a", 5)
+    const b = userMessage("msg_b", 5)
+    expect(compareMessages(a, b)).toBeLessThan(0)
+    expect(messageTime({ id: "msg_x" })).toBe(0)
+    expect(compareMessages({ id: "msg_x" }, a)).toBeLessThan(0) // missing time sorts earliest
+  })
+
+  test("locates a wrapped newer message at the tail, never at the head", () => {
+    const sorted = [userMessage(WRAP_OLD_ID, WRAP_OLD_TIME)]
+    const insert = locateMessage(sorted, userMessage(WRAP_NEW_ID, WRAP_NEW_TIME))
+    expect(insert).toEqual({ found: false, index: 1 })
+    const existing = locateMessage(sorted, userMessage(WRAP_OLD_ID, WRAP_OLD_TIME))
+    expect(existing).toEqual({ found: true, index: 0 })
+    expect(findMessageIndex(sorted, WRAP_OLD_ID)).toBe(0)
+  })
+
+  test("locateMessage finds an item by identity even when its time differs", () => {
+    const sorted = [userMessage(WRAP_OLD_ID, WRAP_OLD_TIME)]
+    const drifted = locateMessage(sorted, { id: WRAP_OLD_ID, time: { created: 1 } })
+    expect(drifted).toEqual({ found: true, index: 0 })
+  })
+})
+
+describe("part order (BUG-407-012 root cause B)", () => {
+  test("orders parts by time.start first, then by ID", () => {
+    const older = textPart("prt_ffa88f084001aaaa", WRAP_OLD_TIME)
+    const newer = textPart("prt_00d62a3c4001bbbb", WRAP_NEW_TIME)
+    expect(newer.id < older.id).toBe(true) // sanity: raw ID order is reversed
+    expect(compareParts(newer, older)).toBeGreaterThan(0)
+    expect(partOrderKey(older) < partOrderKey(newer)).toBe(true)
+    expect([newer, older].sort((a, b) => compareParts(a, b)).map((p) => p.id)).toEqual([older.id, newer.id])
+  })
+
+  test("parts without time.start fall back to 0 and locate by identity", () => {
+    const timeless = textPart("prt_tool")
+    expect(partTime(timeless)).toBe(0)
+    const timed = textPart("prt_aaaa", WRAP_OLD_TIME)
+    expect(compareParts(timeless, timed)).toBeLessThan(0)
+    const located = locatePart([timeless], { ...timed, id: "prt_tool" })
+    expect(located.found).toBe(true)
+  })
+})
diff --git a/packages/app/src/utils/message-order.ts b/packages/app/src/utils/message-order.ts
new file mode 100644
index 00000000..64af1145
--- /dev/null
+++ b/packages/app/src/utils/message-order.ts
@@ -0,0 +1,87 @@
+import { Binary } from "@deepagent-code/core/util/binary"
+
+// BUG-407-012 root cause B: opaque IDs encode a 36-bit millisecond timestamp that wraps every
+// 2^36 ms (~795 days; the 26th wrap happened on 2026-08-14). After a wrap, newly generated
+// `msg_00...` IDs sort lexicographically BEFORE older `msg_ff...` IDs, so ID order is no longer
+// chronological order. IDs must be treated as pure identity; every timeline sort / binary
+// location / "latest" decision uses the compound (time, id) order defined here instead.
+//
+// - messages order by `time.created` (missing -> 0)
+// - parts order by `time.start` (missing -> 0)
+// - the tie-break key remains the existing lexicographic ID comparison
+
+export type MessageOrderItem = { id: string; time?: { created?: number } }
+// Part `time` shapes differ across variants (`{start}` on text/reasoning, `{created}` on retry,
+// absent on tools), so the order item accepts any time shape and reads `start` defensively.
+export type PartOrderItem = { id: string; time?: Record<string, unknown> }
+
+// Millisecond epochs fit in 13 digits today; 16 keeps the fixed-width prefix sortable for eons.
+const TIME_FIELD_WIDTH = 16
+
+export const compareIDs = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
+
+const normalizeTime = (value: number | undefined) =>
+  typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0
+
+export const messageTime = (message: MessageOrderItem) => normalizeTime(message.time?.created)
+
+export const partTime = (part: PartOrderItem) => normalizeTime(part.time?.start as number | undefined)
+
+const timePrefix = (time: number) => String(time).padStart(TIME_FIELD_WIDTH, "0")
+
+// Lexicographic comparison of these keys is exactly the compound (time, id) order, so they can be
+// used with key-based Binary.search and with plain string `<`/`>` boundary checks (e.g. revert).
+export const messageOrderKey = (message: MessageOrderItem) => timePrefix(messageTime(message)) + message.id
+
+export const partOrderKey = (part: PartOrderItem) => timePrefix(partTime(part)) + part.id
+
+export const compareMessages = (a: MessageOrderItem, b: MessageOrderItem) => {
+  const delta = messageTime(a) - messageTime(b)
+  if (delta !== 0) return delta < 0 ? -1 : 1
+  return compareIDs(a.id, b.id)
+}
+
+export const compareParts = (a: PartOrderItem, b: PartOrderItem) => {
+  const delta = partTime(a) - partTime(b)
+  if (delta !== 0) return delta < 0 ? -1 : 1
+  return compareIDs(a.id, b.id)
+}
+
+export const searchMessages = <T extends MessageOrderItem>(messages: readonly T[], message: MessageOrderItem) =>
+  Binary.search(messages as unknown as MessageOrderItem[], messageOrderKey(message), (item) => messageOrderKey(item))
+
+export const searchParts = <T extends PartOrderItem>(parts: readonly T[], part: PartOrderItem) =>
+  Binary.search(parts as unknown as PartOrderItem[], partOrderKey(part), (item) => partOrderKey(item))
+
+// A bare ID carries no time, so it cannot be binary-searched in a (time, id)-ordered array.
+// Linear scans are bounded: one session's loaded messages / one message's parts.
+export const findMessageIndex = <T extends { id: string }>(messages: readonly T[], id: string) =>
+  messages.findIndex((item) => item.id === id)
+
+export const findPartIndex = <T extends { id: string }>(parts: readonly T[], id: string) =>
+  parts.findIndex((item) => item.id === id)
+
+// Locate an item by identity without ever duplicating it: prefer the compound-order binary search
+// (fast path; also yields the correct insertion index when absent), then fall back to an ID scan
+// for the rare case where the stored copy carries a different time field than the incoming one.
+export function locateMessage<T extends MessageOrderItem>(
+  messages: readonly T[],
+  message: MessageOrderItem,
+): { found: boolean; index: number } {
+  const result = searchMessages(messages, message)
+  if (result.found) return result
+  const index = findMessageIndex(messages, message.id)
+  if (index !== -1) return { found: true, index }
+  return result
+}
+
+export function locatePart<T extends PartOrderItem>(parts: readonly T[], part: PartOrderItem): {
+  found: boolean
+  index: number
+} {
+  const result = searchParts(parts, part)
+  if (result.found) return result
+  const index = findPartIndex(parts, part.id)
+  if (index !== -1) return { found: true, index }
+  return result
+}
diff --git a/packages/app/src/utils/session-stats.test.ts b/packages/app/src/utils/session-stats.test.ts
new file mode 100644
index 00000000..d238d22f
--- /dev/null
+++ b/packages/app/src/utils/session-stats.test.ts
@@ -0,0 +1,181 @@
+import { describe, expect, test } from "bun:test"
+import {
+  aggregateSessionStats,
+  formatCost,
+  formatTokenCount,
+  sortModelUsage,
+  type StatsSession,
+} from "./session-stats"
+
+const MS_IN_DAY = 24 * 60 * 60 * 1000
+
+function session(overrides: Partial<StatsSession> & { id: string }): StatsSession {
+  return {
+    time: { created: 0, updated: 0 },
+    ...overrides,
+  }
+}
+
+describe("aggregateSessionStats", () => {
+  test("empty input yields zeroed stats without NaN", () => {
+    const stats = aggregateSessionStats([])
+    expect(stats.totalSessions).toBe(0)
+    expect(stats.totalCost).toBe(0)
+    expect(stats.totalTokens.input).toBe(0)
+    expect(stats.tokensPerSession).toBe(0)
+    expect(stats.medianTokensPerSession).toBe(0)
+    expect(stats.costPerDay).toBe(0)
+    expect(Object.keys(stats.modelUsage)).toHaveLength(0)
+  })
+
+  test("sums cost and tokens across sessions", () => {
+    const stats = aggregateSessionStats([
+      session({
+        id: "a",
+        cost: 1.5,
+        tokens: { input: 100, output: 50, reasoning: 10, cache: { read: 5, write: 2 } },
+      }),
+      session({
+        id: "b",
+        cost: 0.25,
+        tokens: { input: 200, output: 30, reasoning: 0, cache: { read: 15, write: 8 } },
+      }),
+    ])
+    expect(stats.totalSessions).toBe(2)
+    expect(stats.totalCost).toBeCloseTo(1.75)
+    expect(stats.totalTokens.input).toBe(300)
+    expect(stats.totalTokens.output).toBe(80)
+    expect(stats.totalTokens.reasoning).toBe(10)
+    expect(stats.totalTokens.cache.read).toBe(20)
+    expect(stats.totalTokens.cache.write).toBe(10)
+  })
+
+  test("groups model usage by provider/model key", () => {
+    const stats = aggregateSessionStats([
+      session({
+        id: "a",
+        cost: 1,
+        tokens: { input: 10, output: 5, reasoning: 1, cache: { read: 2, write: 3 } },
+        model: { providerID: "anthropic", id: "claude" },
+      }),
+      session({
+        id: "b",
+        cost: 2,
+        tokens: { input: 20, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
+        model: { providerID: "anthropic", id: "claude" },
+      }),
+      session({
+        id: "c",
+        cost: 4,
+        tokens: { input: 1, output: 1, reasoning: 0, cache: { read: 0, write: 0 } },
+        model: { providerID: "openai", id: "gpt" },
+      }),
+    ])
+    const claude = stats.modelUsage["anthropic/claude"]
+    const gpt = stats.modelUsage["openai/gpt"]
+    expect(claude).toBeDefined()
+    expect(claude.sessions).toBe(2)
+    expect(claude.cost).toBeCloseTo(3)
+    expect(claude.tokens.input).toBe(30)
+    expect(claude.tokens.output).toBe(15)
+    expect(claude.tokens.reasoning).toBe(1)
+    expect(claude.tokens.cache.read).toBe(2)
+    expect(claude.tokens.cache.write).toBe(3)
+    expect(gpt).toBeDefined()
+    expect(gpt.sessions).toBe(1)
+    expect(gpt.cost).toBeCloseTo(4)
+  })
+
+  test("sessions without rollups contribute zero and stay out of model usage", () => {
+    const stats = aggregateSessionStats([
+      session({ id: "a" }),
+      session({ id: "b", cost: Number.NaN, tokens: undefined }),
+      session({
+        id: "c",
+        cost: 1,
+        tokens: { input: 4, output: 6, reasoning: 0, cache: { read: 0, write: 0 } },
+        model: { providerID: "p", id: "m" },
+      }),
+    ])
+    expect(stats.totalSessions).toBe(3)
+    expect(stats.totalCost).toBeCloseTo(1)
+    expect(stats.totalTokens.input).toBe(4)
+    expect(stats.totalTokens.output).toBe(6)
+    expect(Object.keys(stats.modelUsage)).toEqual(["p/m"])
+  })
+
+  test("computes per-session averages and median (even count)", () => {
+    const stats = aggregateSessionStats([
+      session({ id: "a", tokens: { input: 10, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } }),
+      session({ id: "b", tokens: { input: 30, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } }),
+      session({ id: "c", tokens: { input: 100, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } }),
+      session({ id: "d", tokens: { input: 200, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } }),
+    ])
+    expect(stats.tokensPerSession).toBeCloseTo((10 + 30 + 100 + 200) / 4)
+    expect(stats.medianTokensPerSession).toBeCloseTo((30 + 100) / 2)
+  })
+
+  test("computes date range, days and cost per day", () => {
+    const start = Date.UTC(2026, 0, 1)
+    const stats = aggregateSessionStats([
+      session({ id: "a", cost: 3, time: { created: start, updated: start + MS_IN_DAY } }),
+      session({ id: "b", cost: 5, time: { created: start + MS_IN_DAY, updated: start + 3 * MS_IN_DAY } }),
+    ])
+    expect(stats.dateRange.earliest).toBe(start)
+    expect(stats.dateRange.latest).toBe(start + 3 * MS_IN_DAY)
+    expect(stats.days).toBe(3)
+    expect(stats.costPerDay).toBeCloseTo(8 / 3)
+  })
+
+  test("single session collapses to one day", () => {
+    const at = Date.UTC(2026, 0, 1)
+    const stats = aggregateSessionStats([session({ id: "a", cost: 2, time: { created: at, updated: at } })])
+    expect(stats.days).toBe(1)
+    expect(stats.costPerDay).toBeCloseTo(2)
+  })
+})
+
+describe("formatTokenCount", () => {
+  test("keeps small numbers verbatim", () => {
+    expect(formatTokenCount(0)).toBe("0")
+    expect(formatTokenCount(999)).toBe("999")
+  })
+
+  test("compacts thousands and millions", () => {
+    expect(formatTokenCount(1_500)).toBe("1.5K")
+    expect(formatTokenCount(2_500_000)).toBe("2.5M")
+  })
+
+  test("tolerates non-finite input", () => {
+    expect(formatTokenCount(Number.NaN)).toBe("0")
+    expect(formatTokenCount(Number.POSITIVE_INFINITY)).toBe("0")
+  })
+})
+
+describe("formatCost", () => {
+  test("formats dollars with two decimals by default", () => {
+    expect(formatCost(1.2345)).toBe("$1.23")
+    expect(formatCost(0)).toBe("$0.00")
+  })
+
+  test("supports higher precision for model rows", () => {
+    expect(formatCost(0.1234, 4)).toBe("$0.1234")
+  })
+
+  test("tolerates non-finite input", () => {
+    expect(formatCost(Number.NaN)).toBe("$0.00")
+  })
+})
+
+describe("sortModelUsage", () => {
+  test("sorts by cost descending with session count tiebreak", () => {
+    const usage = aggregateSessionStats([
+      session({ id: "a", cost: 1, model: { providerID: "p", id: "cheap" } }),
+      session({ id: "b", cost: 9, model: { providerID: "p", id: "pricey" } }),
+      session({ id: "c", cost: 1, model: { providerID: "p", id: "busy" } }),
+      session({ id: "d", cost: 0, model: { providerID: "p", id: "busy" } }),
+    ]).modelUsage
+    const sorted = sortModelUsage(usage).map(([key]) => key)
+    expect(sorted).toEqual(["p/pricey", "p/busy", "p/cheap"])
+  })
+})
diff --git a/packages/app/src/utils/session-stats.ts b/packages/app/src/utils/session-stats.ts
new file mode 100644
index 00000000..db28121d
--- /dev/null
+++ b/packages/app/src/utils/session-stats.ts
@@ -0,0 +1,188 @@
+// PARITY-001: cross-session cost/token aggregation for the GUI.
+//
+// Mirrors the CLI `stats` command (packages/deepagent-code/src/cli/cmd/stats.ts) but aggregates
+// over the sessions already synced into the directory store (`store.session`) instead of reading
+// the database directly. The SDK `Session` type carries `cost`, `tokens` and `model` per session,
+// so no new API endpoint is needed. Per-message breakdowns (tool usage, per-message model usage)
+// are intentionally out of scope here — the store only carries session-level rollups.
+
+/** Structural slice of the SDK `Session` shape this aggregation consumes. */
+export interface StatsSession {
+  readonly id: string
+  readonly parentID?: string
+  readonly cost?: number
+  readonly tokens?: {
+    readonly input: number
+    readonly output: number
+    readonly reasoning: number
+    readonly cache: {
+      readonly read: number
+      readonly write: number
+    }
+  }
+  readonly model?: {
+    readonly id: string
+    readonly providerID: string
+  }
+  readonly time: {
+    readonly created: number
+    readonly updated: number
+  }
+}
+
+export interface StatsModelUsage {
+  readonly sessions: number
+  readonly cost: number
+  readonly tokens: {
+    readonly input: number
+    readonly output: number
+    readonly reasoning: number
+    readonly cache: {
+      readonly read: number
+      readonly write: number
+    }
+  }
+}
+
+export interface SessionStats {
+  readonly totalSessions: number
+  readonly totalCost: number
+  readonly totalTokens: {
+    readonly input: number
+    readonly output: number
+    readonly reasoning: number
+    readonly cache: {
+      readonly read: number
+      readonly write: number
+    }
+  }
+  /** Keyed by `${providerID}/${modelID}`, matching the CLI stats model keys. */
+  readonly modelUsage: Record<string, StatsModelUsage>
+  readonly dateRange: {
+    readonly earliest: number
+    readonly latest: number
+  }
+  readonly days: number
+  readonly costPerDay: number
+  readonly tokensPerSession: number
+  readonly medianTokensPerSession: number
+}
+
+const MS_IN_DAY = 24 * 60 * 60 * 1000
+
+const emptyTokens = () => ({ input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } })
+
+const totalOf = (tokens: SessionStats["totalTokens"]) =>
+  tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write
+
+/**
+ * Aggregate per-session cost/token rollups into a cross-session overview.
+ *
+ * Pure and allocation-light so it can run inside a `createMemo` on every store update. Sessions
+ * missing `cost`/`tokens` (older rows, not yet rolled up) contribute zero.
+ */
+export function aggregateSessionStats(sessions: readonly StatsSession[]): SessionStats {
+  const totalTokens = emptyTokens()
+  const modelUsage: Record<string, StatsModelUsage> = {}
+  const sessionTotals: number[] = []
+  let totalCost = 0
+  let earliest = 0
+  let latest = 0
+
+  for (const session of sessions) {
+    const cost = typeof session.cost === "number" && Number.isFinite(session.cost) ? session.cost : 0
+    const tokens = session.tokens
+    totalCost += cost
+    if (tokens) {
+      totalTokens.input += tokens.input || 0
+      totalTokens.output += tokens.output || 0
+      totalTokens.reasoning += tokens.reasoning || 0
+      totalTokens.cache.read += tokens.cache?.read || 0
+      totalTokens.cache.write += tokens.cache?.write || 0
+    }
+    sessionTotals.push(totalOf({ ...emptyTokens(), ...tokens, cache: { ...emptyTokens().cache, ...tokens?.cache } }))
+
+    if (session.model) {
+      const key = `${session.model.providerID}/${session.model.id}`
+      const existing = modelUsage[key]
+      const merged: StatsModelUsage = existing
+        ? {
+            sessions: existing.sessions + 1,
+            cost: existing.cost + cost,
+            tokens: {
+              input: existing.tokens.input + (tokens?.input || 0),
+              output: existing.tokens.output + (tokens?.output || 0),
+              reasoning: existing.tokens.reasoning + (tokens?.reasoning || 0),
+              cache: {
+                read: existing.tokens.cache.read + (tokens?.cache?.read || 0),
+                write: existing.tokens.cache.write + (tokens?.cache?.write || 0),
+              },
+            },
+          }
+        : {
+            sessions: 1,
+            cost,
+            tokens: {
+              input: tokens?.input || 0,
+              output: tokens?.output || 0,
+              reasoning: tokens?.reasoning || 0,
+              cache: {
+                read: tokens?.cache?.read || 0,
+                write: tokens?.cache?.write || 0,
+              },
+            },
+          }
+      modelUsage[key] = merged
+    }
+
+    const created = session.time?.created ?? 0
+    const updated = session.time?.updated ?? created
+    if (earliest === 0 || (created > 0 && created < earliest)) earliest = created
+    if (updated > latest) latest = updated
+  }
+
+  const days = earliest > 0 && latest > earliest ? Math.max(1, Math.ceil((latest - earliest) / MS_IN_DAY)) : 1
+  const grandTotal = totalOf(totalTokens)
+  sessionTotals.sort((a, b) => a - b)
+  const mid = Math.floor(sessionTotals.length / 2)
+  const median =
+    sessionTotals.length === 0
+      ? 0
+      : sessionTotals.length % 2 === 0
+        ? (sessionTotals[mid - 1] + sessionTotals[mid]) / 2
+        : sessionTotals[mid]
+
+  return {
+    totalSessions: sessions.length,
+    totalCost,
+    totalTokens,
+    modelUsage,
+    dateRange: { earliest, latest },
+    days,
+    costPerDay: totalCost / days,
+    tokensPerSession: sessions.length > 0 ? grandTotal / sessions.length : 0,
+    medianTokensPerSession: median,
+  }
+}
+
+/** Compact token formatting shared with the CLI display (1.2K / 3.4M). */
+export function formatTokenCount(num: number): string {
+  if (!Number.isFinite(num)) return "0"
+  const value = Math.round(num)
+  if (value >= 1_000_000) return (value / 1_000_000).toFixed(1) + "M"
+  if (value >= 1_000) return (value / 1_000).toFixed(1) + "K"
+  return value.toString()
+}
+
+/** Dollar formatting for overview-level costs (two decimals). */
+export function formatCost(cost: number, decimals = 2): string {
+  const value = Number.isFinite(cost) ? cost : 0
+  return `$${value.toFixed(decimals)}`
+}
+
+/** Model usage rows sorted by cost descending (ties: session count descending). */
+export function sortModelUsage(modelUsage: Record<string, StatsModelUsage>): Array<[string, StatsModelUsage]> {
+  return Object.entries(modelUsage).sort(
+    ([, a], [, b]) => b.cost - a.cost || b.sessions - a.sessions,
+  )
+}
diff --git a/packages/cli/script/generate.ts b/packages/cli/script/generate.ts
index 9ad25383..b2977434 100755
--- a/packages/cli/script/generate.ts
+++ b/packages/cli/script/generate.ts
@@ -1,7 +1,23 @@
-const modelsUrl = process.env.DEEPAGENT_CODE_MODELS_URL || "https://models.dev"
+// Clean-build policy: ordered list of fresh remote endpoints; fail closed when all fail (never
+// fall back to a stale local snapshot). Default chain: models.dev then the Gitee mirror of
+// deepagent-ltd/models.dev (hourly-synced, reachable from CN networks).
+const modelsURLs = (
+  process.env.DEEPAGENT_CODE_MODELS_URL?.trim() ||
+  "https://models.dev,https://gitee.com/deepagent-ai/models.dev/raw/main"
+)
+  .split(",")
+  .map((url) => url.trim().replace(/\/$/, ""))
+  .filter((url) => url.length > 0)
 
-export const modelsData = process.env.MODELS_DEV_API_JSON
-  ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
-  : await fetch(`${modelsUrl}/api.json`).then((response) => response.text())
+async function load() {
+  if (process.env.MODELS_DEV_API_JSON) return Bun.file(process.env.MODELS_DEV_API_JSON).text()
+  for (const modelsUrl of modelsURLs) {
+    const response = await fetch(`${modelsUrl}/api.json`).catch(() => undefined)
+    if (response?.ok) return response.text()
+  }
+  throw new Error(`Unable to load models.dev catalog from ${modelsURLs.join(", ")}`)
+}
+
+export const modelsData = await load()
 
 console.log("Loaded models.dev snapshot")
diff --git a/packages/cli/src/services/daemon.ts b/packages/cli/src/services/daemon.ts
index 3cc3fa99..83294338 100644
--- a/packages/cli/src/services/daemon.ts
+++ b/packages/cli/src/services/daemon.ts
@@ -32,6 +32,12 @@ function sameRegistration(left: Registration, right: Registration) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
 
+// PARITY-003 (Wave 0): the daemon's spawn target is switchable. DEEPAGENT_CODE_DAEMON_BACKEND=legacy
+// mounts the full legacy deepagent-code server instead of the v2 `serve`; the legacy entrypoint is
+// resolved from DEEPAGENT_CODE_DAEMON_LEGACY_ENTRYPOINT. Read lazily so each call observes the
+// current environment.
+const backend = () => (process.env.DEEPAGENT_CODE_DAEMON_BACKEND === "legacy" ? "legacy" : "v2")
+
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -63,8 +69,30 @@ export const layer = Layer.effect(
       return createOpencodeClient({ baseUrl: url, headers: ServerAuth.headers({ password: yield* password() }) })
     })
 
+    // The legacy server exposes GET /global/health -> { healthy, version, runtimeId } guarded by
+    // the same Basic-auth credential, instead of the v2 /api/health SDK route.
+    const legacyHealth = Effect.fnUntraced(function* (info: Registration) {
+      const credential = yield* password()
+      const body = yield* Effect.tryPromise({
+        try: async () => {
+          const response = await fetch(`${info.url}/global/health`, {
+            headers: ServerAuth.headers({ password: credential }),
+            signal: AbortSignal.timeout(2_000),
+          })
+          if (!response.ok) throw new Error(`Legacy health endpoint responded ${response.status}`)
+          return (await response.json()) as { healthy?: boolean; version?: string }
+        },
+        catch: (cause) => new Error("Legacy health check failed", { cause }),
+      })
+      if (body?.healthy !== true) return yield* Effect.fail(new Error("Registered server is not healthy"))
+      // The legacy endpoint reports its own version; prefer it so compatible() keeps the same
+      // handshake semantics as the v2 registration file.
+      return typeof body.version === "string" ? { ...info, version: body.version } : info
+    })
+
     const healthy = Effect.fnUntraced(function* () {
       const info = yield* registration()
+      if (backend() === "legacy") return yield* legacyHealth(info)
       const client = yield* createClient(info.url)
       const response = yield* Effect.tryPromise(() => client.v2.health.get({ signal: AbortSignal.timeout(2_000) }))
       if (response.data?.healthy === true) return info
@@ -114,18 +142,37 @@ export const layer = Layer.effect(
       if (found?.version === InstallationVersion && compiled) return found.url
       if (found) yield* stopProcess(found).pipe(Effect.ignore)
 
-      const entrypoint = compiled ? undefined : process.argv[1]
-      if (!compiled && entrypoint === undefined)
-        return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
-      yield* Effect.try({
-        try: () => {
-          spawn(process.execPath, [...(entrypoint ? [entrypoint] : []), "serve", "--register"], {
-            detached: true,
-            stdio: "ignore",
-          }).unref()
-        },
-        catch: (cause) => new Error("Failed to start server", { cause }),
-      })
+      if (backend() === "legacy") {
+        // Wave 0: spawn the legacy deepagent-code CLI `serve --register`. The password is passed
+        // through the environment the legacy server already honors (DEEPAGENT_CODE_SERVER_PASSWORD).
+        const legacyEntrypoint = process.env.DEEPAGENT_CODE_DAEMON_LEGACY_ENTRYPOINT
+        if (!legacyEntrypoint)
+          return yield* Effect.fail(new Error("DEEPAGENT_CODE_DAEMON_LEGACY_ENTRYPOINT is required for the legacy backend"))
+        const credential = yield* password()
+        yield* Effect.try({
+          try: () => {
+            spawn(process.execPath, [legacyEntrypoint, "serve", "--register"], {
+              detached: true,
+              stdio: "ignore",
+              env: { ...process.env, DEEPAGENT_CODE_SERVER_PASSWORD: credential },
+            }).unref()
+          },
+          catch: (cause) => new Error("Failed to start legacy server", { cause }),
+        })
+      } else {
+        const entrypoint = compiled ? undefined : process.argv[1]
+        if (!compiled && entrypoint === undefined)
+          return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
+        yield* Effect.try({
+          try: () => {
+            spawn(process.execPath, [...(entrypoint ? [entrypoint] : []), "serve", "--register"], {
+              detached: true,
+              stdio: "ignore",
+            }).unref()
+          },
+          catch: (cause) => new Error("Failed to start server", { cause }),
+        })
+      }
 
       return yield* compatible().pipe(
         Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
diff --git a/packages/cli/test/daemon.test.ts b/packages/cli/test/daemon.test.ts
new file mode 100644
index 00000000..611855fd
--- /dev/null
+++ b/packages/cli/test/daemon.test.ts
@@ -0,0 +1,151 @@
+// PARITY-003 (Wave 0): daemon mounting the legacy deepagent-code server.
+//
+// Covers the legacy-specific daemon paths without touching the v2 behavior:
+//   * status() resolves a legacy registration through GET /global/health (Basic auth + version)
+//   * an unauthenticated/unknown legacy server is treated as unhealthy and deregistered
+//   * start() spawns the legacy entrypoint with the password in the environment, completes the
+//     version handshake, and stop() tears the process down and removes the registration
+import { afterAll, afterEach, beforeEach, describe, expect, it } from "bun:test"
+import { InstallationVersion } from "@deepagent-code/core/installation/version"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import { Effect } from "effect"
+import { mkdir, readFile, rm, writeFile, access } from "fs/promises"
+import { mkdtemp } from "fs/promises"
+import { tmpdir } from "os"
+import path from "path"
+import { Daemon } from "../src/services/daemon"
+
+const run = <A, E>(effect: Effect.Effect<A, E, Daemon.Service>) =>
+  Effect.runPromise(
+    effect.pipe(Effect.provide(Daemon.defaultLayer), Effect.provide(NodeServices.layer), Effect.scoped),
+  )
+
+const withDaemon = <A>(use: (daemon: Daemon.Interface) => Effect.Effect<A, unknown, never>) =>
+  run(Effect.flatMap(Daemon.Service, use))
+
+const exists = (file: string) => access(file).then(
+  () => true,
+  () => false,
+)
+
+const fixtureEntrypoint = path.join(__dirname, "fixtures", "legacy-entry.ts")
+
+let home: string
+const homes: string[] = []
+
+const stateFile = () => path.join(home, "state", "server.json")
+
+beforeEach(async () => {
+  home = await mkdtemp(path.join(tmpdir(), "dacode-daemon-test-"))
+  homes.push(home)
+  await mkdir(path.join(home, "state"), { recursive: true })
+  process.env.DEEPAGENT_CODE_TEST_HOME = home
+  process.env.DEEPAGENT_CODE_HOME = home
+  process.env.DEEPAGENT_CODE_DAEMON_BACKEND = "legacy"
+  delete process.env.DEEPAGENT_CODE_DAEMON_LEGACY_ENTRYPOINT
+  delete process.env.DEEPAGENT_CODE_DAEMON_FIXTURE_VERSION
+})
+
+afterEach(() => {
+  delete process.env.DEEPAGENT_CODE_DAEMON_BACKEND
+  delete process.env.DEEPAGENT_CODE_DAEMON_LEGACY_ENTRYPOINT
+  delete process.env.DEEPAGENT_CODE_DAEMON_FIXTURE_VERSION
+})
+
+afterAll(async () => {
+  delete process.env.DEEPAGENT_CODE_HOME
+  delete process.env.DEEPAGENT_CODE_TEST_HOME
+  await Promise.all(homes.map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+function fakeLegacyServer(version: string, expectedPassword?: () => string) {
+  let seenAuth: string | undefined
+  const server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    fetch(request) {
+      const url = new URL(request.url)
+      if (url.pathname === "/global/health") {
+        seenAuth = request.headers.get("authorization") ?? undefined
+        const expected = `Basic ${Buffer.from(`deepagent-code:${expectedPassword?.() ?? ""}`).toString("base64")}`
+        if (seenAuth !== expected) return Response.json({ error: "unauthorized" }, { status: 401 })
+        return Response.json({ healthy: true, version, runtimeId: "fake" })
+      }
+      return Response.json({ error: "not found" }, { status: 404 })
+    },
+  })
+  return { server, url: `http://127.0.0.1:${server.port}`, seenAuth: () => seenAuth }
+}
+
+describe("daemon legacy backend (PARITY-003)", () => {
+  it("resolves a legacy registration through /global/health with Basic auth", async () => {
+    let password = ""
+    const fake = fakeLegacyServer(InstallationVersion, () => password)
+    try {
+      password = await withDaemon((daemon) => daemon.password())
+      await writeFile(
+        stateFile(),
+        JSON.stringify({ id: "fixed", version: InstallationVersion, url: fake.url, pid: process.pid }),
+      )
+      const url = await withDaemon((daemon) => daemon.status())
+      expect(url).toBe(fake.url)
+      expect(fake.seenAuth()).toBe(`Basic ${Buffer.from(`deepagent-code:${password}`).toString("base64")}`)
+    } finally {
+      fake.server.stop()
+    }
+  })
+
+  it("treats an unauthenticated legacy server as unhealthy and clears the registration", async () => {
+    // The fake demands a password the daemon does not know (none generated yet on its side;
+    // generate one that differs from the fake's expected credential).
+    const fake = fakeLegacyServer(InstallationVersion, () => "some-other-secret")
+    try {
+      await withDaemon((daemon) => daemon.password("daemon-secret"))
+      await writeFile(
+        stateFile(),
+        JSON.stringify({ id: "fixed", version: InstallationVersion, url: fake.url, pid: process.pid }),
+      )
+      const url = await withDaemon((daemon) => daemon.status())
+      expect(url).toBeUndefined()
+      expect(await exists(stateFile())).toBe(false)
+    } finally {
+      fake.server.stop()
+    }
+  })
+
+  it("start() spawns the legacy entrypoint, completes the handshake, and stop() tears it down", async () => {
+    process.env.DEEPAGENT_CODE_DAEMON_LEGACY_ENTRYPOINT = fixtureEntrypoint
+    process.env.DEEPAGENT_CODE_DAEMON_FIXTURE_VERSION = InstallationVersion
+
+    const url = await withDaemon((daemon) => daemon.start())
+    expect(url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/)
+
+    const registration = JSON.parse(await readFile(stateFile(), "utf8"))
+    expect(registration.version).toBe(InstallationVersion)
+    expect(registration.url).toBe(url)
+    expect(registration.pid).toBeGreaterThan(0)
+
+    // The spawned server received the daemon's password and authenticates health checks with it.
+    const password = await withDaemon((daemon) => daemon.password())
+    const health = await fetch(`${url}/global/health`, {
+      headers: { Authorization: `Basic ${Buffer.from(`deepagent-code:${password}`).toString("base64")}` },
+    })
+    expect(health.status).toBe(200)
+    expect(await health.json()).toMatchObject({ healthy: true, version: InstallationVersion })
+
+    await withDaemon((daemon) => daemon.stop())
+    expect(await exists(stateFile())).toBe(false)
+
+    // The spawned process stepped down on SIGTERM.
+    const pid = registration.pid as number
+    for (let i = 0; i < 100; i++) {
+      try {
+        process.kill(pid, 0)
+      } catch {
+        return
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50))
+    }
+    throw new Error(`Legacy server process ${pid} is still running after stop()`)
+  }, 15_000)
+})
diff --git a/packages/cli/test/fixtures/legacy-entry.ts b/packages/cli/test/fixtures/legacy-entry.ts
new file mode 100644
index 00000000..fc67936f
--- /dev/null
+++ b/packages/cli/test/fixtures/legacy-entry.ts
@@ -0,0 +1,62 @@
+// PARITY-003 (Wave 0) fixture: a minimal stand-in for the legacy deepagent-code CLI entrypoint.
+//
+// Implements exactly the protocol surface the daemon relies on when mounting a legacy server:
+//   * `serve --register` listens on an ephemeral port and exposes GET /global/health guarded by
+//     Basic auth (the same DEEPAGENT_CODE_SERVER_PASSWORD credential the daemon injects).
+//   * Writes state/server.json ({ id, version, url, pid }) atomically under the isolated test
+//     home, mirroring registerWithDaemon in packages/deepagent-code/src/cli/cmd/serve.ts.
+//   * Steps down on SIGTERM: removes the registration it owns, then exits.
+//
+// Plain Node/Bun on purpose — importing the real legacy CLI would drag in the whole app runtime.
+import { randomUUID } from "node:crypto"
+import fsSync from "node:fs"
+import path from "node:path"
+
+const version = process.env.DEEPAGENT_CODE_DAEMON_FIXTURE_VERSION ?? "local"
+const stateDir = path.join(process.env.DEEPAGENT_CODE_HOME ?? process.cwd(), "state")
+const file = path.join(stateDir, "server.json")
+
+const read = (): { id?: string } | undefined => {
+  try {
+    return JSON.parse(fsSync.readFileSync(file, "utf8"))
+  } catch {
+    return undefined
+  }
+}
+const id = randomUUID()
+const owned = () => read()?.id === id
+const expectedAuth = `Basic ${Buffer.from(`deepagent-code:${process.env.DEEPAGENT_CODE_SERVER_PASSWORD ?? ""}`).toString("base64")}`
+
+const server = Bun.serve({
+  port: 0,
+  hostname: "127.0.0.1",
+  fetch(request) {
+    const url = new URL(request.url)
+    if (url.pathname === "/global/health") {
+      if (request.headers.get("authorization") !== expectedAuth) {
+        return Response.json({ error: "unauthorized" }, { status: 401 })
+      }
+      return Response.json({ healthy: true, version, runtimeId: "fixture" })
+    }
+    return Response.json({ error: "not found" }, { status: 404 })
+  },
+})
+
+fsSync.mkdirSync(stateDir, { recursive: true })
+const temp = `${file}.${id}.tmp`
+fsSync.writeFileSync(temp, JSON.stringify({ id, version, url: `http://127.0.0.1:${server.port}`, pid: process.pid }), {
+  mode: 0o600,
+})
+fsSync.renameSync(temp, file)
+
+process.on("SIGTERM", () => {
+  if (owned()) {
+    try {
+      fsSync.unlinkSync(file)
+    } catch {
+      // A concurrent takeover may have already replaced the file.
+    }
+  }
+  server.stop(true)
+  process.exit(0)
+})
diff --git a/packages/core/migration/20260816073717_session_facade_activity/migration.sql b/packages/core/migration/20260816073717_session_facade_activity/migration.sql
new file mode 100644
index 00000000..e26c4f2a
--- /dev/null
+++ b/packages/core/migration/20260816073717_session_facade_activity/migration.sql
@@ -0,0 +1,20 @@
+CREATE TABLE `session_facade_activity` (
+	`activity_id` text PRIMARY KEY,
+	`subkind` text NOT NULL,
+	`parent_session_id` text NOT NULL,
+	`owner_session_id` text,
+	`spawn_tool_call_id` text,
+	`objective_text` text,
+	`budget_json` text,
+	`state` text NOT NULL,
+	`reason_code` text,
+	`source` text,
+	`created_at` integer NOT NULL,
+	`settled_at` integer,
+	`mutation_epoch` integer NOT NULL,
+	CONSTRAINT `fk_session_facade_activity_parent_session_id_session_id_fk` FOREIGN KEY (`parent_session_id`) REFERENCES `session`(`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_session_facade_activity_owner_session_id_session_id_fk` FOREIGN KEY (`owner_session_id`) REFERENCES `session`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `session_facade_activity_active_idx` ON `session_facade_activity` (`parent_session_id`,`subkind`) WHERE "session_facade_activity"."state" = 'active';--> statement-breakpoint
+CREATE INDEX `session_facade_activity_parent_idx` ON `session_facade_activity` (`parent_session_id`,`state`,`created_at`);
\ No newline at end of file
diff --git a/packages/core/migration/20260816073717_session_facade_activity/snapshot.json b/packages/core/migration/20260816073717_session_facade_activity/snapshot.json
new file mode 100644
index 00000000..8a38b8fb
--- /dev/null
+++ b/packages/core/migration/20260816073717_session_facade_activity/snapshot.json
@@ -0,0 +1,16233 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "id": "29b4297e-5c48-49d6-9ea2-61cdd1e56475",
+  "prevIds": [
+    "0a9c6817-9da1-42d9-9c11-86d9fd55fae8"
+  ],
+  "ddl": [
+    {
+      "name": "workspace",
+      "entityType": "tables"
+    },
+    {
+      "name": "data_migration",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_effect_receipt",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_evidence",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_objective",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_permission_decision",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_permission_effect_dispatch",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_permission_once_consumption",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_permission_owner_lease",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_permission_request",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_activity_progress_observation",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_facade_activity",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_admission_outbox",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_governance_action",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_governance_compensation",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_governance_plan",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_job",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_lifecycle_trigger_receipt",
+      "entityType": "tables"
+    },
+    {
+      "name": "learning_reviewer_attempt",
+      "entityType": "tables"
+    },
+    {
+      "name": "released_knowledge_evaluation",
+      "entityType": "tables"
+    },
+    {
+      "name": "released_knowledge_snapshot_document",
+      "entityType": "tables"
+    },
+    {
+      "name": "released_knowledge_snapshot_head",
+      "entityType": "tables"
+    },
+    {
+      "name": "released_knowledge_snapshot",
+      "entityType": "tables"
+    },
+    {
+      "name": "file_part_artifact_binding",
+      "entityType": "tables"
+    },
+    {
+      "name": "file_part_artifact_chunk",
+      "entityType": "tables"
+    },
+    {
+      "name": "file_part_artifact_discard",
+      "entityType": "tables"
+    },
+    {
+      "name": "file_part_artifact_import",
+      "entityType": "tables"
+    },
+    {
+      "name": "file_part_artifact",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_v2_provider_parity_baseline",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_v2_provider_parity_receipt",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_v2_provider_turn_receipt",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_transfer_operation",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_transfer_target_receipt",
+      "entityType": "tables"
+    },
+    {
+      "name": "account_state",
+      "entityType": "tables"
+    },
+    {
+      "name": "account",
+      "entityType": "tables"
+    },
+    {
+      "name": "control_account",
+      "entityType": "tables"
+    },
+    {
+      "name": "context_location_identity_alias",
+      "entityType": "tables"
+    },
+    {
+      "name": "context_location_identity",
+      "entityType": "tables"
+    },
+    {
+      "name": "location_index_coordination",
+      "entityType": "tables"
+    },
+    {
+      "name": "context_project_scope_identity_alias",
+      "entityType": "tables"
+    },
+    {
+      "name": "context_project_scope_identity",
+      "entityType": "tables"
+    },
+    {
+      "name": "context_security_namespace",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_artifact_chunk",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_artifact",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_compaction_receipt",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_dedupe",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_sequence",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_snapshot_attempt",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_snapshot_chunk",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_snapshot_row",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_snapshot",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_sync_backfill",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_sync_index",
+      "entityType": "tables"
+    },
+    {
+      "name": "event_sync_sequence",
+      "entityType": "tables"
+    },
+    {
+      "name": "event",
+      "entityType": "tables"
+    },
+    {
+      "name": "workspace_sync_cursor",
+      "entityType": "tables"
+    },
+    {
+      "name": "im_attachments",
+      "entityType": "tables"
+    },
+    {
+      "name": "im_groups",
+      "entityType": "tables"
+    },
+    {
+      "name": "im_members",
+      "entityType": "tables"
+    },
+    {
+      "name": "im_messages",
+      "entityType": "tables"
+    },
+    {
+      "name": "location_change_event",
+      "entityType": "tables"
+    },
+    {
+      "name": "location_projection_dirty_path",
+      "entityType": "tables"
+    },
+    {
+      "name": "location_projection_registration",
+      "entityType": "tables"
+    },
+    {
+      "name": "permission_saved_epoch",
+      "entityType": "tables"
+    },
+    {
+      "name": "permission",
+      "entityType": "tables"
+    },
+    {
+      "name": "project_directory",
+      "entityType": "tables"
+    },
+    {
+      "name": "project",
+      "entityType": "tables"
+    },
+    {
+      "name": "message",
+      "entityType": "tables"
+    },
+    {
+      "name": "part",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_context_epoch",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_fork_admission",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_fork_intent",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_history_state",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_input",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_intent",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_message",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_part_integrity_quarantine",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_prompt_epoch_message",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_prompt_epoch_recovery",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_steer",
+      "entityType": "tables"
+    },
+    {
+      "name": "session",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_tool_request_resolution_command",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_tool_request_resolution",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_world_state_baseline",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_admission",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_notification_outbox",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_run_event",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_run",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_structured_finalizer_response",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_structured_output_evidence_part",
+      "entityType": "tables"
+    },
+    {
+      "name": "task_structured_output_evidence",
+      "entityType": "tables"
+    },
+    {
+      "name": "todo",
+      "entityType": "tables"
+    },
+    {
+      "name": "session_share",
+      "entityType": "tables"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "''",
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "branch",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "directory",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "extra",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_used",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "data_migration"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_completed",
+      "entityType": "columns",
+      "table": "data_migration"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_kind",
+      "entityType": "columns",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_id",
+      "entityType": "columns",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "effect_fingerprint",
+      "entityType": "columns",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "first_observation_revision",
+      "entityType": "columns",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_kind",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evidence_fingerprint",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evidence_kind",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_receipt_id",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "first_observation_revision",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_activity_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_kind",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admission_fingerprint",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "objective_fingerprint",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "objective_text",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "completion_criteria",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "enforcement_state",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "stall_threshold",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "no_progress_count",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "latest_observation_revision",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "latest_vector_hash",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "next_action",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "terminal_reason",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "session_activity_objective"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "decision_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "idempotency_key",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "decision",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "actor_type",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "actor_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "scope",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "authority_epoch",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "decided_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expires_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "feedback",
+      "entityType": "columns",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_kind",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_message_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_call_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_name",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "consumer_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "idempotency_key",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "outcome",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_json",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_hash",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "started_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_once_consumption"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "consumer_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_once_consumption"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "idempotency_key",
+      "entityType": "columns",
+      "table": "session_activity_permission_once_consumption"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "consumed_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_once_consumption"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_owner_lease"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_owner_lease"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "heartbeat_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_owner_lease"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_kind",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_kind",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "idempotency_key",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "permission",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "patterns",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "always_patterns",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "metadata_hash",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_message_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_call_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "authority_epoch",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "requested_scope",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_type",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expires_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "decided_at",
+      "entityType": "columns",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_kind",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "revision",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "idempotency_key",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observation_fingerprint",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expected_objective_version",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_revision",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "plan_version",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "validation_fingerprint",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evidence_set_hash",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "effect_receipt_set_hash",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "vector_hash",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "next_action",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "changed",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "no_progress_count",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_at",
+      "entityType": "columns",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activity_id",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "subkind",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_session_id",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_session_id",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "spawn_tool_call_id",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "objective_text",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "budget_json",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason_code",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "mutation_epoch",
+      "entityType": "columns",
+      "table": "session_facade_activity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "intent_id",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "trigger",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "dedupe_key",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_json",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_fingerprint",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "job_id",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "candidate_input_ref",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "rejection_code",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "rejection_detail",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "action_id",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "plan_id",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "candidate_id",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sequence",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "kind",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "predecessor_action_id",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_json",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_fingerprint",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_ref",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_hash",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_fingerprint",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_detail",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_governance_action"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "compensation_id",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "plan_id",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "action_id",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sequence",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "kind",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_payload_fingerprint",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_ref",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_hash",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_fingerprint",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_detail",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "plan_id",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "job_id",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "policy",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_json",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_fingerprint",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "action_count",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "job_owner",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_job_version",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "job_started_version",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_ref",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_hash",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_fingerprint",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_detail",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_governance_plan"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "job_id",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "trigger",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "dedupe_key",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "candidate_input_ref",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "policy",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "max_attempts",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admission_fingerprint",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "attempts",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "side_effect_state",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "side_effect_kind",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expected_result_ref",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "review_job_id",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_ref",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_detail",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settlement_fingerprint",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "next_attempt_at",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "started_at",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_job"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_id",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "trigger",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "boundary_key",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_admission_hash",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_terminal_hash",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_path",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_hash",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_json",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admission_fingerprint",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admission_json",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_detail",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "attempt_id",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "job_id",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "review_session_id",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_ref",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_candidate_ids_json",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_candidate_set_hash",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "provider_id",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "model_id",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "policy_hash",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "response_ref",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "response_hash",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "verdict",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "selected_candidate_ids_json",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "selected_subset_hash",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_detail",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "dispatched_at",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evaluation_id",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_scope_key",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "matrix_hash",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "matrix_json",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "document_manifest_json",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "baseline_ref",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "repetitions",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evaluator_type",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evaluator_id",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "ordinal",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_store",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "doc_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "doc_version",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "doc_hash",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "doc_type",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "doc_scope",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_scope_key",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "generation",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_scope_key",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_project_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_snapshot_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evaluation_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "release_kind",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "document_count",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "published_generation",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "verdict",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "failure_reason",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "actor_type",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "actor_id",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "finalized_at",
+      "entityType": "columns",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "part_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "original_data_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_chunk"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_index",
+      "entityType": "columns",
+      "table": "file_part_artifact_chunk"
+    },
+    {
+      "type": "blob",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "file_part_artifact_chunk"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_chunk"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "original_data_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "original_data_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "body_hash",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "body_bytes",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_bytes",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_count",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "codec_version",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "complete",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "file_part_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "campaign_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "case_name",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_receipt_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prepared_turn",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "outcome_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "outcome_artifact",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_response_fingerprint",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evidence",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "settled_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "campaign_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "case_name",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_receipt_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "core_v2_receipt_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_request_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "core_v2_request_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_outcome_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "core_v2_outcome_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_prepared_turn",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "core_v2_prepared_turn",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "diff_artifact",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "allowlist_version",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "allowlisted_differences",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "disallowed_differences",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "evidence",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "verified",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_ordinal",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "user_message_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "history_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "history_source_end_message_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_input_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "provider_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "model_id",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "protocol",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_mode",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_token",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prepared_turn_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "wire_request_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prepared_turn",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "outcome_hash",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "outcome_artifact",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "dispatching_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "first_event_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "terminal_at",
+      "entityType": "columns",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "transfer_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_workspace_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_workspace_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_owner_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_owner_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_event_seq",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_hash",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error_code",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "completed_at",
+      "entityType": "columns",
+      "table": "session_transfer_operation"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "transfer_id",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_snapshot_id",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_snapshot_hash",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_event_seq",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_workspace_id",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_owner_id",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activated_snapshot_id",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "activated_at",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_transfer_target_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "account_state"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "active_account_id",
+      "entityType": "columns",
+      "table": "account_state"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "active_org_id",
+      "entityType": "columns",
+      "table": "account_state"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "url",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "access_token",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "refresh_token",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "token_expiry",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "url",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "access_token",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "refresh_token",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "token_expiry",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "active",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "control_account"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "old_canonical_root",
+      "entityType": "columns",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "location_key",
+      "entityType": "columns",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "location_key",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_scope_key",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_binding",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_root",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_project_id",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "retired_at",
+      "entityType": "columns",
+      "table": "context_location_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "location_key",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "index_space_id",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "projection_kind",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "index_incarnation",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "db_locator",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "fencing_token",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expires_at",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "replacement_state",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "location_index_coordination"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "old_project_identity_hash",
+      "entityType": "columns",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_scope_key",
+      "entityType": "columns",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "security_namespace_id",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_scope_key",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_kind",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_identity_hash",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_project_id",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "retired_at",
+      "entityType": "columns",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "context_security_namespace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "kind",
+      "entityType": "columns",
+      "table": "context_security_namespace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "binding_hash",
+      "entityType": "columns",
+      "table": "context_security_namespace"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "context_security_namespace"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "retired_at",
+      "entityType": "columns",
+      "table": "context_security_namespace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "event_artifact_chunk"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_index",
+      "entityType": "columns",
+      "table": "event_artifact_chunk"
+    },
+    {
+      "type": "blob",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "event_artifact_chunk"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_hash",
+      "entityType": "columns",
+      "table": "event_artifact_chunk"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "artifact_id",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "kind",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "original_data_hash",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data_hash",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "canonical_data",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "body_hash",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "body_bytes",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_count",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "codec_version",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "event_artifact"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "through_seq",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "codec",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "schema_version",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cursor_seq",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "deleted_count",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data_hash",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_data",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "compacted_at",
+      "entityType": "columns",
+      "table": "event_dedupe"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_sequence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "event_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "event_sequence"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "retention_floor_seq",
+      "entityType": "columns",
+      "table": "event_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "event_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "write_fence_transfer_id",
+      "entityType": "columns",
+      "table": "event_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "through_seq",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expected_latest",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "codec",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "schema_version",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "projection_revision",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cursor",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "row_count",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "encoded_bytes",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "content_hash",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tables",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "row_hash",
+      "entityType": "columns",
+      "table": "event_snapshot_chunk"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_index",
+      "entityType": "columns",
+      "table": "event_snapshot_chunk"
+    },
+    {
+      "type": "blob",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "event_snapshot_chunk"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_hash",
+      "entityType": "columns",
+      "table": "event_snapshot_chunk"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "row_index",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "table_name",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "row_key",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "row_hash",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "row_bytes",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chunk_count",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "chain_hash",
+      "entityType": "columns",
+      "table": "event_snapshot_row"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_id",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "through_seq",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sync_seq",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "codec",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "schema_version",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot_hash",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "body",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_id",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "event_snapshot"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cursor_rowid",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "high_water_rowid",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "processed_count",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "started_at",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "completed_at",
+      "entityType": "columns",
+      "table": "event_sync_backfill"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sync_seq",
+      "entityType": "columns",
+      "table": "event_sync_index"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "event_sync_index"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event_sync_index"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "event_sync_index"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "event_sync_sequence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "event_sync_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "generation",
+      "entityType": "columns",
+      "table": "event_sync_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cursor_secret",
+      "entityType": "columns",
+      "table": "event_sync_sequence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "backfill_complete",
+      "entityType": "columns",
+      "table": "event_sync_sequence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "aggregate_id",
+      "entityType": "columns",
+      "table": "event"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "event"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sync_seq",
+      "entityType": "columns",
+      "table": "event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_id",
+      "entityType": "columns",
+      "table": "workspace_sync_cursor"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "remote_fingerprint",
+      "entityType": "columns",
+      "table": "workspace_sync_cursor"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cursor",
+      "entityType": "columns",
+      "table": "workspace_sync_cursor"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "workspace_sync_cursor"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_id",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "group_id",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_id",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "uploaded_by",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "storage_path",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "filename",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "mime",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "size_bytes",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "checksum",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "deleted_at",
+      "entityType": "columns",
+      "table": "im_attachments"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_id",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_by",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "deleted_at",
+      "entityType": "columns",
+      "table": "im_groups"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "group_id",
+      "entityType": "columns",
+      "table": "im_members"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "member_id",
+      "entityType": "columns",
+      "table": "im_members"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "member_type",
+      "entityType": "columns",
+      "table": "im_members"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "role",
+      "entityType": "columns",
+      "table": "im_members"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "last_read_at",
+      "entityType": "columns",
+      "table": "im_members"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "joined_at",
+      "entityType": "columns",
+      "table": "im_members"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "group_id",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sender_id",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sender_type",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "content",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "mentions",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "metadata",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reply_to_id",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery_status",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "deleted_at",
+      "entityType": "columns",
+      "table": "im_messages"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": true,
+      "default": null,
+      "generated": null,
+      "name": "event_seq",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "index_space_id",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "path",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "previous_path",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "rename_correlation_id",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "change_kind",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_mtime_ns",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_sha",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_at",
+      "entityType": "columns",
+      "table": "location_change_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "index_space_id",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "projection_kind",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "path",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "latest_event_seq",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "previous_path",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "rename_correlation_id",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "change_kind",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_mtime_ns",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "observed_sha",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "index_space_id",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "projection_kind",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "registration_epoch",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "consumed_event_seq",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reconcile_required",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "location_projection_registration"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "permission_saved_epoch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "epoch",
+      "entityType": "columns",
+      "table": "permission_saved_epoch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "table": "permission_saved_epoch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "permission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "permission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "action",
+      "entityType": "columns",
+      "table": "permission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "resource",
+      "entityType": "columns",
+      "table": "permission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "permission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "permission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "project_directory"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "directory",
+      "entityType": "columns",
+      "table": "project_directory"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "project_directory"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "project_directory"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "vcs",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "icon_url",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "icon_url_override",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "icon_color",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_initialized",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sandboxes",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "commands",
+      "entityType": "columns",
+      "table": "project"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "message"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_id",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "provenance",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "part"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "baseline",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'auto'",
+      "generated": null,
+      "name": "agent",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "baseline_seq",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "replacement_seq",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "revision",
+      "entityType": "columns",
+      "table": "session_context_epoch"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "intent_id",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "fork_mode",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_session_id",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_window_id",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_effective_history_hash",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_message_count",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_cutoff_message_id",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "projection_version",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sanitation_policy_version",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "requested_directory",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "isolation_mode",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "requested_target_session_id",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_session_id",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_depth",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "task_request_hash",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree_directory",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree_branch",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree_base_commit",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "recovery_reason",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session_fork_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "intent_id",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "fork_mode",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_session_id",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_window_id",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_effective_history_hash",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_message_count",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_cutoff_message_id",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "projection_version",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "sanitation_policy_version",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_session_id",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_window_id",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_effective_history_hash",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "target_world_state_baseline_hash",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cloned_message_count",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "cloned_part_count",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "event_cursor",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_count",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery_owner",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "delivery_attempts",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "recovery_reason",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_committed",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_completed",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "side_effects_completed_at",
+      "entityType": "columns",
+      "table": "session_fork_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_history_state"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_history_state"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "session_history_state"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_history_state"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session_history_state"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prompt",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admitted_seq",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "promoted_seq",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_input"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "intent_id",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "selected_variant",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "selected_payload_hash",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admitted_message_id",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "correlation_id",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_token",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'legacy'",
+      "generated": null,
+      "name": "execution_mode",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'legacy'",
+      "generated": null,
+      "name": "execution_state",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "execution_claim_id",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "execution_claimed_at",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "mutation_epoch",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_selected",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_admitted",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session_intent"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "session_message"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "part_id",
+      "entityType": "columns",
+      "table": "session_part_integrity_quarantine"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_id",
+      "entityType": "columns",
+      "table": "session_part_integrity_quarantine"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "part_session_id",
+      "entityType": "columns",
+      "table": "session_part_integrity_quarantine"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_session_id",
+      "entityType": "columns",
+      "table": "session_part_integrity_quarantine"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "session_part_integrity_quarantine"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "quarantined_at",
+      "entityType": "columns",
+      "table": "session_part_integrity_quarantine"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prompt_epoch",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "ordinal",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_id",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prompt_epoch",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "resolution_id",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "successor_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "ambiguity_message_id",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "physical_message_high_water",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": true,
+      "default": null,
+      "generated": null,
+      "name": "seq",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "correlation_id",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prompt",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "mutation_epoch",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "consumed_seq",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "superseded_at",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "materialized_at",
+      "entityType": "columns",
+      "table": "session_steer"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_id",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_id",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "slug",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "directory",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "path",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "title",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "share_url",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "summary_additions",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "summary_deletions",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "summary_files",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "summary_diffs",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "summary_diff_manifest",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "metadata",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "real",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "cost",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "tokens_input",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "tokens_output",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "tokens_reasoning",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "tokens_cache_read",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "tokens_cache_write",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "mutation_epoch",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "revert",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "permission",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "agent",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "model",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_compacting",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_archived",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_suspended",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "preview",
+      "entityType": "columns",
+      "table": "session"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "command_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_resolution_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "resolution_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "receipt_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "legacy_activity_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "assistant_message_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_window_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_effective_history_hash",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_request_hash",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expected_provider_state",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "decision",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "actor_type",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "actor_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "risk_acknowledged",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "safe_end_message_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "safe_history_hash",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "safe_message_ids",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "ambiguity_message_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "physical_message_high_water",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "successor_prompt_epoch",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "successor_window_id",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "successor_history_hash",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "successor_mutation_epoch",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "prompt_epoch",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "section_id",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "snapshot",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "fragment",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "fragment_hash",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "provenance",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "admission_key",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_session_id",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_message_id",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_call_id",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery_mode",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "task_admission"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_session_id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "directory",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "status",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "attempts",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "available_at",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_owner",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "last_error",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_delivered",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'terminal'",
+      "generated": null,
+      "name": "event_kind",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "correlation_id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload_hash",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_input_message_id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "response_message_id",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "response_started_at",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_admitted",
+      "entityType": "columns",
+      "table": "task_notification_outbox"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "event_id",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "from_state",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "to_state",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "data",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "task_run_event"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "root_run_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_hash",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_session_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_message_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "tool_call_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_session_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "generation",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery_mode",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "phase",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "reason",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "attempts",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "execution_owner",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "lease_expires_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "raw_result_message_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "structured_result_message_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "structured_output_receipt",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "output",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "error",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_settled",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "parent_run_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "continuation_of_run_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "1",
+      "generated": null,
+      "name": "depth",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'task_tool'",
+      "generated": null,
+      "name": "origin_kind",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "origin_key",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'foreground'",
+      "generated": null,
+      "name": "effective_delivery_mode",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "promoted_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'new'",
+      "generated": null,
+      "name": "session_mode",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'fresh'",
+      "generated": null,
+      "name": "context_mode",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "context_cutoff_message_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'write'",
+      "generated": null,
+      "name": "mutation_capability",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'legacy-unknown'",
+      "generated": null,
+      "name": "tool_capability_hash",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'shared'",
+      "generated": null,
+      "name": "workspace_mode",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'parent'",
+      "generated": null,
+      "name": "workspace_owner",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'live'",
+      "generated": null,
+      "name": "workspace_visibility",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'allow_live'",
+      "generated": null,
+      "name": "parent_dirty_policy",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_operation_key",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_revision",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "execution_spec",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "version",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'open'",
+      "generated": null,
+      "name": "control_state",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'legacy'",
+      "generated": null,
+      "name": "input_state",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_message_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "input_admission_started_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_input_materialized_hash",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_input_part_count",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "execution_started_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "finalizer_started_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "interrupt_requested_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "interrupt_reason",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "close_requested_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "close_reason",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "claim_generation",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "start_attempts",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "available_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "priority",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "queue_reason",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'legacy'",
+      "generated": null,
+      "name": "workspace_preflight_state",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_preflight_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_repository_root",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_base_commit",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_parent_branch",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_target_branch",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_status_hash",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_preflight_error_code",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'none'",
+      "generated": null,
+      "name": "workspace_branch_state",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "workspace_branch_started_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree_directory",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree_branch",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "'none'",
+      "generated": null,
+      "name": "worktree_state",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "worktree_started_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "pr_operation_key",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "pr_started_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "pr_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "goal_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "goal_tick_seq",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "goal_role",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "goal_ordinal",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_hash",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "usage",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "0",
+      "generated": null,
+      "name": "progress_seq",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "last_progress_at",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "finalizer_input_message_id",
+      "entityType": "columns",
+      "table": "task_run"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "attempt",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_session_id",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_token",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "claim_generation",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expected_version",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "source_message_id",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "request_message_id",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "response_message_id",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "response_message_json",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "role",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "ordinal",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "part_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "message_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "part_json",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "run_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "child_session_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "owner_token",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "claim_generation",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "expected_version",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "terminal_state",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "attempts",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "contract_json",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "raw_result_message_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "raw_message_json",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "raw_parts_json",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_message_id",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_message_json",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "result_parts_json",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "output",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "structured_output_receipt",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "failure_code",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "content",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "status",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "priority",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "position",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "todo"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_share"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "session_share"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "secret",
+      "entityType": "columns",
+      "table": "session_share"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "url",
+      "entityType": "columns",
+      "table": "session_share"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_share"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_updated",
+      "entityType": "columns",
+      "table": "session_share"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_workspace_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "workspace"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_activity_objective_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_activity_objective"
+    },
+    {
+      "columns": [
+        "request_id"
+      ],
+      "tableTo": "session_activity_permission_request",
+      "columnsTo": [
+        "request_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_activity_permission_effect_dispatch_request_id_session_activity_permission_request_request_id_fk",
+      "entityType": "fks",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_activity_permission_effect_dispatch_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_activity_permission_effect_dispatch_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_activity_permission_request_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_activity_permission_request_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "columns": [
+        "parent_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_facade_activity_parent_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_facade_activity"
+    },
+    {
+      "columns": [
+        "owner_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_facade_activity_owner_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_facade_activity"
+    },
+    {
+      "columns": [
+        "job_id"
+      ],
+      "tableTo": "learning_job",
+      "columnsTo": [
+        "job_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_admission_outbox_job_id_learning_job_job_id_fk",
+      "entityType": "fks",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "columns": [
+        "plan_id"
+      ],
+      "tableTo": "learning_governance_plan",
+      "columnsTo": [
+        "plan_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_governance_action_plan_id_learning_governance_plan_plan_id_fk",
+      "entityType": "fks",
+      "table": "learning_governance_action"
+    },
+    {
+      "columns": [
+        "plan_id"
+      ],
+      "tableTo": "learning_governance_plan",
+      "columnsTo": [
+        "plan_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_governance_compensation_plan_id_learning_governance_plan_plan_id_fk",
+      "entityType": "fks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "columns": [
+        "action_id"
+      ],
+      "tableTo": "learning_governance_action",
+      "columnsTo": [
+        "action_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_governance_compensation_action_id_learning_governance_action_action_id_fk",
+      "entityType": "fks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "columns": [
+        "job_id"
+      ],
+      "tableTo": "learning_job",
+      "columnsTo": [
+        "job_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_governance_plan_job_id_learning_job_job_id_fk",
+      "entityType": "fks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_job_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "learning_job"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_job_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "learning_job"
+    },
+    {
+      "columns": [
+        "job_id"
+      ],
+      "tableTo": "learning_job",
+      "columnsTo": [
+        "job_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_learning_reviewer_attempt_job_id_learning_job_job_id_fk",
+      "entityType": "fks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_evaluation_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "tableTo": "context_project_scope_identity",
+      "columnsTo": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_evaluation_security_namespace_id_project_scope_key_context_project_scope_identity_security_namespace_id_project_scope_key_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "columns": [
+        "snapshot_id"
+      ],
+      "tableTo": "released_knowledge_snapshot",
+      "columnsTo": [
+        "snapshot_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_document_snapshot_id_released_knowledge_snapshot_snapshot_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_head_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "tableTo": "context_project_scope_identity",
+      "columnsTo": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_head_security_namespace_id_project_scope_key_context_project_scope_identity_security_namespace_id_project_scope_key_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key",
+        "snapshot_id"
+      ],
+      "tableTo": "released_knowledge_snapshot",
+      "columnsTo": [
+        "security_namespace_id",
+        "project_scope_key",
+        "snapshot_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_head_security_namespace_id_project_scope_key_snapshot_id_released_knowledge_snapshot_security_namespace_id_project_scope_key_snapshot_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "tableTo": "context_project_scope_identity",
+      "columnsTo": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_security_namespace_id_project_scope_key_context_project_scope_identity_security_namespace_id_project_scope_key_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key",
+        "parent_snapshot_id"
+      ],
+      "tableTo": "released_knowledge_snapshot",
+      "columnsTo": [
+        "security_namespace_id",
+        "project_scope_key",
+        "snapshot_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_security_namespace_id_project_scope_key_parent_snapshot_id_released_knowledge_snapshot_security_namespace_id_project_scope_key_snapshot_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key",
+        "evaluation_id"
+      ],
+      "tableTo": "released_knowledge_evaluation",
+      "columnsTo": [
+        "security_namespace_id",
+        "project_scope_key",
+        "evaluation_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_released_knowledge_snapshot_security_namespace_id_project_scope_key_evaluation_id_released_knowledge_evaluation_security_namespace_id_project_scope_key_evaluation_id_fk",
+      "entityType": "fks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_file_part_artifact_binding_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "tableTo": "file_part_artifact",
+      "columnsTo": [
+        "artifact_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "RESTRICT",
+      "nameExplicit": false,
+      "name": "fk_file_part_artifact_binding_artifact_id_file_part_artifact_artifact_id_fk",
+      "entityType": "fks",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "tableTo": "file_part_artifact",
+      "columnsTo": [
+        "artifact_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_file_part_artifact_chunk_artifact_id_file_part_artifact_artifact_id_fk",
+      "entityType": "fks",
+      "table": "file_part_artifact_chunk"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "tableTo": "file_part_artifact",
+      "columnsTo": [
+        "artifact_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_file_part_artifact_discard_artifact_id_file_part_artifact_artifact_id_fk",
+      "entityType": "fks",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "tableTo": "file_part_artifact",
+      "columnsTo": [
+        "artifact_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_file_part_artifact_import_artifact_id_file_part_artifact_artifact_id_fk",
+      "entityType": "fks",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "columns": [
+        "core_v2_receipt_id"
+      ],
+      "tableTo": "session_v2_provider_turn_receipt",
+      "columnsTo": [
+        "receipt_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_session_v2_provider_parity_receipt_core_v2_receipt_id_session_v2_provider_turn_receipt_receipt_id_fk",
+      "entityType": "fks",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_v2_provider_turn_receipt_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "columns": [
+        "owner_token"
+      ],
+      "tableTo": "session_provider_owner_lease",
+      "columnsTo": [
+        "owner_token"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_session_v2_provider_turn_receipt_owner_token_session_provider_owner_lease_owner_token_fk",
+      "entityType": "fks",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_transfer_operation_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_transfer_operation"
+    },
+    {
+      "columns": [
+        "active_account_id"
+      ],
+      "tableTo": "account",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "SET NULL",
+      "nameExplicit": false,
+      "name": "fk_account_state_active_account_id_account_id_fk",
+      "entityType": "fks",
+      "table": "account_state"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_context_location_identity_alias_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_context_location_identity_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "context_location_identity"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_context_project_scope_identity_alias_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "columns": [
+        "security_namespace_id"
+      ],
+      "tableTo": "context_security_namespace",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "fk_context_project_scope_identity_security_namespace_id_context_security_namespace_id_fk",
+      "entityType": "fks",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "tableTo": "event_artifact",
+      "columnsTo": [
+        "artifact_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_artifact_chunk_artifact_id_event_artifact_artifact_id_fk",
+      "entityType": "fks",
+      "table": "event_artifact_chunk"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_artifact_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "event_artifact"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_compaction_receipt_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "event_compaction_receipt"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_dedupe_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "event_dedupe"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_snapshot_attempt_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_snapshot_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "event_snapshot"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "tableTo": "event_sequence",
+      "columnsTo": [
+        "aggregate_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_event_aggregate_id_event_sequence_aggregate_id_fk",
+      "entityType": "fks",
+      "table": "event"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_im_attachments_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "im_attachments"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_im_groups_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "im_groups"
+    },
+    {
+      "columns": [
+        "group_id"
+      ],
+      "tableTo": "im_groups",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_im_members_group_id_im_groups_id_fk",
+      "entityType": "fks",
+      "table": "im_members"
+    },
+    {
+      "columns": [
+        "group_id"
+      ],
+      "tableTo": "im_groups",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_im_messages_group_id_im_groups_id_fk",
+      "entityType": "fks",
+      "table": "im_messages"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_permission_saved_epoch_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "permission_saved_epoch"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_permission_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "permission"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_project_directory_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "project_directory"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_message_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "message"
+    },
+    {
+      "columns": [
+        "message_id"
+      ],
+      "tableTo": "message",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_part_message_id_message_id_fk",
+      "entityType": "fks",
+      "table": "part"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_context_epoch_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_context_epoch"
+    },
+    {
+      "columns": [
+        "source_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_fork_admission_source_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_fork_admission"
+    },
+    {
+      "columns": [
+        "source_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_fork_intent_source_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_fork_intent"
+    },
+    {
+      "columns": [
+        "target_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_fork_intent_target_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_fork_intent"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_history_state_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_history_state"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_input_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_input"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_intent_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_intent"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_message_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_message"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_prompt_epoch_message_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "columns": [
+        "message_id"
+      ],
+      "tableTo": "message",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_prompt_epoch_message_message_id_message_id_fk",
+      "entityType": "fks",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_steer_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_steer"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "tableTo": "project",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_project_id_project_id_fk",
+      "entityType": "fks",
+      "table": "session"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_world_state_baseline_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_admission_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_admission"
+    },
+    {
+      "columns": [
+        "parent_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_admission_parent_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "task_admission"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_notification_outbox_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_notification_outbox"
+    },
+    {
+      "columns": [
+        "parent_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_notification_outbox_parent_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "task_notification_outbox"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_run_event_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_run_event"
+    },
+    {
+      "columns": [
+        "parent_session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_run_parent_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        "parent_run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_run_parent_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        "continuation_of_run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_run_continuation_of_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_structured_finalizer_response_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "tableTo": "task_structured_output_evidence",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_structured_output_evidence_part_run_id_task_structured_output_evidence_run_id_fk",
+      "entityType": "fks",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "tableTo": "task_run",
+      "columnsTo": [
+        "run_id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_task_structured_output_evidence_run_id_task_run_run_id_fk",
+      "entityType": "fks",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_todo_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "todo"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "tableTo": "session",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_share_session_id_session_id_fk",
+      "entityType": "fks",
+      "table": "session_share"
+    },
+    {
+      "columns": [
+        "activity_kind",
+        "activity_id",
+        "receipt_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_effect_receipt_pk",
+      "entityType": "pks",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "columns": [
+        "activity_kind",
+        "activity_id",
+        "evidence_fingerprint"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_evidence_pk",
+      "entityType": "pks",
+      "table": "session_activity_evidence"
+    },
+    {
+      "columns": [
+        "activity_kind",
+        "activity_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_objective_pk",
+      "entityType": "pks",
+      "table": "session_activity_objective"
+    },
+    {
+      "columns": [
+        "activity_kind",
+        "activity_id",
+        "revision"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_progress_observation_pk",
+      "entityType": "pks",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "columns": [
+        "snapshot_id",
+        "source_store",
+        "doc_id"
+      ],
+      "nameExplicit": false,
+      "name": "released_knowledge_snapshot_document_pk",
+      "entityType": "pks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "nameExplicit": false,
+      "name": "released_knowledge_snapshot_head_pk",
+      "entityType": "pks",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "columns": [
+        "artifact_id",
+        "chunk_index"
+      ],
+      "nameExplicit": false,
+      "name": "file_part_artifact_chunk_pk",
+      "entityType": "pks",
+      "table": "file_part_artifact_chunk"
+    },
+    {
+      "columns": [
+        "campaign_id",
+        "case_name"
+      ],
+      "nameExplicit": false,
+      "name": "session_v2_provider_parity_baseline_pk",
+      "entityType": "pks",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "columns": [
+        "campaign_id",
+        "case_name"
+      ],
+      "nameExplicit": false,
+      "name": "session_v2_provider_parity_receipt_pk",
+      "entityType": "pks",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "columns": [
+        "email",
+        "url"
+      ],
+      "nameExplicit": false,
+      "name": "control_account_pk",
+      "entityType": "pks",
+      "table": "control_account"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "old_canonical_root"
+      ],
+      "nameExplicit": false,
+      "name": "context_location_identity_alias_pk",
+      "entityType": "pks",
+      "table": "context_location_identity_alias"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "location_key"
+      ],
+      "nameExplicit": false,
+      "name": "context_location_identity_pk",
+      "entityType": "pks",
+      "table": "context_location_identity"
+    },
+    {
+      "columns": [
+        "index_space_id",
+        "projection_kind"
+      ],
+      "nameExplicit": false,
+      "name": "location_index_coordination_pk",
+      "entityType": "pks",
+      "table": "location_index_coordination"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "old_project_identity_hash"
+      ],
+      "nameExplicit": false,
+      "name": "context_project_scope_identity_alias_pk",
+      "entityType": "pks",
+      "table": "context_project_scope_identity_alias"
+    },
+    {
+      "columns": [
+        "security_namespace_id",
+        "project_scope_key"
+      ],
+      "nameExplicit": false,
+      "name": "context_project_scope_identity_pk",
+      "entityType": "pks",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "columns": [
+        "artifact_id",
+        "chunk_index"
+      ],
+      "nameExplicit": false,
+      "name": "event_artifact_chunk_pk",
+      "entityType": "pks",
+      "table": "event_artifact_chunk"
+    },
+    {
+      "columns": [
+        "row_hash",
+        "chunk_index"
+      ],
+      "nameExplicit": false,
+      "name": "event_snapshot_chunk_pk",
+      "entityType": "pks",
+      "table": "event_snapshot_chunk"
+    },
+    {
+      "columns": [
+        "snapshot_id",
+        "row_index"
+      ],
+      "nameExplicit": false,
+      "name": "event_snapshot_row_pk",
+      "entityType": "pks",
+      "table": "event_snapshot_row"
+    },
+    {
+      "columns": [
+        "workspace_id",
+        "remote_fingerprint"
+      ],
+      "nameExplicit": false,
+      "name": "workspace_sync_cursor_pk",
+      "entityType": "pks",
+      "table": "workspace_sync_cursor"
+    },
+    {
+      "columns": [
+        "index_space_id",
+        "projection_kind",
+        "path"
+      ],
+      "nameExplicit": false,
+      "name": "location_projection_dirty_path_pk",
+      "entityType": "pks",
+      "table": "location_projection_dirty_path"
+    },
+    {
+      "columns": [
+        "index_space_id",
+        "projection_kind"
+      ],
+      "nameExplicit": false,
+      "name": "location_projection_registration_pk",
+      "entityType": "pks",
+      "table": "location_projection_registration"
+    },
+    {
+      "columns": [
+        "project_id",
+        "directory"
+      ],
+      "nameExplicit": false,
+      "name": "project_directory_pk",
+      "entityType": "pks",
+      "table": "project_directory"
+    },
+    {
+      "columns": [
+        "session_id",
+        "prompt_epoch",
+        "ordinal"
+      ],
+      "nameExplicit": false,
+      "name": "session_prompt_epoch_message_pk",
+      "entityType": "pks",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "columns": [
+        "session_id",
+        "prompt_epoch"
+      ],
+      "nameExplicit": false,
+      "name": "session_prompt_epoch_recovery_pk",
+      "entityType": "pks",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "columns": [
+        "session_id",
+        "prompt_epoch",
+        "section_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_world_state_baseline_pk",
+      "entityType": "pks",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "columns": [
+        "run_id",
+        "attempt"
+      ],
+      "nameExplicit": false,
+      "name": "task_structured_finalizer_response_pk",
+      "entityType": "pks",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "columns": [
+        "run_id",
+        "role",
+        "part_id"
+      ],
+      "nameExplicit": false,
+      "name": "task_structured_output_evidence_part_pk",
+      "entityType": "pks",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "columns": [
+        "session_id",
+        "position"
+      ],
+      "nameExplicit": false,
+      "name": "todo_pk",
+      "entityType": "pks",
+      "table": "todo"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "workspace_pk",
+      "table": "workspace",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "name"
+      ],
+      "nameExplicit": false,
+      "name": "data_migration_pk",
+      "table": "data_migration",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "decision_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_permission_decision_pk",
+      "table": "session_activity_permission_decision",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "receipt_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_permission_effect_dispatch_pk",
+      "table": "session_activity_permission_effect_dispatch",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "request_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_permission_once_consumption_pk",
+      "table": "session_activity_permission_once_consumption",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "owner_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_permission_owner_lease_pk",
+      "table": "session_activity_permission_owner_lease",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "request_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_activity_permission_request_pk",
+      "table": "session_activity_permission_request",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "activity_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_facade_activity_pk",
+      "table": "session_facade_activity",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "intent_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_admission_outbox_pk",
+      "table": "learning_admission_outbox",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "action_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_governance_action_pk",
+      "table": "learning_governance_action",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "compensation_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_governance_compensation_pk",
+      "table": "learning_governance_compensation",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "plan_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_governance_plan_pk",
+      "table": "learning_governance_plan",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "job_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_job_pk",
+      "table": "learning_job",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "receipt_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_lifecycle_trigger_receipt_pk",
+      "table": "learning_lifecycle_trigger_receipt",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "attempt_id"
+      ],
+      "nameExplicit": false,
+      "name": "learning_reviewer_attempt_pk",
+      "table": "learning_reviewer_attempt",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "evaluation_id"
+      ],
+      "nameExplicit": false,
+      "name": "released_knowledge_evaluation_pk",
+      "table": "released_knowledge_evaluation",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "snapshot_id"
+      ],
+      "nameExplicit": false,
+      "name": "released_knowledge_snapshot_pk",
+      "table": "released_knowledge_snapshot",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "event_id"
+      ],
+      "nameExplicit": false,
+      "name": "file_part_artifact_binding_pk",
+      "table": "file_part_artifact_binding",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "event_id"
+      ],
+      "nameExplicit": false,
+      "name": "file_part_artifact_discard_pk",
+      "table": "file_part_artifact_discard",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "event_id"
+      ],
+      "nameExplicit": false,
+      "name": "file_part_artifact_import_pk",
+      "table": "file_part_artifact_import",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "nameExplicit": false,
+      "name": "file_part_artifact_pk",
+      "table": "file_part_artifact",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "receipt_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_v2_provider_turn_receipt_pk",
+      "table": "session_v2_provider_turn_receipt",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "transfer_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_transfer_operation_pk",
+      "table": "session_transfer_operation",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "transfer_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_transfer_target_receipt_pk",
+      "table": "session_transfer_target_receipt",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "account_state_pk",
+      "table": "account_state",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "account_pk",
+      "table": "account",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "context_security_namespace_pk",
+      "table": "context_security_namespace",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "artifact_id"
+      ],
+      "nameExplicit": false,
+      "name": "event_artifact_pk",
+      "table": "event_artifact",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "nameExplicit": false,
+      "name": "event_compaction_receipt_pk",
+      "table": "event_compaction_receipt",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "aggregate_id"
+      ],
+      "nameExplicit": false,
+      "name": "event_sequence_pk",
+      "table": "event_sequence",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "snapshot_id"
+      ],
+      "nameExplicit": false,
+      "name": "event_snapshot_attempt_pk",
+      "table": "event_snapshot_attempt",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "snapshot_id"
+      ],
+      "nameExplicit": false,
+      "name": "event_snapshot_pk",
+      "table": "event_snapshot",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "event_sync_backfill_pk",
+      "table": "event_sync_backfill",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "sync_seq"
+      ],
+      "nameExplicit": false,
+      "name": "event_sync_index_pk",
+      "table": "event_sync_index",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "event_sync_sequence_pk",
+      "table": "event_sync_sequence",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "event_pk",
+      "table": "event",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "im_attachments_pk",
+      "table": "im_attachments",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "im_groups_pk",
+      "table": "im_groups",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "im_messages_pk",
+      "table": "im_messages",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "event_seq"
+      ],
+      "nameExplicit": false,
+      "name": "location_change_event_pk",
+      "table": "location_change_event",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "project_id"
+      ],
+      "nameExplicit": false,
+      "name": "permission_saved_epoch_pk",
+      "table": "permission_saved_epoch",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "permission_pk",
+      "table": "permission",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "project_pk",
+      "table": "project",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "message_pk",
+      "table": "message",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "part_pk",
+      "table": "part",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_context_epoch_pk",
+      "table": "session_context_epoch",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "intent_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_fork_admission_pk",
+      "table": "session_fork_admission",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "intent_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_fork_intent_pk",
+      "table": "session_fork_intent",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_history_state_pk",
+      "table": "session_history_state",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "session_input_pk",
+      "table": "session_input",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "intent_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_intent_pk",
+      "table": "session_intent",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "session_message_pk",
+      "table": "session_message",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "part_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_part_integrity_quarantine_pk",
+      "table": "session_part_integrity_quarantine",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "seq"
+      ],
+      "nameExplicit": false,
+      "name": "session_steer_pk",
+      "table": "session_steer",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "session_pk",
+      "table": "session",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "command_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_tool_request_resolution_command_pk",
+      "table": "session_tool_request_resolution_command",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "resolution_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_tool_request_resolution_pk",
+      "table": "session_tool_request_resolution",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "admission_key"
+      ],
+      "nameExplicit": false,
+      "name": "task_admission_pk",
+      "table": "task_admission",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "task_notification_outbox_pk",
+      "table": "task_notification_outbox",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "event_id"
+      ],
+      "nameExplicit": false,
+      "name": "task_run_event_pk",
+      "table": "task_run_event",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "nameExplicit": false,
+      "name": "task_run_pk",
+      "table": "task_run",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "nameExplicit": false,
+      "name": "task_structured_output_evidence_pk",
+      "table": "task_structured_output_evidence",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "session_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_share_pk",
+      "table": "session_share",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        {
+          "value": "activity_kind",
+          "isExpression": false
+        },
+        {
+          "value": "activity_id",
+          "isExpression": false
+        },
+        {
+          "value": "first_observation_revision",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_effect_receipt_activity_idx",
+      "entityType": "indexes",
+      "table": "session_activity_effect_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "activity_kind",
+          "isExpression": false
+        },
+        {
+          "value": "activity_id",
+          "isExpression": false
+        },
+        {
+          "value": "first_observation_revision",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_evidence_activity_idx",
+      "entityType": "indexes",
+      "table": "session_activity_evidence"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "updated_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_objective_session_idx",
+      "entityType": "indexes",
+      "table": "session_activity_objective"
+    },
+    {
+      "columns": [
+        {
+          "value": "request_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_decision_request_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "columns": [
+        {
+          "value": "idempotency_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_decision_idempotency_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_decision"
+    },
+    {
+      "columns": [
+        {
+          "value": "request_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_effect_dispatch_request_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        {
+          "value": "idempotency_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_effect_dispatch_idempotency_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        {
+          "value": "activity_kind",
+          "isExpression": false
+        },
+        {
+          "value": "activity_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "started_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_effect_dispatch_activity_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        {
+          "value": "owner_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "started_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_effect_dispatch_owner_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_effect_dispatch"
+    },
+    {
+      "columns": [
+        {
+          "value": "idempotency_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_once_consumption_idempotency_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_once_consumption"
+    },
+    {
+      "columns": [
+        {
+          "value": "lease_expires_at",
+          "isExpression": false
+        },
+        {
+          "value": "owner_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_owner_lease_expiry_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_owner_lease"
+    },
+    {
+      "columns": [
+        {
+          "value": "idempotency_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_request_idempotency_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "columns": [
+        {
+          "value": "activity_kind",
+          "isExpression": false
+        },
+        {
+          "value": "activity_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": "\"session_activity_permission_request\".\"state\" = 'pending' AND \"session_activity_permission_request\".\"request_kind\" = 'no_progress'",
+      "origin": "manual",
+      "name": "session_activity_permission_request_pending_no_progress_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_permission_request_pending_idx",
+      "entityType": "indexes",
+      "table": "session_activity_permission_request"
+    },
+    {
+      "columns": [
+        {
+          "value": "idempotency_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_progress_observation_idempotency_idx",
+      "entityType": "indexes",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "columns": [
+        {
+          "value": "activity_kind",
+          "isExpression": false
+        },
+        {
+          "value": "activity_id",
+          "isExpression": false
+        },
+        {
+          "value": "observed_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_activity_progress_observation_latest_idx",
+      "entityType": "indexes",
+      "table": "session_activity_progress_observation"
+    },
+    {
+      "columns": [
+        {
+          "value": "parent_session_id",
+          "isExpression": false
+        },
+        {
+          "value": "subkind",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": "\"session_facade_activity\".\"state\" = 'active'",
+      "origin": "manual",
+      "name": "session_facade_activity_active_idx",
+      "entityType": "indexes",
+      "table": "session_facade_activity"
+    },
+    {
+      "columns": [
+        {
+          "value": "parent_session_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_facade_activity_parent_idx",
+      "entityType": "indexes",
+      "table": "session_facade_activity"
+    },
+    {
+      "columns": [
+        {
+          "value": "dedupe_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_admission_outbox_dedupe_idx",
+      "entityType": "indexes",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "columns": [
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": "\"learning_admission_outbox\".\"state\" = 'pending'",
+      "origin": "manual",
+      "name": "learning_admission_outbox_pending_idx",
+      "entityType": "indexes",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "columns": [
+        {
+          "value": "plan_id",
+          "isExpression": false
+        },
+        {
+          "value": "sequence",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_action_plan_sequence_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_action"
+    },
+    {
+      "columns": [
+        {
+          "value": "plan_id",
+          "isExpression": false
+        },
+        {
+          "value": "candidate_id",
+          "isExpression": false
+        },
+        {
+          "value": "kind",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_action_plan_candidate_kind_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_action"
+    },
+    {
+      "columns": [
+        {
+          "value": "plan_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "sequence",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_action_claim_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_action"
+    },
+    {
+      "columns": [
+        {
+          "value": "action_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_compensation_action_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "columns": [
+        {
+          "value": "plan_id",
+          "isExpression": false
+        },
+        {
+          "value": "sequence",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_compensation_plan_sequence_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_compensation_claim_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "columns": [
+        {
+          "value": "job_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_plan_job_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_plan"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_governance_plan_state_idx",
+      "entityType": "indexes",
+      "table": "learning_governance_plan"
+    },
+    {
+      "columns": [
+        {
+          "value": "dedupe_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_job_dedupe_idx",
+      "entityType": "indexes",
+      "table": "learning_job"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "next_attempt_at",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_job_due_idx",
+      "entityType": "indexes",
+      "table": "learning_job"
+    },
+    {
+      "columns": [
+        {
+          "value": "project_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_job_project_created_idx",
+      "entityType": "indexes",
+      "table": "learning_job"
+    },
+    {
+      "columns": [
+        {
+          "value": "owner",
+          "isExpression": false
+        },
+        {
+          "value": "lease_expires_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": "\"learning_job\".\"owner\" IS NOT NULL",
+      "origin": "manual",
+      "name": "learning_job_owner_lease_idx",
+      "entityType": "indexes",
+      "table": "learning_job"
+    },
+    {
+      "columns": [
+        {
+          "value": "trigger",
+          "isExpression": false
+        },
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "run_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_lifecycle_trigger_identity_idx",
+      "entityType": "indexes",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "created_at",
+          "isExpression": false
+        },
+        {
+          "value": "receipt_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": "\"learning_lifecycle_trigger_receipt\".\"state\" = 'prepared'",
+      "origin": "manual",
+      "name": "learning_lifecycle_trigger_pending_idx",
+      "entityType": "indexes",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "job_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_reviewer_attempt_job_idx",
+      "entityType": "indexes",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "columns": [
+        {
+          "value": "review_session_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_reviewer_attempt_session_idx",
+      "entityType": "indexes",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "updated_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "learning_reviewer_attempt_state_idx",
+      "entityType": "indexes",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "columns": [
+        {
+          "value": "security_namespace_id",
+          "isExpression": false
+        },
+        {
+          "value": "project_scope_key",
+          "isExpression": false
+        },
+        {
+          "value": "evaluation_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "released_knowledge_evaluation_scope_identity_idx",
+      "entityType": "indexes",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "columns": [
+        {
+          "value": "security_namespace_id",
+          "isExpression": false
+        },
+        {
+          "value": "project_scope_key",
+          "isExpression": false
+        },
+        {
+          "value": "matrix_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "released_knowledge_evaluation_matrix_idx",
+      "entityType": "indexes",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "columns": [
+        {
+          "value": "snapshot_id",
+          "isExpression": false
+        },
+        {
+          "value": "ordinal",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "released_knowledge_snapshot_document_ordinal_idx",
+      "entityType": "indexes",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "columns": [
+        {
+          "value": "security_namespace_id",
+          "isExpression": false
+        },
+        {
+          "value": "project_scope_key",
+          "isExpression": false
+        },
+        {
+          "value": "snapshot_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "released_knowledge_snapshot_scope_identity_idx",
+      "entityType": "indexes",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "columns": [
+        {
+          "value": "parent_snapshot_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "released_knowledge_snapshot_parent_idx",
+      "entityType": "indexes",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "file_part_artifact_binding_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "part_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "file_part_artifact_binding_part_idx",
+      "entityType": "indexes",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "columns": [
+        {
+          "value": "artifact_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "file_part_artifact_binding_artifact_idx",
+      "entityType": "indexes",
+      "table": "file_part_artifact_binding"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "file_part_artifact_discard_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "file_part_artifact_discard"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "file_part_artifact_import_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "columns": [
+        {
+          "value": "artifact_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "file_part_artifact_import_artifact_idx",
+      "entityType": "indexes",
+      "table": "file_part_artifact_import"
+    },
+    {
+      "columns": [
+        {
+          "value": "receipt_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_parity_baseline_hash_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "columns": [
+        {
+          "value": "campaign_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_parity_baseline_campaign_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "columns": [
+        {
+          "value": "receipt_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_parity_receipt_hash_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "campaign_id",
+          "isExpression": false
+        },
+        {
+          "value": "verified",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_parity_receipt_campaign_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_parity_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "request_ordinal",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_turn_receipt_ordinal_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "user_message_id",
+          "isExpression": false
+        },
+        {
+          "value": "history_prompt_epoch",
+          "isExpression": false
+        },
+        {
+          "value": "request_input_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_turn_receipt_input_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "owner_token",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_v2_provider_turn_receipt_owner_state_idx",
+      "entityType": "indexes",
+      "table": "session_v2_provider_turn_receipt"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "request_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_transfer_operation_session_request_idx",
+      "entityType": "indexes",
+      "table": "session_transfer_operation"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": "\"session_transfer_operation\".\"state\" NOT IN ('target_activated', 'aborted')",
+      "origin": "manual",
+      "name": "session_transfer_operation_active_idx",
+      "entityType": "indexes",
+      "table": "session_transfer_operation"
+    },
+    {
+      "columns": [
+        {
+          "value": "security_namespace_id",
+          "isExpression": false
+        },
+        {
+          "value": "canonical_root",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "context_location_identity_root_idx",
+      "entityType": "indexes",
+      "table": "context_location_identity"
+    },
+    {
+      "columns": [
+        {
+          "value": "security_namespace_id",
+          "isExpression": false
+        },
+        {
+          "value": "location_key",
+          "isExpression": false
+        },
+        {
+          "value": "projection_kind",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "location_index_coordination_location_idx",
+      "entityType": "indexes",
+      "table": "location_index_coordination"
+    },
+    {
+      "columns": [
+        {
+          "value": "security_namespace_id",
+          "isExpression": false
+        },
+        {
+          "value": "project_identity_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "context_project_scope_identity_value_idx",
+      "entityType": "indexes",
+      "table": "context_project_scope_identity"
+    },
+    {
+      "columns": [
+        {
+          "value": "kind",
+          "isExpression": false
+        },
+        {
+          "value": "binding_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "context_security_namespace_binding_idx",
+      "entityType": "indexes",
+      "table": "context_security_namespace"
+    },
+    {
+      "columns": [
+        {
+          "value": "event_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_artifact_event_idx",
+      "entityType": "indexes",
+      "table": "event_artifact"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_artifact_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "event_artifact"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_dedupe_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "event_dedupe"
+    },
+    {
+      "columns": [
+        {
+          "value": "event_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_dedupe_event_idx",
+      "entityType": "indexes",
+      "table": "event_dedupe"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_attempt_aggregate_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot_attempt"
+    },
+    {
+      "columns": [
+        {
+          "value": "snapshot_id",
+          "isExpression": false
+        },
+        {
+          "value": "table_name",
+          "isExpression": false
+        },
+        {
+          "value": "row_key",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_row_identity_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot_row"
+    },
+    {
+      "columns": [
+        {
+          "value": "row_hash",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_row_hash_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot_row"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_row_aggregate_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot_row"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "through_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_aggregate_created_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot"
+    },
+    {
+      "columns": [
+        {
+          "value": "sync_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_snapshot_sync_seq_idx",
+      "entityType": "indexes",
+      "table": "event_snapshot"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_sync_index_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "event_sync_index"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "event_aggregate_seq_idx",
+      "entityType": "indexes",
+      "table": "event"
+    },
+    {
+      "columns": [
+        {
+          "value": "aggregate_id",
+          "isExpression": false
+        },
+        {
+          "value": "type",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "event_aggregate_type_seq_idx",
+      "entityType": "indexes",
+      "table": "event"
+    },
+    {
+      "columns": [
+        {
+          "value": "workspace_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_attachments_workspace",
+      "entityType": "indexes",
+      "table": "im_attachments"
+    },
+    {
+      "columns": [
+        {
+          "value": "message_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_attachments_message",
+      "entityType": "indexes",
+      "table": "im_attachments"
+    },
+    {
+      "columns": [
+        {
+          "value": "group_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_attachments_group",
+      "entityType": "indexes",
+      "table": "im_attachments"
+    },
+    {
+      "columns": [
+        {
+          "value": "workspace_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "im_groups_workspace_idx",
+      "entityType": "indexes",
+      "table": "im_groups"
+    },
+    {
+      "columns": [
+        {
+          "value": "project_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "im_groups_project_idx",
+      "entityType": "indexes",
+      "table": "im_groups"
+    },
+    {
+      "columns": [
+        {
+          "value": "group_id",
+          "isExpression": false
+        },
+        {
+          "value": "member_id",
+          "isExpression": false
+        },
+        {
+          "value": "member_type",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "im_members_unique_idx",
+      "entityType": "indexes",
+      "table": "im_members"
+    },
+    {
+      "columns": [
+        {
+          "value": "member_id",
+          "isExpression": false
+        },
+        {
+          "value": "group_id",
+          "isExpression": false
+        },
+        {
+          "value": "last_read_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_members_unread",
+      "entityType": "indexes",
+      "table": "im_members"
+    },
+    {
+      "columns": [
+        {
+          "value": "group_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        },
+        {
+          "value": "id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_messages_active",
+      "entityType": "indexes",
+      "table": "im_messages"
+    },
+    {
+      "columns": [
+        {
+          "value": "group_id",
+          "isExpression": false
+        },
+        {
+          "value": "reply_to_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_messages_thread",
+      "entityType": "indexes",
+      "table": "im_messages"
+    },
+    {
+      "columns": [
+        {
+          "value": "event_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "idx_im_messages_event",
+      "entityType": "indexes",
+      "table": "im_messages"
+    },
+    {
+      "columns": [
+        {
+          "value": "index_space_id",
+          "isExpression": false
+        },
+        {
+          "value": "event_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "location_change_event_space_seq_idx",
+      "entityType": "indexes",
+      "table": "location_change_event"
+    },
+    {
+      "columns": [
+        {
+          "value": "project_id",
+          "isExpression": false
+        },
+        {
+          "value": "action",
+          "isExpression": false
+        },
+        {
+          "value": "resource",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "permission_project_action_resource_idx",
+      "entityType": "indexes",
+      "table": "permission"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "time_created",
+          "isExpression": false
+        },
+        {
+          "value": "id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "message_session_time_created_id_idx",
+      "entityType": "indexes",
+      "table": "message"
+    },
+    {
+      "columns": [
+        {
+          "value": "message_id",
+          "isExpression": false
+        },
+        {
+          "value": "id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "part_message_id_id_idx",
+      "entityType": "indexes",
+      "table": "part"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "part_session_idx",
+      "entityType": "indexes",
+      "table": "part"
+    },
+    {
+      "columns": [
+        {
+          "value": "source_session_id",
+          "isExpression": false
+        },
+        {
+          "value": "time_created",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_fork_admission_source_idx",
+      "entityType": "indexes",
+      "table": "session_fork_admission"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "time_updated",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_fork_admission_recovery_idx",
+      "entityType": "indexes",
+      "table": "session_fork_admission"
+    },
+    {
+      "columns": [
+        {
+          "value": "source_session_id",
+          "isExpression": false
+        },
+        {
+          "value": "time_created",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_fork_intent_source_idx",
+      "entityType": "indexes",
+      "table": "session_fork_intent"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "time_updated",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_fork_intent_delivery_idx",
+      "entityType": "indexes",
+      "table": "session_fork_intent"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "promoted_seq",
+          "isExpression": false
+        },
+        {
+          "value": "delivery",
+          "isExpression": false
+        },
+        {
+          "value": "admitted_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_input_session_pending_delivery_seq_idx",
+      "entityType": "indexes",
+      "table": "session_input"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "admitted_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_input_session_admitted_seq_idx",
+      "entityType": "indexes",
+      "table": "session_input"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "promoted_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_input_session_promoted_seq_idx",
+      "entityType": "indexes",
+      "table": "session_input"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "intent_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_intent_session_intent_idx",
+      "entityType": "indexes",
+      "table": "session_intent"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "time_created",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_intent_session_state_idx",
+      "entityType": "indexes",
+      "table": "session_intent"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_message_session_seq_idx",
+      "entityType": "indexes",
+      "table": "session_message"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "type",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_message_session_type_seq_idx",
+      "entityType": "indexes",
+      "table": "session_message"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "time_created",
+          "isExpression": false
+        },
+        {
+          "value": "id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_message_session_time_created_id_idx",
+      "entityType": "indexes",
+      "table": "session_message"
+    },
+    {
+      "columns": [
+        {
+          "value": "time_created",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_message_time_created_idx",
+      "entityType": "indexes",
+      "table": "session_message"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "prompt_epoch",
+          "isExpression": false
+        },
+        {
+          "value": "message_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_prompt_epoch_message_identity_idx",
+      "entityType": "indexes",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "prompt_epoch",
+          "isExpression": false
+        },
+        {
+          "value": "message_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_prompt_epoch_message_lookup_idx",
+      "entityType": "indexes",
+      "table": "session_prompt_epoch_message"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "consumed_seq",
+          "isExpression": false
+        },
+        {
+          "value": "seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_steer_session_pending_seq_idx",
+      "entityType": "indexes",
+      "table": "session_steer"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "correlation_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_steer_session_correlation_idx",
+      "entityType": "indexes",
+      "table": "session_steer"
+    },
+    {
+      "columns": [
+        {
+          "value": "project_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_project_idx",
+      "entityType": "indexes",
+      "table": "session"
+    },
+    {
+      "columns": [
+        {
+          "value": "workspace_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_workspace_idx",
+      "entityType": "indexes",
+      "table": "session"
+    },
+    {
+      "columns": [
+        {
+          "value": "parent_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_parent_idx",
+      "entityType": "indexes",
+      "table": "session"
+    },
+    {
+      "columns": [
+        {
+          "value": "time_suspended",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": "\"session\".\"time_suspended\" is not null",
+      "origin": "manual",
+      "name": "session_time_suspended_idx",
+      "entityType": "indexes",
+      "table": "session"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_tool_request_resolution_command_session_idx",
+      "entityType": "indexes",
+      "table": "session_tool_request_resolution_command"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "created_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_tool_request_resolution_session_idx",
+      "entityType": "indexes",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "prompt_epoch",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_world_state_baseline_epoch_idx",
+      "entityType": "indexes",
+      "table": "session_world_state_baseline"
+    },
+    {
+      "columns": [
+        {
+          "value": "run_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_admission_run_idx",
+      "entityType": "indexes",
+      "table": "task_admission"
+    },
+    {
+      "columns": [
+        {
+          "value": "status",
+          "isExpression": false
+        },
+        {
+          "value": "available_at",
+          "isExpression": false
+        },
+        {
+          "value": "lease_expires_at",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_notification_outbox_due_idx",
+      "entityType": "indexes",
+      "table": "task_notification_outbox"
+    },
+    {
+      "columns": [
+        {
+          "value": "parent_session_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": "\"task_notification_outbox\".\"status\" = 'processing'",
+      "origin": "manual",
+      "name": "task_notification_outbox_parent_processing_idx",
+      "entityType": "indexes",
+      "table": "task_notification_outbox"
+    },
+    {
+      "columns": [
+        {
+          "value": "run_id",
+          "isExpression": false
+        },
+        {
+          "value": "version",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_event_run_version_idx",
+      "entityType": "indexes",
+      "table": "task_run_event"
+    },
+    {
+      "columns": [
+        {
+          "value": "time_created",
+          "isExpression": false
+        },
+        {
+          "value": "event_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_event_time_idx",
+      "entityType": "indexes",
+      "table": "task_run_event"
+    },
+    {
+      "columns": [
+        {
+          "value": "child_session_id",
+          "isExpression": false
+        },
+        {
+          "value": "generation",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_child_generation_idx",
+      "entityType": "indexes",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        {
+          "value": "child_session_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": "\"task_run\".\"state\" IN ('admitted', 'provisioning', 'running', 'researching', 'finalizing')",
+      "origin": "manual",
+      "name": "task_run_child_active_idx",
+      "entityType": "indexes",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        {
+          "value": "parent_session_id",
+          "isExpression": false
+        },
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "time_updated",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_parent_state_idx",
+      "entityType": "indexes",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        {
+          "value": "root_run_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_root_idx",
+      "entityType": "indexes",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        {
+          "value": "state",
+          "isExpression": false
+        },
+        {
+          "value": "available_at",
+          "isExpression": false
+        },
+        {
+          "value": "priority",
+          "isExpression": false
+        },
+        {
+          "value": "time_created",
+          "isExpression": false
+        },
+        {
+          "value": "generation",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_queue_idx",
+      "entityType": "indexes",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        {
+          "value": "goal_id",
+          "isExpression": false
+        },
+        {
+          "value": "goal_tick_seq",
+          "isExpression": false
+        },
+        {
+          "value": "goal_role",
+          "isExpression": false
+        },
+        {
+          "value": "goal_ordinal",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_run_goal_idx",
+      "entityType": "indexes",
+      "table": "task_run"
+    },
+    {
+      "columns": [
+        {
+          "value": "response_message_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "task_structured_finalizer_response_message_idx",
+      "entityType": "indexes",
+      "table": "task_structured_finalizer_response"
+    },
+    {
+      "columns": [
+        {
+          "value": "run_id",
+          "isExpression": false
+        },
+        {
+          "value": "role",
+          "isExpression": false
+        },
+        {
+          "value": "ordinal",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "task_structured_output_evidence_part_ordinal_idx",
+      "entityType": "indexes",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "columns": [
+        {
+          "value": "part_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_structured_output_evidence_part_part_idx",
+      "entityType": "indexes",
+      "table": "task_structured_output_evidence_part"
+    },
+    {
+      "columns": [
+        {
+          "value": "raw_result_message_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_structured_output_evidence_raw_message_idx",
+      "entityType": "indexes",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "columns": [
+        {
+          "value": "result_message_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "task_structured_output_evidence_result_message_idx",
+      "entityType": "indexes",
+      "table": "task_structured_output_evidence"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "todo_session_idx",
+      "entityType": "indexes",
+      "table": "todo"
+    },
+    {
+      "columns": [
+        "body_hash"
+      ],
+      "nameExplicit": false,
+      "name": "file_part_artifact_body_hash_unique",
+      "entityType": "uniques",
+      "table": "file_part_artifact"
+    },
+    {
+      "columns": [
+        "legacy_receipt_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_v2_provider_parity_baseline_legacy_receipt_id_unique",
+      "entityType": "uniques",
+      "table": "session_v2_provider_parity_baseline"
+    },
+    {
+      "columns": [
+        "event_id"
+      ],
+      "nameExplicit": false,
+      "name": "event_sync_index_event_id_unique",
+      "entityType": "uniques",
+      "table": "event_sync_index"
+    },
+    {
+      "columns": [
+        "target_session_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_fork_admission_target_session_id_unique",
+      "entityType": "uniques",
+      "table": "session_fork_admission"
+    },
+    {
+      "columns": [
+        "target_session_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_fork_intent_target_session_id_unique",
+      "entityType": "uniques",
+      "table": "session_fork_intent"
+    },
+    {
+      "columns": [
+        "resolution_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_prompt_epoch_recovery_resolution_id_unique",
+      "entityType": "uniques",
+      "table": "session_prompt_epoch_recovery"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "session_steer_id_unique",
+      "entityType": "uniques",
+      "table": "session_steer"
+    },
+    {
+      "columns": [
+        "receipt_id"
+      ],
+      "nameExplicit": false,
+      "name": "session_tool_request_resolution_receipt_id_unique",
+      "entityType": "uniques",
+      "table": "session_tool_request_resolution"
+    },
+    {
+      "columns": [
+        "run_id"
+      ],
+      "nameExplicit": false,
+      "name": "task_notification_outbox_run_id_unique",
+      "entityType": "uniques",
+      "table": "task_notification_outbox"
+    },
+    {
+      "columns": [
+        "message_id"
+      ],
+      "nameExplicit": false,
+      "name": "task_notification_outbox_message_id_unique",
+      "entityType": "uniques",
+      "table": "task_notification_outbox"
+    },
+    {
+      "value": "\"trigger\" IN ('idle', 'pause', 'project_switch', 'session_finalization')",
+      "name": "learning_admission_outbox_trigger_check",
+      "entityType": "checks",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "value": "json_valid(\"payload_json\") AND json_type(\"payload_json\") = 'object'",
+      "name": "learning_admission_outbox_payload_json_check",
+      "entityType": "checks",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "value": "length(\"payload_fingerprint\") = 64 AND \"payload_fingerprint\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_admission_outbox_payload_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "value": "\"state\" IN ('pending', 'admitted', 'rejected')",
+      "name": "learning_admission_outbox_state_check",
+      "entityType": "checks",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "value": "(\"state\" = 'pending' AND \"job_id\" IS NULL AND \"candidate_input_ref\" IS NULL AND \"rejection_code\" IS NULL AND \"rejection_detail\" IS NULL AND \"settled_at\" IS NULL) OR (\"state\" = 'admitted' AND \"job_id\" IS NOT NULL AND length(trim(\"candidate_input_ref\")) > 0 AND \"rejection_code\" IS NULL AND \"rejection_detail\" IS NULL AND \"settled_at\" IS NOT NULL) OR (\"state\" = 'rejected' AND \"job_id\" IS NULL AND length(trim(\"rejection_code\")) > 0 AND length(trim(\"rejection_detail\")) > 0 AND \"settled_at\" IS NOT NULL)",
+      "name": "learning_admission_outbox_settlement_check",
+      "entityType": "checks",
+      "table": "learning_admission_outbox"
+    },
+    {
+      "value": "\"sequence\" >= 0",
+      "name": "learning_governance_action_sequence_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "\"version\" >= 0",
+      "name": "learning_governance_action_version_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "length(trim(\"candidate_id\")) > 0",
+      "name": "learning_governance_action_candidate_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "json_valid(\"payload_json\")",
+      "name": "learning_governance_action_payload_json_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "\"kind\" IN ('document_stage', 'memory_inbox')",
+      "name": "learning_governance_action_kind_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "length(\"payload_fingerprint\") = 64 AND \"payload_fingerprint\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_governance_action_payload_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "\"result_hash\" IS NULL OR (length(\"result_hash\") = 64 AND \"result_hash\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_governance_action_result_hash_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "\"result_fingerprint\" IS NULL OR (length(\"result_fingerprint\") = 64 AND \"result_fingerprint\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_governance_action_result_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "\"state\" IN ('prepared', 'running', 'settled', 'recovery_required')",
+      "name": "learning_governance_action_state_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "(\"state\" = 'prepared' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND \"result_ref\" IS NULL AND \"result_hash\" IS NULL AND \"result_fingerprint\" IS NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NULL) OR (\"state\" = 'running' AND length(trim(\"owner\")) > 0 AND \"lease_expires_at\" IS NOT NULL AND \"result_ref\" IS NULL AND \"result_hash\" IS NULL AND \"result_fingerprint\" IS NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NULL) OR (\"state\" = 'settled' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND length(trim(\"result_ref\")) > 0 AND \"result_hash\" IS NOT NULL AND \"result_fingerprint\" IS NOT NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NOT NULL) OR (\"state\" = 'recovery_required' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND length(trim(\"error_code\")) > 0 AND \"settled_at\" IS NOT NULL)",
+      "name": "learning_governance_action_lifecycle_check",
+      "entityType": "checks",
+      "table": "learning_governance_action"
+    },
+    {
+      "value": "\"sequence\" >= 0",
+      "name": "learning_governance_compensation_sequence_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "\"version\" >= 0",
+      "name": "learning_governance_compensation_version_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "\"kind\" IN ('document_quarantine', 'memory_inbox_revoke')",
+      "name": "learning_governance_compensation_kind_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "length(\"source_payload_fingerprint\") = 64 AND \"source_payload_fingerprint\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_governance_compensation_source_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "\"result_hash\" IS NULL OR (length(\"result_hash\") = 64 AND \"result_hash\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_governance_compensation_result_hash_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "\"result_fingerprint\" IS NULL OR (length(\"result_fingerprint\") = 64 AND \"result_fingerprint\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_governance_compensation_result_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "\"state\" IN ('prepared', 'running', 'settled', 'recovery_required')",
+      "name": "learning_governance_compensation_state_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "(\"state\" = 'prepared' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND \"result_ref\" IS NULL AND \"result_hash\" IS NULL AND \"result_fingerprint\" IS NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NULL) OR (\"state\" = 'running' AND length(trim(\"owner\")) > 0 AND \"lease_expires_at\" IS NOT NULL AND \"result_ref\" IS NULL AND \"result_hash\" IS NULL AND \"result_fingerprint\" IS NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NULL) OR (\"state\" = 'settled' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND length(trim(\"result_ref\")) > 0 AND \"result_hash\" IS NOT NULL AND \"result_fingerprint\" IS NOT NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NOT NULL) OR (\"state\" = 'recovery_required' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND length(trim(\"error_code\")) > 0 AND \"settled_at\" IS NOT NULL)",
+      "name": "learning_governance_compensation_lifecycle_check",
+      "entityType": "checks",
+      "table": "learning_governance_compensation"
+    },
+    {
+      "value": "\"policy\" = 'manual_review'",
+      "name": "learning_governance_plan_policy_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "\"action_count\" >= 0",
+      "name": "learning_governance_plan_action_count_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "\"version\" >= 0",
+      "name": "learning_governance_plan_version_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "json_valid(\"payload_json\")",
+      "name": "learning_governance_plan_payload_json_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "length(\"payload_fingerprint\") = 64 AND \"payload_fingerprint\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_governance_plan_payload_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "\"result_hash\" IS NULL OR (length(\"result_hash\") = 64 AND \"result_hash\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_governance_plan_result_hash_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "\"result_fingerprint\" IS NULL OR (length(\"result_fingerprint\") = 64 AND \"result_fingerprint\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_governance_plan_result_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "\"state\" IN ('prepared', 'settled', 'recovery_required')",
+      "name": "learning_governance_plan_state_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "(\"state\" = 'prepared' AND \"result_ref\" IS NULL AND \"result_hash\" IS NULL AND \"result_fingerprint\" IS NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NULL) OR (\"state\" = 'settled' AND length(trim(\"result_ref\")) > 0 AND \"result_hash\" IS NOT NULL AND \"result_fingerprint\" IS NOT NULL AND \"error_code\" IS NULL AND \"settled_at\" IS NOT NULL) OR (\"state\" = 'recovery_required' AND length(trim(\"error_code\")) > 0 AND \"settled_at\" IS NOT NULL)",
+      "name": "learning_governance_plan_settlement_check",
+      "entityType": "checks",
+      "table": "learning_governance_plan"
+    },
+    {
+      "value": "\"trigger\" IN ('idle', 'pause', 'project_switch', 'session_finalization')",
+      "name": "learning_job_trigger_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"policy\" IN ('auto_merge_safe_project', 'manual_review')",
+      "name": "learning_job_policy_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"state\" IN ('queued', 'running', 'reviewing', 'governance', 'completed', 'failed', 'cancelled', 'recovery_required')",
+      "name": "learning_job_state_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"attempts\" >= 0",
+      "name": "learning_job_attempts_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"max_attempts\" > 0",
+      "name": "learning_job_max_attempts_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"version\" >= 0",
+      "name": "learning_job_version_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "length(\"admission_fingerprint\") = 64 AND \"admission_fingerprint\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_job_admission_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "(\"side_effect_state\" = 'not_started' AND \"side_effect_kind\" IS NULL) OR (\"side_effect_state\" IN ('started', 'settled', 'unknown') AND \"side_effect_kind\" IS NOT NULL)",
+      "name": "learning_job_side_effect_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "(\"side_effect_state\" = 'not_started' AND \"expected_result_ref\" IS NULL) OR (\"side_effect_kind\" IN ('extraction', 'reviewer') AND \"side_effect_state\" IN ('started', 'settled') AND length(trim(\"expected_result_ref\")) > 0) OR (\"side_effect_kind\" = 'governance' AND \"expected_result_ref\" IS NULL) OR (\"side_effect_state\" = 'unknown' AND \"expected_result_ref\" IS NULL)",
+      "name": "learning_job_expected_result_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"side_effect_state\" <> 'settled' OR (length(trim(\"result_ref\")) > 0 AND (\"expected_result_ref\" IS NULL OR \"side_effect_kind\" = 'reviewer' OR \"result_ref\" = \"expected_result_ref\"))",
+      "name": "learning_job_settled_result_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"state\" NOT IN ('running', 'reviewing', 'governance') OR \"side_effect_state\" = 'not_started' OR (\"state\" = 'running' AND \"side_effect_kind\" = 'extraction') OR (\"state\" = 'reviewing' AND \"side_effect_kind\" = 'reviewer') OR (\"state\" = 'governance' AND \"side_effect_kind\" = 'governance')",
+      "name": "learning_job_active_phase_kind_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "(\"state\" = 'queued' AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND \"side_effect_state\" = 'not_started') OR (\"state\" IN ('running', 'reviewing', 'governance') AND \"started_at\" IS NOT NULL AND \"settled_at\" IS NULL AND ((length(trim(\"owner\")) > 0 AND \"lease_expires_at\" IS NOT NULL) OR (\"state\" IN ('reviewing', 'governance') AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND \"side_effect_state\" = 'not_started'))) OR (\"state\" IN ('completed', 'failed', 'cancelled', 'recovery_required') AND \"owner\" IS NULL AND \"lease_expires_at\" IS NULL AND \"settled_at\" IS NOT NULL)",
+      "name": "learning_job_ownership_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"state\" <> 'recovery_required' OR (\"side_effect_state\" <> 'not_started' AND \"error_code\" IS NOT NULL)",
+      "name": "learning_job_recovery_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"state\" <> 'completed' OR (\"side_effect_state\" = 'settled' AND length(trim(\"result_ref\")) > 0)",
+      "name": "learning_job_completed_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"state\" <> 'failed' OR length(trim(\"error_code\")) > 0",
+      "name": "learning_job_failed_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"state\" NOT IN ('completed', 'failed', 'cancelled') OR \"side_effect_state\" IN ('not_started', 'settled')",
+      "name": "learning_job_terminal_side_effect_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"settlement_fingerprint\" IS NULL OR (length(\"settlement_fingerprint\") = 64 AND \"settlement_fingerprint\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_job_settlement_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_job"
+    },
+    {
+      "value": "\"trigger\" IN ('idle', 'pause', 'project_switch')",
+      "name": "learning_lifecycle_trigger_kind_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "\"state\" IN ('prepared', 'admitted')",
+      "name": "learning_lifecycle_trigger_state_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "length(\"source_admission_hash\") = 64 AND \"source_admission_hash\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_lifecycle_trigger_source_admission_hash_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "length(\"source_terminal_hash\") = 64 AND \"source_terminal_hash\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_lifecycle_trigger_source_terminal_hash_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "length(\"artifact_hash\") = 64 AND \"artifact_hash\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_lifecycle_trigger_artifact_hash_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "length(\"admission_fingerprint\") = 64 AND \"admission_fingerprint\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_lifecycle_trigger_admission_fingerprint_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "json_valid(\"admission_json\") AND json_type(\"admission_json\") = 'object'",
+      "name": "learning_lifecycle_trigger_admission_json_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "json_valid(\"artifact_json\") AND json_type(\"artifact_json\") = 'object'",
+      "name": "learning_lifecycle_trigger_artifact_json_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "(\"state\" = 'prepared' AND \"settled_at\" IS NULL) OR (\"state\" = 'admitted' AND \"settled_at\" IS NOT NULL AND \"error_detail\" IS NULL)",
+      "name": "learning_lifecycle_trigger_settlement_check",
+      "entityType": "checks",
+      "table": "learning_lifecycle_trigger_receipt"
+    },
+    {
+      "value": "\"state\" IN ('prepared', 'dispatching', 'settled', 'failed', 'recovery_required')",
+      "name": "learning_reviewer_attempt_state_check",
+      "entityType": "checks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "value": "\"version\" >= 0",
+      "name": "learning_reviewer_attempt_version_check",
+      "entityType": "checks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "value": "length(\"request_hash\") = 64 AND \"request_hash\" NOT GLOB '*[^0-9a-f]*' AND length(\"source_candidate_set_hash\") = 64 AND \"source_candidate_set_hash\" NOT GLOB '*[^0-9a-f]*' AND length(\"policy_hash\") = 64 AND \"policy_hash\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "learning_reviewer_attempt_hash_check",
+      "entityType": "checks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "value": "(\"state\" IN ('prepared', 'dispatching') AND \"settled_at\" IS NULL) OR (\"state\" IN ('settled', 'failed', 'recovery_required') AND \"settled_at\" IS NOT NULL)",
+      "name": "learning_reviewer_attempt_terminal_check",
+      "entityType": "checks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "value": "(\"state\" <> 'settled' AND \"response_ref\" IS NULL AND \"response_hash\" IS NULL AND \"verdict\" IS NULL AND \"selected_candidate_ids_json\" IS NULL AND \"selected_subset_hash\" IS NULL) OR (\"state\" = 'settled' AND length(trim(\"response_ref\")) > 0 AND length(\"response_hash\") = 64 AND \"response_hash\" NOT GLOB '*[^0-9a-f]*' AND \"verdict\" IN ('approve', 'reject', 'manual_review') AND length(trim(\"selected_candidate_ids_json\")) > 0 AND length(\"selected_subset_hash\") = 64 AND \"selected_subset_hash\" NOT GLOB '*[^0-9a-f]*')",
+      "name": "learning_reviewer_attempt_response_check",
+      "entityType": "checks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "value": "\"state\" NOT IN ('failed', 'recovery_required') OR length(trim(\"error_code\")) > 0",
+      "name": "learning_reviewer_attempt_error_check",
+      "entityType": "checks",
+      "table": "learning_reviewer_attempt"
+    },
+    {
+      "value": "length(\"matrix_hash\") = 64 AND \"matrix_hash\" NOT GLOB '*[^0-9a-f]*'",
+      "name": "released_knowledge_evaluation_matrix_hash_check",
+      "entityType": "checks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "value": "json_valid(\"matrix_json\")",
+      "name": "released_knowledge_evaluation_matrix_json_check",
+      "entityType": "checks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "value": "json_valid(\"document_manifest_json\") AND json_type(\"document_manifest_json\") = 'array'",
+      "name": "released_knowledge_evaluation_document_manifest_json_check",
+      "entityType": "checks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "value": "\"repetitions\" > 0",
+      "name": "released_knowledge_evaluation_repetitions_check",
+      "entityType": "checks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "value": "\"evaluator_type\" IN ('human', 'agent', 'system')",
+      "name": "released_knowledge_evaluation_actor_type_check",
+      "entityType": "checks",
+      "table": "released_knowledge_evaluation"
+    },
+    {
+      "value": "\"ordinal\" >= 0",
+      "name": "released_knowledge_snapshot_document_ordinal_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "value": "\"source_store\" IN ('user_global', 'project')",
+      "name": "released_knowledge_snapshot_document_source_store_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "value": "\"doc_version\" > 0",
+      "name": "released_knowledge_snapshot_document_version_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "value": "length(\"doc_hash\") = 71 AND substr(\"doc_hash\", 1, 7) = 'sha256:' AND substr(\"doc_hash\", 8) NOT GLOB '*[^0-9a-f]*'",
+      "name": "released_knowledge_snapshot_document_hash_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "value": "\"doc_type\" IN ('knowledge', 'strategy', 'methodology', 'memory', 'skill')",
+      "name": "released_knowledge_snapshot_document_type_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot_document"
+    },
+    {
+      "value": "(\"snapshot_id\" IS NULL AND \"generation\" = 0) OR (\"snapshot_id\" IS NOT NULL AND \"generation\" > 0)",
+      "name": "released_knowledge_snapshot_head_generation_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot_head"
+    },
+    {
+      "value": "\"release_kind\" IN ('legacy_baseline', 'evaluated', 'rollback')",
+      "name": "released_knowledge_snapshot_release_kind_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "\"document_count\" >= 0",
+      "name": "released_knowledge_snapshot_document_count_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "(\"verdict\" = 'passed' AND \"published_generation\" > 0) OR (\"verdict\" = 'failed' AND \"published_generation\" >= 0)",
+      "name": "released_knowledge_snapshot_published_generation_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "\"verdict\" IN ('passed', 'failed')",
+      "name": "released_knowledge_snapshot_verdict_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "(\"verdict\" = 'passed' AND \"failure_reason\" IS NULL) OR (\"verdict\" = 'failed' AND length(trim(\"failure_reason\")) > 0)",
+      "name": "released_knowledge_snapshot_failure_reason_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "(\"release_kind\" = 'legacy_baseline' AND \"parent_snapshot_id\" IS NULL AND \"verdict\" = 'passed') OR (\"release_kind\" <> 'legacy_baseline' AND \"parent_snapshot_id\" IS NOT NULL)",
+      "name": "released_knowledge_snapshot_release_chain_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "\"release_kind\" <> 'evaluated' OR \"verdict\" = 'failed' OR \"document_count\" > 0",
+      "name": "released_knowledge_snapshot_evaluated_membership_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    },
+    {
+      "value": "\"actor_type\" IN ('human', 'agent', 'system')",
+      "name": "released_knowledge_snapshot_actor_type_check",
+      "entityType": "checks",
+      "table": "released_knowledge_snapshot"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/packages/core/package.json b/packages/core/package.json
index cffe3aa2..ea328b62 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "4.0.7-r2",
+  "version": "4.0.8",
   "name": "@deepagent-code/core",
   "type": "module",
   "license": "AGPL-3.0-or-later",
diff --git a/packages/core/script/release-gate-migration-check.ts b/packages/core/script/release-gate-migration-check.ts
new file mode 100644
index 00000000..7fe123c9
--- /dev/null
+++ b/packages/core/script/release-gate-migration-check.ts
@@ -0,0 +1,21 @@
+// Release-gate migration check: open a DB copy via layerFromPath (which applies pending
+// migrations) and report the latest applied migrations. Never touches the live DB.
+import { Effect } from "effect"
+import { Database } from "../src/database/database"
+
+const filename = process.argv[2]
+if (!filename) {
+  console.error("usage: bun script/release-gate-migration-check.ts <db-path>")
+  process.exit(1)
+}
+
+const program = Effect.gen(function* () {
+  const svc = yield* Database.Service
+  const rows = yield* svc.db.all<{ id: string }>("SELECT id FROM migration ORDER BY id DESC LIMIT 6")
+  console.log("APPLIED_OK")
+  for (const row of rows) console.log("  migration:", row.id)
+  const count = yield* svc.db.get<{ n: number }>("SELECT COUNT(*) AS n FROM migration")
+  console.log("total migrations:", count?.n)
+}).pipe(Effect.provide(Database.layerFromPath(filename)))
+
+await Effect.runPromise(program)
diff --git a/packages/core/src/agent-gateway.ts b/packages/core/src/agent-gateway.ts
index 6944769d..49e04155 100644
--- a/packages/core/src/agent-gateway.ts
+++ b/packages/core/src/agent-gateway.ts
@@ -17,6 +17,7 @@ import { knowledgeEnabled, strategyMethodologyEnabled, domainKnowledgeEnabled, m
 import type { AgentMode } from "./deepagent/mode"
 import { resolveDeepAgentCodeHome } from "./deepagent/workspace"
 import * as KnowledgeRetriever from "./deepagent/knowledge-retriever"
+import { buildProfile as buildRunProfile } from "./deepagent/profile-builder"
 import type { ProblemProfile } from "./deepagent/domain-pack"
 import { DeepAgentDurableLearning, type Admission } from "./deepagent/durable-learning"
 import { writeFileAtomic } from "./deepagent/atomic-write"
@@ -543,6 +544,7 @@ import * as DeepAgentKnowledgeSource from "./deepagent/knowledge-source"
 import * as DeepAgentKnowledgeSeed from "./deepagent/knowledge-seed"
 import * as DeepAgentDurableKnowledgeStore from "./deepagent/durable-knowledge-store"
 import * as DeepAgentDomainPackRegistry from "./deepagent/domain-pack-registry"
+import { readPinnedPacks } from "./deepagent/pinned-packs"
 import * as DeepAgentPromotion from "./deepagent/promotion"
 import * as DeepAgentDocumentStore from "./deepagent/document-store"
 import * as DeepAgentRunGraph from "./deepagent/run-graph"
@@ -917,6 +919,12 @@ const ensureSessionStateForRun = (run: RunRecord): DeepAgentSessionState.Session
     runId: run.runID,
     workspacePath: workspacePathForInput(run.input) ?? existing?.workspacePath ?? process.cwd(),
     userRequest: userRequestForInput(run.input) ?? existing?.userRequest ?? null,
+    // FEAT-007: lock the run's active pack snapshot id onto the session state at the run entry, so
+    // the session prompt loop can attribute each tool-request receipt's
+    // context_active_pack_set_snapshot_id to the exact pack set that shaped this run's knowledge
+    // retrieval. Single authority (FEAT-002): activePackSnapshot is memoized per run and derives from
+    // the SAME activation the retriever constrains on, so the receipt never re-derives it.
+    packSnapshotId: activePackSnapshot(run).id,
   })
 }
 
@@ -1769,6 +1777,9 @@ const modelWorkPackage = (run: RunRecord) => {
   const selectedStrategyRefs = refIdsOfKind("strategy")
   const selectedMemoryRefs = refIdsOfKind("memory")
   const selectedMethodologyRefs = refIdsOfKind("methodology")
+  // FEAT-002: compute the pack snapshot ONCE per work package (previously 2+ calls per record
+  // build); the WeakMap inside activePackSnapshot keeps every other call site on the same value.
+  const packSnapshot = activePackSnapshot(run)
   return {
     schema_version: "model_work_package.v1",
     work_package_id: run.workPackageID,
@@ -1953,9 +1964,10 @@ const modelWorkPackage = (run: RunRecord) => {
     required_skill_refs: [],
     selected_methodology_refs: selectedMethodologyRefs,
     // docs/34 §9 S4/DAP-7: record the active domain pack set + locked snapshot so the run is
-    // reproducible. activePackSnapshot is derived from the run's problem profile via the registry.
-    active_pack_set: activePackSnapshot(run).packs.map((p) => p.id),
-    pack_snapshot_id: activePackSnapshot(run).id,
+    // reproducible. FEAT-002: derived from the run's single authoritative profile (same one
+    // retrieval consumed), so active_pack_set and the retrieval constraints share one source.
+    active_pack_set: packSnapshot.packs.map((p) => p.id),
+    pack_snapshot_id: packSnapshot.id,
     knowledge_retrieval: {
       enabled: knowledgeEnabled(run.agentMode),
       mode: knowledgeEnabled(run.agentMode) ? "bounded_retrieval_refs_only" : "disabled",
@@ -2986,6 +2998,10 @@ function parseAgentMode(value: string | undefined): AgentMode {
 const retrieveKnowledge = (run: RunRecord) => {
   const task = extractTaskContext(run)
   const workspacePath = workspacePathForInput(run.input)
+  // FEAT-001: GUI-pinned packs must reach retrieval. Pins persist in the workspace memory dir
+  // (<baseDir>/memory/pinned-packs.json) written by the packsPin/packsUnpin handlers; the gateway
+  // reads the SAME dir so the control plane and the runtime agree.
+  const pinned = pinnedPackIds()
   return KnowledgeRetriever.retrieve({
     mode: run.agentMode,
     task,
@@ -2993,6 +3009,11 @@ const retrieveKnowledge = (run: RunRecord) => {
     round: 1,
     previousFailures: 0,
     profile: extractProblemProfile(run),
+    // FEAT-002: the authoritative run profile (built once per run). The retriever uses it for
+    // pack activation instead of re-deriving one from task text, so retrieval's selected packs
+    // and the run record's active_pack_set come from the same profile.
+    profileOverride: profileForRun(run),
+    ...(pinned.length > 0 ? { domainOptions: { overrides: pinned } } : {}),
     // docs/34 §8: scope durable retrieval to the run's workspace path (unions user-global +
     // this workspace's project-shared). Absent workspace => user-global only.
     ...(workspacePath ? { workspacePath } : {}),
@@ -3058,35 +3079,60 @@ const extractProblemProfile = (run: RunRecord): ProblemProfile => {
   }
 }
 
+// FEAT-001: the workspace memory dir the HTTP handlers (deepagent-code) write pinned-packs.json to
+// is <gateway baseDir>/memory (dirname(runsDir)/memory == Global.Path.agent.data/memory in
+// production). The gateway derives it from its own configured storage home — no workspacePath
+// needed, since the pin file is per-instance, mirroring the handler's workspaceMemoryDir().
+const pinnedMemoryDir = (): string => path.join(path.resolve(current.baseDir ?? resolveDeepAgentCodeHome()), "memory")
+
+const pinnedPackIds = (): string[] => readPinnedPacks(pinnedMemoryDir())
+
+// FEAT-002: the SINGLE authoritative ExtendedProblemProfile producer for a run. The gateway used
+// to keep two competing truths — profileFromInput (regex-derived inside the retriever) and a
+// hardcoded profile for the recorded snapshot — so active_pack_set could diverge from the packs
+// retrieval actually constrained on. Now the gateway builds one profile at run entry (workspace
+// facts via profile-builder, the same logic deepagent-code's profile-detector re-exports) and both
+// knowledge retrieval (RetrievalInput.profileOverride) and the pack snapshot consume it. Built
+// once per run record: inputs are immutable and pins are read once, so the WeakMap cache makes
+// every downstream call site observe the identical profile.
+const runProfileCache = new WeakMap<RunRecord, DeepAgentDomainPackRegistry.ExtendedProblemProfile>()
+const profileForRun = (run: RunRecord): DeepAgentDomainPackRegistry.ExtendedProblemProfile => {
+  const cached = runProfileCache.get(run)
+  if (cached) return cached
+  const profile = buildRunProfile({
+    cwd: workspacePathForInput(run.input) ?? process.cwd(),
+    agentMode: run.agentMode,
+    scenarioMode: "intelligence",
+    userRequest: userRequestForInput(run.input) ?? run.input.feature ?? "",
+    userOverrides: pinnedPackIds(),
+  })
+  runProfileCache.set(run, profile)
+  return profile
+}
+
 // docs/34 §9 DAP-7: lock the active domain pack snapshot for a run so each run records the exact
-// pack set that shaped its knowledge retrieval. Best-effort: if the registry has no configured
-// dir or discover returns nothing, the snapshot is empty (no packs) — retrieval still works.
+// pack set that shaped its knowledge retrieval. FEAT-002: no hardcoded profile fields — the
+// snapshot is locked from the SAME activation (activationForProfile over profileForRun) that the
+// retriever constrains on, and memoized per run so the record build calls it effectively once.
+// Best-effort: if the registry has no configured dir or discover returns nothing, the snapshot is
+// empty (no packs) — retrieval still works.
+const packSnapshotCache = new WeakMap<RunRecord, DeepAgentDomainPackRegistry.PackSnapshot>()
 const activePackSnapshot = (run: RunRecord): DeepAgentDomainPackRegistry.PackSnapshot => {
+  const cached = packSnapshotCache.get(run)
+  if (cached) return cached
+  let snapshot: DeepAgentDomainPackRegistry.PackSnapshot
   if (!DeepAgentDomainPackRegistry.isRegistryConfigured()) {
-    return { id: "pack_snapshot:empty", packs: [], created_at: new Date().toISOString() }
-  }
-  try {
-    const signals = run.input.feature ?? ""
-    const profile: DeepAgentDomainPackRegistry.ExtendedProblemProfile = {
-      scenario_mode: "intelligence",
-      agent_strength: run.agentMode as DeepAgentDomainPackRegistry.ExtendedProblemProfile["agent_strength"],
-      task_kind: "implement",
-      code_domains: ["code"],
-      business_domains: [],
-      platforms: [],
-      languages: ["typescript"],
-      frameworks: [],
-      data_classes: [],
-      risk_markers: [],
-      repo_signals: [signals],
-      round_signals: [],
-      user_overrides: [],
+    snapshot = { id: "pack_snapshot:empty", packs: [], created_at: new Date().toISOString() }
+  } else {
+    try {
+      const activation = KnowledgeRetriever.activationForProfile(profileForRun(run))
+      snapshot = DeepAgentDomainPackRegistry.lockSnapshot(activation.activePackIds)
+    } catch {
+      snapshot = { id: "pack_snapshot:error", packs: [], created_at: new Date().toISOString() }
     }
-    const { snapshot } = DeepAgentDomainPackRegistry.activateForProfile(profile)
-    return snapshot
-  } catch {
-    return { id: "pack_snapshot:error", packs: [], created_at: new Date().toISOString() }
   }
+  packSnapshotCache.set(run, snapshot)
+  return snapshot
 }
 
 const activationMode = (mode: AgentMode) =>
diff --git a/packages/core/src/context-federation/provider-owner.ts b/packages/core/src/context-federation/provider-owner.ts
index 5082485e..2a5a7046 100644
--- a/packages/core/src/context-federation/provider-owner.ts
+++ b/packages/core/src/context-federation/provider-owner.ts
@@ -21,6 +21,10 @@ export interface Interface {
   readonly register: (input: {
     readonly ownerToken: string
     readonly leaseMs: number
+    // Successor generation registration (BUG-407-009): the old token was fenced by lease expiry and
+    // this token continues the same ownership chain. Also installs the protocol-3 compatibility fence
+    // so a pre-successor binary refuses to open this database instead of re-quarantining the chain.
+    readonly successor?: boolean
     readonly now?: number
   }) => Effect.Effect<Lease, ConflictError>
   readonly heartbeat: (input: {
@@ -52,6 +56,7 @@ export const layer = Layer.effect(
     const register = Effect.fn("SessionProviderOwner.register")(function* (input: {
       readonly ownerToken: string
       readonly leaseMs: number
+      readonly successor?: boolean
       readonly now?: number
     }) {
       return yield* db
@@ -92,7 +97,7 @@ export function observedAtInTransaction(tx: Transaction): Effect.Effect<number>
 
 function registerInTransaction(
   tx: Transaction,
-  input: { readonly ownerToken: string; readonly leaseMs: number },
+  input: { readonly ownerToken: string; readonly leaseMs: number; readonly successor?: boolean },
 ) {
   return Effect.gen(function* () {
     if (!input.ownerToken.trim()) return yield* new ConflictError({ reason: "owner_token_required" })
@@ -110,6 +115,14 @@ function registerInTransaction(
       .returning()
       .get()
     if (!inserted) return yield* new ConflictError({ reason: "owner_token_already_registered" })
+    if (input.successor)
+      yield* tx.run(sql`
+        INSERT INTO database_capability(
+          capability, minimum_reader_protocol, minimum_writer_protocol, installed_at
+        ) VALUES (
+          'provider_owner_successor_v1', 3, 3, ${databaseNow}
+        ) ON CONFLICT(capability) DO NOTHING
+      `)
     return lease(inserted)
   })
 }
diff --git a/packages/core/src/context-federation/reconciliation-sql.ts b/packages/core/src/context-federation/reconciliation-sql.ts
new file mode 100644
index 00000000..0c7b941a
--- /dev/null
+++ b/packages/core/src/context-federation/reconciliation-sql.ts
@@ -0,0 +1,33 @@
+// FEAT-007: durable per-turn reconciliation records for federated context selections.
+// One row per federated provider turn receipt — compares the legacy selected refs (when
+// available at the receipt write site) against the projection selection ref set so the
+// "why did the model see these documents" question survives restarts (knowledgeMemoryDelta
+// is in-memory only).
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core"
+import { SessionTable } from "../session/sql"
+import { SessionActivityTable } from "./session-sql"
+import type { ContextReconciliation } from "./reconciliation"
+
+export const SessionContextReconciliationTable = sqliteTable(
+  "session_context_reconciliation",
+  {
+    reconciliation_id: text().primaryKey().notNull(),
+    session_id: text()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    activity_id: text()
+      .notNull()
+      .references(() => SessionActivityTable.activity_id, { onDelete: "cascade" }),
+    turn_receipt_id: text().notNull(),
+    selection_id: text(),
+    legacy_refs_fingerprint: text(),
+    projection_refs_fingerprint: text().notNull(),
+    outcome: text().$type<ContextReconciliation.Outcome>().notNull(),
+    diff_summary: text({ mode: "json" }).$type<ContextReconciliation.DiffSummary>().notNull(),
+    created_at: integer().notNull(),
+  },
+  (table) => [
+    uniqueIndex("session_context_reconciliation_receipt_idx").on(table.turn_receipt_id),
+    index("session_context_reconciliation_session_idx").on(table.session_id, table.created_at),
+  ],
+)
diff --git a/packages/core/src/context-federation/reconciliation.ts b/packages/core/src/context-federation/reconciliation.ts
new file mode 100644
index 00000000..60bb84f5
--- /dev/null
+++ b/packages/core/src/context-federation/reconciliation.ts
@@ -0,0 +1,158 @@
+export * as ContextReconciliation from "./reconciliation"
+
+import { Effect } from "effect"
+import { Database } from "../database/database"
+import { Hash } from "../util/hash"
+import type { GraphKind } from "./contract"
+import { SessionContextReconciliationTable } from "./reconciliation-sql"
+
+export type RefKeyParts = {
+  readonly graph: GraphKind
+  readonly entityId: string
+  readonly revision: string
+}
+
+export type Outcome =
+  | "legacy_unavailable_projection_consistent"
+  | "legacy_unavailable_projection_duplicate_refs"
+  | "legacy_match"
+  | "legacy_mismatch"
+
+export type DiffSummary = {
+  readonly mode: "projection_internal" | "legacy_vs_projection"
+  readonly refCount: number
+  readonly duplicateCount: number
+  readonly perGraph: Readonly<Record<string, number>>
+  readonly legacy?: {
+    readonly refCount: number
+    readonly onlyInLegacy: readonly string[]
+    readonly onlyInProjection: readonly string[]
+    readonly sharedCount: number
+  }
+  readonly note?: string
+}
+
+export type RecordInput = {
+  readonly sessionId: string
+  readonly activityId: string
+  readonly turnReceiptId: string
+  readonly selectionId?: string
+  readonly projectionRefs: readonly RefKeyParts[]
+  readonly legacyRefs?: readonly RefKeyParts[]
+  readonly now?: number
+}
+
+export function refKey(parts: RefKeyParts): string {
+  return `${parts.graph}:${parts.entityId}:${parts.revision}`
+}
+
+/** Sorted, de-duplicated ref keys — the canonical set representation for fingerprinting/diffing. */
+export function refKeys(refs: readonly RefKeyParts[]): readonly string[] {
+  return [...new Set(refs.map(refKey))].sort()
+}
+
+export function duplicateCount(refs: readonly RefKeyParts[]): number {
+  return refs.length - new Set(refs.map(refKey)).size
+}
+
+export function refsFingerprint(refs: readonly RefKeyParts[]): string {
+  return Hash.sha256(JSON.stringify(refKeys(refs)))
+}
+
+export function diffRefKeys(a: readonly string[], b: readonly string[]) {
+  const setA = new Set(a)
+  const setB = new Set(b)
+  return {
+    onlyInA: a.filter((key) => !setB.has(key)),
+    onlyInB: b.filter((key) => !setA.has(key)),
+    sharedCount: a.filter((key) => setB.has(key)).length,
+  }
+}
+
+function perGraph(refs: readonly RefKeyParts[]): Record<string, number> {
+  return refs.reduce<Record<string, number>>(
+    (counts, ref) => ({ ...counts, [ref.graph]: (counts[ref.graph] ?? 0) + 1 }),
+    {},
+  )
+}
+
+export function evaluate(input: {
+  readonly projectionRefs: readonly RefKeyParts[]
+  readonly legacyRefs?: readonly RefKeyParts[]
+}): {
+  readonly outcome: Outcome
+  readonly projectionFingerprint: string
+  readonly legacyFingerprint?: string
+  readonly diffSummary: DiffSummary
+} {
+  const projectionFingerprint = refsFingerprint(input.projectionRefs)
+  const duplicates = duplicateCount(input.projectionRefs)
+  const base = {
+    refCount: input.projectionRefs.length,
+    duplicateCount: duplicates,
+    perGraph: perGraph(input.projectionRefs),
+  }
+  if (!input.legacyRefs) {
+    // Legacy selected refs are produced inside the provider prepare path only; the receipt
+    // write site has the projection selection exclusively. Record projection-internal
+    // consistency instead of a cross-path diff (FEAT-007 fallback).
+    return {
+      outcome: duplicates > 0 ? "legacy_unavailable_projection_duplicate_refs" : "legacy_unavailable_projection_consistent",
+      projectionFingerprint,
+      diffSummary: {
+        ...base,
+        mode: "projection_internal",
+        note: "legacy selected refs unavailable at receipt write site; projection-internal consistency recorded",
+      },
+    }
+  }
+  const legacyKeys = refKeys(input.legacyRefs)
+  const projectionKeys = refKeys(input.projectionRefs)
+  const diff = diffRefKeys(legacyKeys, projectionKeys)
+  return {
+    outcome: diff.onlyInA.length === 0 && diff.onlyInB.length === 0 ? "legacy_match" : "legacy_mismatch",
+    projectionFingerprint,
+    legacyFingerprint: Hash.sha256(JSON.stringify(legacyKeys)),
+    diffSummary: {
+      ...base,
+      mode: "legacy_vs_projection",
+      legacy: {
+        refCount: input.legacyRefs.length,
+        onlyInLegacy: diff.onlyInA,
+        onlyInProjection: diff.onlyInB,
+        sharedCount: diff.sharedCount,
+      },
+    },
+  }
+}
+
+/** Deterministic per-receipt identity; safe for idempotent retries. */
+export function reconciliationId(turnReceiptId: string): string {
+  return Hash.sha256(`session-context-reconciliation:${turnReceiptId}`)
+}
+
+/**
+ * Durable per-turn reconciliation write. Idempotent on `turn_receipt_id`; callers are
+ * expected to wrap this best-effort so a failure never blocks the turn.
+ */
+export function record(db: Database.Interface["db"], input: RecordInput) {
+  return Effect.gen(function* () {
+    const evaluated = evaluate(input)
+    yield* db
+      .insert(SessionContextReconciliationTable)
+      .values({
+        reconciliation_id: reconciliationId(input.turnReceiptId),
+        session_id: input.sessionId,
+        activity_id: input.activityId,
+        turn_receipt_id: input.turnReceiptId,
+        selection_id: input.selectionId ?? null,
+        legacy_refs_fingerprint: evaluated.legacyFingerprint ?? null,
+        projection_refs_fingerprint: evaluated.projectionFingerprint,
+        outcome: evaluated.outcome,
+        diff_summary: evaluated.diffSummary,
+        created_at: input.now ?? Date.now(),
+      })
+      .onConflictDoNothing({ target: SessionContextReconciliationTable.turn_receipt_id })
+    return evaluated
+  })
+}
diff --git a/packages/core/src/context-federation/session-context.ts b/packages/core/src/context-federation/session-context.ts
index 652cbdc3..dda3b106 100644
--- a/packages/core/src/context-federation/session-context.ts
+++ b/packages/core/src/context-federation/session-context.ts
@@ -187,7 +187,7 @@ export interface Interface {
     readonly activityId: string
     readonly state: "settled" | "failed" | "interrupted"
     readonly now?: number
-  }) => Effect.Effect<Activity, Error>
+  }) => Effect.Effect<Activity | undefined, Error>
   readonly commitSelection: (input: CommitSelectionInput) => Effect.Effect<Selection, Error>
   readonly appendValidation: (input: ValidationInput) => Effect.Effect<string, Error>
   readonly hasValidValidation: (input: {
@@ -426,12 +426,16 @@ export const layer = Layer.effect(
       return yield* db
         .transaction((tx) =>
           Effect.gen(function* () {
+            // Idempotent settle (BUG-003): a missing row or one already in a terminal state is a
+            // no-op, not an error — multiple terminal paths (runLoop exit, resolve rollback,
+            // restart recovery) may legitimately race to settle the same activity. Real DB
+            // failures still surface through the error channel.
             const current = yield* tx
               .select()
               .from(SessionActivityTable)
               .where(eq(SessionActivityTable.activity_id, input.activityId))
               .get()
-            if (!current || current.state !== "active") return yield* new ActivityStateError()
+            if (!current || current.state !== "active") return undefined
             const settled = yield* tx
               .update(SessionActivityTable)
               .set({ state: input.state, settled_at: input.now ?? Date.now() })
@@ -440,7 +444,7 @@ export const layer = Layer.effect(
               )
               .returning()
               .get()
-            if (!settled) return yield* new ActivityStateError()
+            if (!settled) return undefined
             return activity(settled)
           }),
         )
diff --git a/packages/core/src/database/database.ts b/packages/core/src/database/database.ts
index edc3acb7..c41db1d4 100644
--- a/packages/core/src/database/database.ts
+++ b/packages/core/src/database/database.ts
@@ -14,6 +14,13 @@ import { containsDataPath } from "../global-path"
 const makeDatabase = EffectDrizzleSqlite.makeWithDefaults()
 type DatabaseShape = Effect.Success<typeof makeDatabase>
 
+// Compatibility protocol this runtime implements. Protocol 2 is the 1.4.5/1.4.6-era; protocol 3
+// marks databases that carry provider-owner successor generations (BUG-407-009 recovery fence): an
+// older binary that does not understand successor tokens must refuse to open such a database, or its
+// startup recovery would re-quarantine the successor state.
+export const SupportedReaderProtocol = 3
+export const SupportedWriterProtocol = 3
+
 export interface Interface {
   db: DatabaseShape
 }
@@ -43,10 +50,10 @@ export const layer = Layer.effect(
       minimum_writer_protocol: number
     }>("SELECT capability, minimum_reader_protocol, minimum_writer_protocol FROM database_capability")
     for (const capability of capabilities) {
-      if (capability.minimum_reader_protocol > 2 || capability.minimum_writer_protocol > 2)
+      if (capability.minimum_reader_protocol > SupportedReaderProtocol || capability.minimum_writer_protocol > SupportedWriterProtocol)
         return yield* Effect.die(
           new Error(
-            `Database capability ${capability.capability} requires reader protocol ${capability.minimum_reader_protocol} and writer protocol ${capability.minimum_writer_protocol}; this runtime supports protocol 2`,
+            `Database capability ${capability.capability} requires reader protocol ${capability.minimum_reader_protocol} and writer protocol ${capability.minimum_writer_protocol}; this runtime supports protocol ${SupportedWriterProtocol}`,
           ),
         )
     }
diff --git a/packages/core/src/database/migration.gen.ts b/packages/core/src/database/migration.gen.ts
index 2029c194..4e3c0e3d 100644
--- a/packages/core/src/database/migration.gen.ts
+++ b/packages/core/src/database/migration.gen.ts
@@ -139,5 +139,15 @@ export const migrations = (
     import("./migration/20260813121129_v2_provider_parity_response_fingerprint"),
     import("./migration/20260813121200_v2_provider_parity_campaign_authority"),
     import("./migration/20260813150000_single_authority_snapshot_merge"),
+    import("./migration/20260815120000_event_delivery_claim_lease"),
+    import("./migration/20260815130000_event_multiprocess_extensions"),
+    import("./migration/20260816000000_handoff_admission_receipt"),
+    import("./migration/20260816073717_session_facade_activity"),
+    import("./migration/20260816080000_receipt_active_pack_set_attribution"),
+    import("./migration/20260816081000_session_context_reconciliation"),
+    import("./migration/20260819120000_session_intent_confirmation_state"),
+    import("./migration/20260820000000_remote_compact_persistence"),
+    import("./migration/20260820120000_session_turn_stage_evidence"),
+    import("./migration/20260820130000_compaction_continuation_fail_closed"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]
diff --git a/packages/core/src/database/migration.ts b/packages/core/src/database/migration.ts
index cf9028dc..b4a044d7 100644
--- a/packages/core/src/database/migration.ts
+++ b/packages/core/src/database/migration.ts
@@ -1,13 +1,33 @@
 export * as DatabaseMigration from "./migration"
 
 import { sql } from "drizzle-orm"
-import { Effect, Semaphore } from "effect"
+import { Cause, Data, Effect, Exit, Schedule, Semaphore } from "effect"
 import type { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
 import { migrations } from "./migration.gen"
 
 type Database = EffectDrizzleSqlite.EffectSQLiteDatabase
 type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0]
 const lock = Semaphore.makeUnsafe(1)
+
+// A migration DDL can fail transiently when another connection (a second desktop instance, a
+// lingering daemon, or an in-process worker) holds an active statement against the old schema:
+// SQLite returns SQLITE_LOCKED immediately and busy_timeout does not apply to schema locks.
+// The migration transaction rolls back cleanly, so retrying once the competing connection
+// releases is safe; without the retry a desktop startup dies on a transient race.
+class TransientLock extends Data.TaggedError("DatabaseMigration.TransientLock")<{ readonly detail: string }> {}
+
+const isLockError = (value: unknown): boolean => {
+  if (typeof value !== "object" || value === null) return false
+  const record = value as { code?: string; message?: string; cause?: unknown }
+  if (record.code === "SQLITE_LOCKED" || record.code === "SQLITE_BUSY") return true
+  if (typeof record.message === "string" && /(database is locked|database table is locked|database is busy)/i.test(record.message))
+    return true
+  return record.cause !== undefined ? isLockError(record.cause) : false
+}
+
+const isTransientLockCause = (cause: Cause.Cause<unknown>): boolean => cause.reasons.some(isLockError)
+
+const transientLockRetry = Schedule.spaced("2 seconds").pipe(Schedule.take(30))
 const historicalAliases = new Map([
   ["20260530232709_lovely_romulus", "20260511173437_session-metadata"],
   ["20260803000000_subagent_control_plane_l1", "20260803000001_subagent_control_plane_l1"],
@@ -21,6 +41,9 @@ const mergedHistoryInsertions = new Set([
   "20260813100000_event_snapshot_authority",
   "20260813110000_provider_recovery_authority_bridge",
   "20260813120000_legacy_provider_receipt_supersession",
+  "20260813120346_v2_provider_parity_campaign",
+  "20260813121129_v2_provider_parity_response_fingerprint",
+  "20260813121200_v2_provider_parity_campaign_authority",
   "20260813125000_event_sync_backfill_authority",
   "20260813130000_file_part_artifact",
   "20260813131000_event_snapshot_chunks",
@@ -32,6 +55,7 @@ const mergedHistoryInsertions = new Set([
   "20260813141000_bug_407_010_sidecar_lifecycle",
   "20260813142000_bug_407_010_sidecar_indexes",
   "20260813143000_bug_407_010_aggregate_indexes",
+  "20260813150000_single_authority_snapshot_merge",
 ])
 
 export type Migration = {
@@ -109,18 +133,39 @@ function applyMigrations(db: Database, input: Migration[], requireLinearHistory:
 
     for (const migration of input) {
       if (completed.has(migration.id)) continue
-      yield* db.transaction((tx) =>
-        Effect.gen(function* () {
-          if (!process.env.DEEPAGENT_CODE_SKIP_MIGRATIONS) {
-            if (reconcileMergedHistory && migration.id === "20260812120000_legacy_provider_recovery")
-              yield* reconcileLegacyProviderRecovery(tx)
-            else yield* migration.up(tx)
-          }
-          yield* tx.run(
-            sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
-          )
-        }),
-      )
+      yield* db
+        .transaction((tx) =>
+          Effect.gen(function* () {
+            if (!process.env.DEEPAGENT_CODE_SKIP_MIGRATIONS) {
+              if (reconcileMergedHistory && migration.id === "20260812120000_legacy_provider_recovery")
+                yield* reconcileLegacyProviderRecovery(tx)
+              else yield* migration.up(tx)
+            }
+            yield* tx.run(
+              sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
+            )
+          }),
+        )
+        .pipe(
+          Effect.exit,
+          Effect.flatMap((exit) => {
+            if (Exit.isSuccess(exit)) return Effect.succeed(undefined)
+            if (isTransientLockCause(exit.cause)) return Effect.fail(new TransientLock({ detail: migration.id }))
+            return Effect.failCause(exit.cause)
+          }),
+          Effect.retry({ while: (error) => error instanceof TransientLock, schedule: transientLockRetry }),
+          Effect.exit,
+          Effect.flatMap((exit) => {
+            if (Exit.isSuccess(exit)) return Effect.succeed(undefined)
+            if (exit.cause.reasons.some((reason) => reason instanceof TransientLock))
+              return Effect.die(
+                new Error(
+                  `database migration ${migration.id} was blocked by another connection for 60s; close other DeepAgent Code windows and restart`,
+                ),
+              )
+            return Effect.failCause(exit.cause)
+          }),
+        )
     }
   })
 }
diff --git a/packages/core/src/database/migration/20260815120000_event_delivery_claim_lease.ts b/packages/core/src/database/migration/20260815120000_event_delivery_claim_lease.ts
new file mode 100644
index 00000000..bcfe1694
--- /dev/null
+++ b/packages/core/src/database/migration/20260815120000_event_delivery_claim_lease.ts
@@ -0,0 +1,22 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// RISK-001: claim/lease columns for durable event retry delivery. `dueRetries()` was an unlocked
+// global scan — two processes (Desktop + CLI daemon, or an upgrade overlap) could pick up the same
+// pending row and execute its side effects twice. A claimant now atomically stamps a token + lease;
+// rows whose lease expired become eligible for re-claim. Nullable so pre-existing rows stay valid.
+export default {
+  id: "20260815120000_event_delivery_claim_lease",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE deepagent_event_delivery ADD COLUMN claim_token TEXT`)
+      yield* tx.run(`ALTER TABLE deepagent_event_delivery ADD COLUMN claimant_id TEXT`)
+      yield* tx.run(`ALTER TABLE deepagent_event_delivery ADD COLUMN claimed_at INTEGER`)
+      yield* tx.run(`ALTER TABLE deepagent_event_delivery ADD COLUMN lease_expires_at INTEGER`)
+      yield* tx.run(`
+        CREATE INDEX deepagent_event_delivery_claim_idx
+        ON deepagent_event_delivery (subscription_group, status, next_attempt_at)
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260815130000_event_multiprocess_extensions.ts b/packages/core/src/database/migration/20260815130000_event_multiprocess_extensions.ts
new file mode 100644
index 00000000..26d4108d
--- /dev/null
+++ b/packages/core/src/database/migration/20260815130000_event_multiprocess_extensions.ts
@@ -0,0 +1,41 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// RISK-006: multi-process extensions for the EventV2 bus.
+//
+//   1. `deepagent_consumer_group.workspace_id` — durable consumer groups had no tenant field, so a
+//      group registry could not express which workspace a group consumes for. Default '' keeps
+//      pre-existing (global/unscoped) registrations valid.
+//   2. `deepagent_event_delivery.priority` — denormalized event priority so `dueRetries`/`claimDue`
+//      can order high-priority work first WITHOUT joining the event table. Nullable: pre-existing
+//      rows read as NULL and are treated as "normal" by the ordering.
+//   3. `deepagent_rate_limit_bucket` — durable fixed-window buckets for the tryPublish rate gate.
+//      Previously the limiter was an in-process Map, so N cooperating processes each enforced their
+//      own 1000/min/workspace quota (×N total). The bucket now lives in the shared DB and is
+//      updated inside an immediate transaction, so all processes enforce ONE combined quota.
+export default {
+  id: "20260815130000_event_multiprocess_extensions",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE deepagent_consumer_group ADD COLUMN workspace_id TEXT NOT NULL DEFAULT ''`)
+      yield* tx.run(`ALTER TABLE deepagent_event_delivery ADD COLUMN priority TEXT`)
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS deepagent_rate_limit_bucket (
+          workspace_id TEXT NOT NULL,
+          window_start INTEGER NOT NULL,
+          count INTEGER NOT NULL,
+          PRIMARY KEY (workspace_id, window_start)
+        )
+      `)
+      yield* tx.run(`
+        CREATE INDEX IF NOT EXISTS deepagent_consumer_group_workspace_idx
+        ON deepagent_consumer_group (workspace_id)
+      `)
+      // sweepPublishLimiter prunes elapsed windows by window_start alone (cross-workspace).
+      yield* tx.run(`
+        CREATE INDEX IF NOT EXISTS deepagent_rate_limit_bucket_window_idx
+        ON deepagent_rate_limit_bucket (window_start)
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260816000000_handoff_admission_receipt.ts b/packages/core/src/database/migration/20260816000000_handoff_admission_receipt.ts
new file mode 100644
index 00000000..51472218
--- /dev/null
+++ b/packages/core/src/database/migration/20260816000000_handoff_admission_receipt.ts
@@ -0,0 +1,35 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// FEAT-008 — durable admission receipt for `agent.handoff.requested` (see handoff-admission-sql.ts
+// for the carrier decision: a NEW table, because deepagent_event_delivery models delivery lifecycle
+// only, task_admission is the subagent task_run receipt, and agent_execution never models the
+// consumer's processing/terminal admission). Forward-only: pure additive CREATE TABLE + indexes.
+export default {
+  id: "20260816000000_handoff_admission_receipt",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`deepagent_handoff_admission\` (
+          \`handoff_id\` text PRIMARY KEY NOT NULL,
+          \`event_id\` text NOT NULL,
+          \`workspace_id\` text NOT NULL,
+          \`state\` text NOT NULL,
+          \`claimant_id\` text NOT NULL,
+          \`reason\` text,
+          \`started_at\` integer NOT NULL,
+          \`updated_at\` integer NOT NULL,
+          \`settled_at\` integer
+        );
+      `)
+      yield* tx.run(`
+        CREATE INDEX IF NOT EXISTS \`deepagent_handoff_admission_workspace_state_idx\`
+        ON \`deepagent_handoff_admission\` (\`workspace_id\`, \`state\`);
+      `)
+      yield* tx.run(`
+        CREATE UNIQUE INDEX IF NOT EXISTS \`deepagent_handoff_admission_event_idx\`
+        ON \`deepagent_handoff_admission\` (\`event_id\`);
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260816073717_session_facade_activity.ts b/packages/core/src/database/migration/20260816073717_session_facade_activity.ts
new file mode 100644
index 00000000..9ac5cc91
--- /dev/null
+++ b/packages/core/src/database/migration/20260816073717_session_facade_activity.ts
@@ -0,0 +1,83 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// FEAT-011 T1 — facade activity authority schema. Forward-only and purely additive: creates
+// the new `session_facade_activity` base table and nothing else. The federation objective /
+// permission child tables keep their ('legacy', 'v2') CHECKs on purpose — they are the fence
+// that keeps the facade branch isolated from the objective/permission machinery (facade
+// settlement is raw-SQL CAS on the base table, mirroring the legacy branch).
+// The drizzle-generated CREATE TABLE/index statements below are augmented with CHECK clauses
+// and lifecycle triggers that drizzle cannot express.
+export default {
+  id: "20260816073717_session_facade_activity",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_facade_activity\` (
+          \`activity_id\` text PRIMARY KEY,
+          \`subkind\` text NOT NULL CHECK (\`subkind\` IN ('task', 'goal', 'panel')),
+          \`parent_session_id\` text NOT NULL,
+          \`owner_session_id\` text,
+          \`spawn_tool_call_id\` text,
+          \`objective_text\` text,
+          \`budget_json\` text,
+          \`state\` text NOT NULL CHECK (\`state\` IN ('active', 'settled', 'failed', 'interrupted', 'recovery_required')),
+          \`reason_code\` text,
+          \`source\` text,
+          \`created_at\` integer NOT NULL,
+          \`settled_at\` integer,
+          \`mutation_epoch\` integer NOT NULL CHECK (\`mutation_epoch\` >= 0),
+          CONSTRAINT \`fk_session_facade_activity_parent_session_id_session_id_fk\` FOREIGN KEY (\`parent_session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE,
+          CONSTRAINT \`fk_session_facade_activity_owner_session_id_session_id_fk\` FOREIGN KEY (\`owner_session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE,
+          CHECK (
+            (\`state\` = 'active' AND \`settled_at\` IS NULL AND \`reason_code\` IS NULL) OR
+            (\`state\` != 'active' AND \`settled_at\` IS NOT NULL AND \`reason_code\` IS NOT NULL)
+          )
+        );
+      `)
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_facade_activity_active_idx\` ON \`session_facade_activity\` (\`parent_session_id\`,\`subkind\`) WHERE "session_facade_activity"."state" = 'active';`)
+      yield* tx.run(`CREATE INDEX \`session_facade_activity_parent_idx\` ON \`session_facade_activity\` (\`parent_session_id\`,\`state\`,\`created_at\`);`)
+
+      // BUG-004 shape: opening a new facade activity requires settling the previous active one
+      // of the same parent+subkind first — enforced by the partial unique index above plus the
+      // single-shot active→terminal transition rule below (mirrors session_legacy_activity).
+      yield* tx.run(`
+        CREATE TRIGGER session_facade_activity_legal_update
+        BEFORE UPDATE ON session_facade_activity
+        WHEN NEW.activity_id != OLD.activity_id
+          OR NEW.subkind != OLD.subkind
+          OR NEW.parent_session_id != OLD.parent_session_id
+          OR COALESCE(NEW.owner_session_id, '') != COALESCE(OLD.owner_session_id, '')
+          OR COALESCE(NEW.spawn_tool_call_id, '') != COALESCE(OLD.spawn_tool_call_id, '')
+          OR COALESCE(NEW.objective_text, '') != COALESCE(OLD.objective_text, '')
+          OR COALESCE(NEW.budget_json, '') != COALESCE(OLD.budget_json, '')
+          OR COALESCE(NEW.source, '') != COALESCE(OLD.source, '')
+          OR NEW.created_at != OLD.created_at
+          OR OLD.state != 'active'
+          OR NEW.state NOT IN ('settled', 'failed', 'interrupted', 'recovery_required')
+          OR NEW.settled_at IS NULL
+          OR NEW.reason_code IS NULL
+        BEGIN
+          SELECT RAISE(ABORT, 'illegal session_facade_activity transition');
+        END
+      `)
+      yield* tx.run(`
+        CREATE TRIGGER session_facade_activity_permission_effect_terminal_guard
+        BEFORE UPDATE OF state ON session_facade_activity
+        WHEN NEW.state IN ('settled', 'failed', 'interrupted', 'recovery_required') AND EXISTS (
+          SELECT 1
+          FROM session_activity_permission_effect_dispatch dispatch
+          WHERE dispatch.activity_kind = 'facade'
+            AND dispatch.activity_id = OLD.activity_id
+            AND (
+              dispatch.state = 'started' OR
+              (NEW.state IN ('settled', 'interrupted') AND dispatch.state = 'unknown')
+            )
+        )
+        BEGIN
+          SELECT RAISE(ABORT, 'activity has unresolved permission effects');
+        END
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260816080000_receipt_active_pack_set_attribution.ts b/packages/core/src/database/migration/20260816080000_receipt_active_pack_set_attribution.ts
new file mode 100644
index 00000000..70c81196
--- /dev/null
+++ b/packages/core/src/database/migration/20260816080000_receipt_active_pack_set_attribution.ts
@@ -0,0 +1,24 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// FEAT-007 — attribution column for the active_pack_set snapshot locked at the run entry.
+// The receipt table lives outside the core drizzle schema (typed in deepagent-code only), so
+// this stays a hand-authored forward-only ALTER, mirroring the released_knowledge_turn_binding
+// precedent. NULL is allowed: the federation resolve result does not expose the pack snapshot
+// id, so the receipt write site records NULL until it does (never blocks admission).
+export default {
+  id: "20260816080000_receipt_active_pack_set_attribution",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        ALTER TABLE session_tool_request_receipt ADD COLUMN context_active_pack_set_snapshot_id TEXT
+        CHECK (context_active_pack_set_snapshot_id IS NULL OR context_active_pack_set_snapshot_id LIKE 'pack_snapshot:%')
+      `)
+      yield* tx.run(`
+        CREATE INDEX session_tool_request_receipt_active_pack_set_idx
+        ON session_tool_request_receipt (context_active_pack_set_snapshot_id)
+        WHERE context_active_pack_set_snapshot_id IS NOT NULL
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260816081000_session_context_reconciliation.ts b/packages/core/src/database/migration/20260816081000_session_context_reconciliation.ts
new file mode 100644
index 00000000..31e630c4
--- /dev/null
+++ b/packages/core/src/database/migration/20260816081000_session_context_reconciliation.ts
@@ -0,0 +1,49 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// FEAT-007 — durable per-turn reconciliation of federated context selections. The in-memory
+// knowledgeMemoryDelta was the only legacy-vs-projection evidence and evaporated on restart;
+// this table persists one row per federated provider turn receipt. Forward-only: pure additive
+// CREATE TABLE + indexes (hand-authored, mirroring the handoff_admission_receipt precedent —
+// the table is typed in reconciliation-sql.ts but stays outside the drizzle-managed schema).
+export default {
+  id: "20260816081000_session_context_reconciliation",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`session_context_reconciliation\` (
+          \`reconciliation_id\` text PRIMARY KEY NOT NULL,
+          \`session_id\` text NOT NULL REFERENCES \`session\`(\`id\`) ON DELETE CASCADE,
+          \`activity_id\` text NOT NULL REFERENCES \`session_activity\`(\`activity_id\`) ON DELETE CASCADE,
+          \`turn_receipt_id\` text NOT NULL,
+          \`selection_id\` text,
+          \`legacy_refs_fingerprint\` text
+          CHECK (\`legacy_refs_fingerprint\` IS NULL OR (
+            length(\`legacy_refs_fingerprint\`) = 64 AND
+            \`legacy_refs_fingerprint\` NOT GLOB '*[^0-9a-f]*'
+          )),
+          \`projection_refs_fingerprint\` text NOT NULL
+          CHECK (
+            length(\`projection_refs_fingerprint\`) = 64 AND
+            \`projection_refs_fingerprint\` NOT GLOB '*[^0-9a-f]*'
+          ),
+          \`outcome\` text NOT NULL,
+          \`diff_summary\` text NOT NULL
+          CHECK (
+            json_valid(\`diff_summary\`) = 1 AND
+            json_type(\`diff_summary\`) = 'object'
+          ),
+          \`created_at\` integer NOT NULL
+        );
+      `)
+      yield* tx.run(`
+        CREATE UNIQUE INDEX IF NOT EXISTS \`session_context_reconciliation_receipt_idx\`
+        ON \`session_context_reconciliation\` (\`turn_receipt_id\`);
+      `)
+      yield* tx.run(`
+        CREATE INDEX IF NOT EXISTS \`session_context_reconciliation_session_idx\`
+        ON \`session_context_reconciliation\` (\`session_id\`, \`created_at\`);
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260819120000_session_intent_confirmation_state.ts b/packages/core/src/database/migration/20260819120000_session_intent_confirmation_state.ts
new file mode 100644
index 00000000..7dbca4cd
--- /dev/null
+++ b/packages/core/src/database/migration/20260819120000_session_intent_confirmation_state.ts
@@ -0,0 +1,253 @@
+/**
+ * BUG-405-003 residual P1: fold `awaiting_confirmation` and `selected` into the durable
+ * session_intent state contract (docs/bug-405-003.md §12.1).
+ *
+ * state = preparing | awaiting_confirmation | selected | admitting |
+ *         admitted | canceled | superseded | failed
+ *
+ * SQLite cannot alter a CHECK constraint in place, so session_intent must be rebuilt.
+ * session_activity_admission.legacy_intent_id references session_intent, and with
+ * PRAGMA foreign_keys enabled (runtime connection) dropping the parent table performs an
+ * implicit DELETE that fails on the referencing admission rows. The whole legacy activity
+ * chain (admission -> legacy_activity -> {admission membership, progress, run, terminal,
+ * migration receipt}) is therefore detached into temp backups first — the same strategy
+ * used by 20260812120000_legacy_provider_recovery — then rebuilt and restored verbatim.
+ *
+ * The detached tables are recreated from their captured sqlite_master definitions (not
+ * hardcoded final shapes) because merged-lineage histories can reach this migration before
+ * 20260812120000/20260812130000 are applied; later authorities must still find the exact
+ * shapes they expect to ALTER or rebuild. Triggers are recreated after the data restore so
+ * restore statements cannot fire validation or projection side effects (e.g. duplicate
+ * session_activity_objective rows).
+ */
+
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+const LEGACY_STATE_CHECK =
+  "CHECK (state IN ('preparing', 'admitting', 'admitted', 'canceled', 'superseded', 'failed'))"
+const WIDENED_STATE_CHECK =
+  "CHECK (state IN ('preparing', 'awaiting_confirmation', 'selected', 'admitting', 'admitted', 'canceled', 'superseded', 'failed'))"
+
+export default {
+  id: "20260819120000_session_intent_confirmation_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      const has = (table: string) =>
+        Effect.gen(function* () {
+          return Boolean(
+            yield* tx.get(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = '${table}'`),
+          )
+        })
+      const ddlOf = (type: string, name: string) =>
+        Effect.gen(function* () {
+          const row = yield* tx.get<{ sql: string }>(
+            `SELECT sql FROM sqlite_master WHERE type = '${type}' AND name = '${name}'`,
+          )
+          return row!.sql
+        })
+
+      const hasAdmission = yield* has("session_activity_admission")
+      const hasLegacyActivity = yield* has("session_legacy_activity")
+      const hasAdmissionJoin = yield* has("session_legacy_activity_admission")
+      const hasProgress = yield* has("session_activity_progress")
+      const hasRun = yield* has("session_legacy_activity_run")
+      const hasTerminal = yield* has("session_legacy_activity_terminal")
+      const hasMigrationReceipt = yield* has("session_legacy_activity_migration_receipt")
+
+      // Merged-lineage histories may not have applied the execution-identity expansion yet.
+      const intentColumns = yield* tx.all<{ name: string }>(`PRAGMA table_info(session_intent)`)
+      const hasExecutionColumns = intentColumns.some((column) => column.name === "execution_mode")
+      const intentDDL = yield* ddlOf("table", "session_intent")
+      const intentIndexes = yield* tx.all<{ sql: string }>(`
+        SELECT sql FROM sqlite_master
+        WHERE type = 'index' AND tbl_name = 'session_intent'
+          AND sql IS NOT NULL AND name NOT LIKE 'sqlite_%'
+      `)
+
+      // Captured current shapes of the detached chain (recreated verbatim later).
+      const chainTables: Array<{ name: string; sql: string }> = []
+      if (hasAdmission) chainTables.push({ name: "session_activity_admission", sql: yield* ddlOf("table", "session_activity_admission") })
+      if (hasLegacyActivity) chainTables.push({ name: "session_legacy_activity", sql: yield* ddlOf("table", "session_legacy_activity") })
+      if (hasAdmissionJoin) chainTables.push({ name: "session_legacy_activity_admission", sql: yield* ddlOf("table", "session_legacy_activity_admission") })
+      if (hasProgress) chainTables.push({ name: "session_activity_progress", sql: yield* ddlOf("table", "session_activity_progress") })
+      if (hasRun) chainTables.push({ name: "session_legacy_activity_run", sql: yield* ddlOf("table", "session_legacy_activity_run") })
+      if (hasTerminal) chainTables.push({ name: "session_legacy_activity_terminal", sql: yield* ddlOf("table", "session_legacy_activity_terminal") })
+      if (hasMigrationReceipt) chainTables.push({ name: "session_legacy_activity_migration_receipt", sql: yield* ddlOf("table", "session_legacy_activity_migration_receipt") })
+      const chainTableNames = chainTables.map((table) => `'${table.name}'`).join(", ")
+      const chainIndexes = chainTableNames.length
+        ? yield* tx.all<{ tbl_name: string; sql: string }>(`
+            SELECT tbl_name, sql FROM sqlite_master
+            WHERE type = 'index' AND tbl_name IN (${chainTableNames})
+              AND sql IS NOT NULL AND name NOT LIKE 'sqlite_%'
+          `)
+        : []
+      const chainTriggers = chainTableNames.length
+        ? yield* tx.all<{ sql: string }>(`
+            SELECT sql FROM sqlite_master
+            WHERE type = 'trigger' AND tbl_name IN (${chainTableNames}) AND sql IS NOT NULL
+          `)
+        : []
+
+      // ── Detach the FK children of session_intent into transaction-local backups ──
+      if (hasMigrationReceipt)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_migration_receipt AS
+          SELECT * FROM session_legacy_activity_migration_receipt
+        `)
+      if (hasTerminal)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_terminal AS
+          SELECT * FROM session_legacy_activity_terminal
+        `)
+      if (hasRun)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_run AS
+          SELECT * FROM session_legacy_activity_run
+        `)
+      if (hasAdmissionJoin)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_admission_join AS
+          SELECT * FROM session_legacy_activity_admission
+        `)
+      if (hasProgress)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_progress AS
+          SELECT * FROM session_activity_progress
+        `)
+      if (hasLegacyActivity)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_activity AS
+          SELECT * FROM session_legacy_activity
+        `)
+      if (hasAdmission)
+        yield* tx.run(`
+          CREATE TEMP TABLE intent_state_backup_admission AS
+          SELECT * FROM session_activity_admission
+        `)
+
+      // Children first so each drop only removes rows of the table itself.
+      if (hasMigrationReceipt) yield* tx.run(`DROP TABLE session_legacy_activity_migration_receipt`)
+      if (hasTerminal) yield* tx.run(`DROP TABLE session_legacy_activity_terminal`)
+      if (hasRun) yield* tx.run(`DROP TABLE session_legacy_activity_run`)
+      if (hasAdmissionJoin) yield* tx.run(`DROP TABLE session_legacy_activity_admission`)
+      if (hasProgress) yield* tx.run(`DROP TABLE session_activity_progress`)
+      if (hasLegacyActivity) yield* tx.run(`DROP TABLE session_legacy_activity`)
+      if (hasAdmission) yield* tx.run(`DROP TABLE session_activity_admission`)
+
+      // ── Rebuild session_intent with the BUG-405-003 §12.1 state contract ──
+      // Only the state CHECK changes; every other column definition is preserved verbatim so
+      // histories lacking the execution-identity columns can still receive them later.
+      const rebuiltDDL = intentDDL
+        .replace("CREATE TABLE session_intent", "CREATE TABLE session_intent_rebuilt")
+        .replace(LEGACY_STATE_CHECK, WIDENED_STATE_CHECK)
+      yield* tx.run(rebuiltDDL)
+      const columnNames = intentColumns.map((column) => column.name).join(", ")
+      yield* tx.run(`
+        INSERT INTO session_intent_rebuilt (${columnNames})
+        SELECT ${columnNames} FROM session_intent
+      `)
+      yield* tx.run(`DROP TABLE session_intent`)
+      // SQLite >= 3.25 rewrites referencing trigger/view bodies during RENAME when foreign_keys
+      // is ON; triggers on OTHER tables (e.g. session_tool_request_resolution_validate_insert)
+      // reference the still-dropped legacy chain at this point and make the rewrite fail
+      // ("no such table: main.session_activity_progress"). The rename target is the same name as
+      // the original table, so no reference rewrite is needed — use the legacy behavior for this
+      // single statement. The desktop runtime (node:sqlite, SQLite 3.51) hits this; bun:sqlite's
+      // older engine does not, which is why tests and bun-driven drills were green.
+      yield* tx.run(`PRAGMA legacy_alter_table = ON`)
+      yield* tx.run(`ALTER TABLE session_intent_rebuilt RENAME TO session_intent`)
+      yield* tx.run(`PRAGMA legacy_alter_table = OFF`)
+      for (const index of intentIndexes) yield* tx.run(index.sql)
+      if (hasExecutionColumns) {
+        yield* tx.run(`
+          CREATE TRIGGER session_intent_execution_validate_insert
+          BEFORE INSERT ON session_intent
+          WHEN NOT (
+            (NEW.execution_mode = 'legacy' AND NEW.execution_state = 'legacy'
+              AND NEW.execution_claim_id IS NULL AND NEW.execution_claimed_at IS NULL) OR
+            (NEW.execution_mode IN ('run_now','deferred') AND NEW.execution_state = 'pending'
+              AND NEW.execution_claim_id IS NULL AND NEW.execution_claimed_at IS NULL) OR
+            (NEW.execution_mode IN ('run_now','deferred') AND NEW.execution_state = 'claimed'
+              AND NEW.execution_claim_id IS NOT NULL AND NEW.execution_claimed_at IS NOT NULL) OR
+            (NEW.execution_mode = 'deferred' AND NEW.execution_state = 'absorbed'
+              AND NEW.execution_claim_id IS NOT NULL AND NEW.execution_claimed_at IS NOT NULL) OR
+            (NEW.execution_mode IN ('run_now','deferred') AND NEW.execution_state = 'canceled'
+              AND NEW.execution_claim_id IS NULL AND NEW.execution_claimed_at IS NULL)
+          )
+          BEGIN
+            SELECT RAISE(ABORT, 'invalid session intent execution identity');
+          END
+        `)
+        yield* tx.run(`
+          CREATE TRIGGER session_intent_execution_validate_update
+          BEFORE UPDATE ON session_intent
+          WHEN NOT (
+            (NEW.execution_mode = 'legacy' AND NEW.execution_state = 'legacy'
+              AND NEW.execution_claim_id IS NULL AND NEW.execution_claimed_at IS NULL) OR
+            (NEW.execution_mode IN ('run_now','deferred') AND NEW.execution_state = 'pending'
+              AND NEW.execution_claim_id IS NULL AND NEW.execution_claimed_at IS NULL) OR
+            (NEW.execution_mode IN ('run_now','deferred') AND NEW.execution_state = 'claimed'
+              AND NEW.execution_claim_id IS NOT NULL AND NEW.execution_claimed_at IS NOT NULL) OR
+            (NEW.execution_mode = 'deferred' AND NEW.execution_state = 'absorbed'
+              AND NEW.execution_claim_id IS NOT NULL AND NEW.execution_claimed_at IS NOT NULL) OR
+            (NEW.execution_mode IN ('run_now','deferred') AND NEW.execution_state = 'canceled'
+              AND NEW.execution_claim_id IS NULL AND NEW.execution_claimed_at IS NULL)
+          ) OR NOT (
+            (NEW.execution_mode = OLD.execution_mode AND NEW.execution_state = OLD.execution_state
+              AND NEW.execution_claim_id IS OLD.execution_claim_id
+              AND NEW.execution_claimed_at IS OLD.execution_claimed_at) OR
+            (OLD.execution_state = 'pending' AND NEW.execution_mode = OLD.execution_mode
+              AND NEW.execution_state IN ('claimed','absorbed','canceled')) OR
+            (OLD.execution_mode = 'legacy' AND OLD.execution_state = 'legacy'
+              AND NEW.execution_mode IN ('run_now','deferred')
+              AND NEW.execution_state IN ('pending','claimed','absorbed','canceled'))
+          )
+          BEGIN
+            SELECT RAISE(ABORT, 'illegal session intent execution transition');
+          END
+        `)
+      }
+
+      // ── Recreate the detached chain with its captured definitions, then restore data ──
+      // Each table's indexes are recreated immediately after the table itself: child tables
+      // resolve FK parents through explicit unique indexes (e.g. terminal.operation_id), so
+      // those indexes must exist before the referencing child CREATE TABLE is prepared.
+      // Restores are positional (SELECT *) because the captured shapes may differ between
+      // merged-lineage and full histories (e.g. execution_mode may not exist yet).
+      for (const table of chainTables) {
+        yield* tx.run(table.sql)
+        for (const index of chainIndexes) if (index.tbl_name === table.name) yield* tx.run(index.sql)
+      }
+      if (hasAdmission)
+        yield* tx.run(`INSERT INTO session_activity_admission SELECT * FROM intent_state_backup_admission`)
+      if (hasLegacyActivity)
+        yield* tx.run(`INSERT INTO session_legacy_activity SELECT * FROM intent_state_backup_activity`)
+      if (hasAdmissionJoin)
+        yield* tx.run(`INSERT INTO session_legacy_activity_admission SELECT * FROM intent_state_backup_admission_join`)
+      if (hasProgress)
+        yield* tx.run(`INSERT INTO session_activity_progress SELECT * FROM intent_state_backup_progress`)
+      if (hasRun)
+        yield* tx.run(`INSERT INTO session_legacy_activity_run SELECT * FROM intent_state_backup_run`)
+      if (hasTerminal)
+        yield* tx.run(`INSERT INTO session_legacy_activity_terminal SELECT * FROM intent_state_backup_terminal`)
+      if (hasMigrationReceipt)
+        yield* tx.run(
+          `INSERT INTO session_legacy_activity_migration_receipt SELECT * FROM intent_state_backup_migration_receipt`,
+        )
+
+      // ── Recreate triggers only after the data restore so no validation or projection
+      //    side effects fire for rows that already existed before this migration ──
+      for (const trigger of chainTriggers) yield* tx.run(trigger.sql)
+
+      // ── Drop the transaction-local backups ──
+      if (hasMigrationReceipt) yield* tx.run(`DROP TABLE intent_state_backup_migration_receipt`)
+      if (hasTerminal) yield* tx.run(`DROP TABLE intent_state_backup_terminal`)
+      if (hasRun) yield* tx.run(`DROP TABLE intent_state_backup_run`)
+      if (hasAdmissionJoin) yield* tx.run(`DROP TABLE intent_state_backup_admission_join`)
+      if (hasProgress) yield* tx.run(`DROP TABLE intent_state_backup_progress`)
+      if (hasLegacyActivity) yield* tx.run(`DROP TABLE intent_state_backup_activity`)
+      if (hasAdmission) yield* tx.run(`DROP TABLE intent_state_backup_admission`)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260820000000_remote_compact_persistence.ts b/packages/core/src/database/migration/20260820000000_remote_compact_persistence.ts
new file mode 100644
index 00000000..3ce511f2
--- /dev/null
+++ b/packages/core/src/database/migration/20260820000000_remote_compact_persistence.ts
@@ -0,0 +1,86 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// UPD-005 (server-side compaction, Gap 1 + Gap 2) — persistence for the opaque
+// `encrypted_content` returned by `/responses/compact`, plus the mode columns on
+// compaction_run.
+//
+// Gap 1: `session_compaction_encrypted_content` holds the ONE currently-valid blob
+// per session (1:1, latest wins via ON CONFLICT(session_id) DO UPDATE at the write
+// site). The blob is cross-run / session-scoped — it is sent back on the NEXT
+// compaction so the provider can expand it — hence an independent table rather than
+// a compaction_run column. `provider_id` is recorded so the read path can verify
+// same-provenance before replaying a blob (a provider switch invalidates it).
+// Cleanup: session deletion cascades; the fail-over path clears explicitly.
+//
+// Gap 2: compaction_run gains `compaction_mode` ('local_summary' — the default and
+// the only value historical rows ever carry — | 'remote_compact') and
+// `encrypted_content_session` (remote mode only: pointer to the blob row). Remote
+// runs commit with `summary_text` NULL by design: losslessness is guaranteed by the
+// provider's encrypted context, not by text, and the information-hole check exempts
+// this mode.
+//
+// Forward-only: additive table + two ALTER ADD COLUMN statements; no existing data
+// is touched. Existing compaction_run rows read back as 'local_summary'.
+//
+// The authority trigger is rebuilt (same name, same state machine) so a
+// 'remote_compact' run may reach 'committed' without the TEXT-summary binding
+// columns: losslessness for remote runs is guaranteed by the provider's encrypted
+// context (see the information-hole exemption on the read path), not by
+// summary_text. local_summary runs keep the exact previous commit binding check.
+export default {
+  id: "20260820000000_remote_compact_persistence",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE session_compaction_encrypted_content (
+          session_id        TEXT NOT NULL PRIMARY KEY REFERENCES session(id) ON DELETE CASCADE,
+          encrypted_content TEXT NOT NULL,
+          provider_id       TEXT NOT NULL,
+          model_id          TEXT,
+          source_run_id     TEXT,
+          created_at        INTEGER NOT NULL,
+          updated_at        INTEGER NOT NULL
+        )
+      `)
+      yield* tx.run(`
+        ALTER TABLE compaction_run ADD COLUMN compaction_mode TEXT NOT NULL DEFAULT 'local_summary'
+        CHECK (compaction_mode IN ('local_summary', 'remote_compact'))
+      `)
+      yield* tx.run(`
+        ALTER TABLE compaction_run ADD COLUMN encrypted_content_session TEXT
+      `)
+      // Rebuild the update authority trigger: identical transitions
+      // (requested → summarizing → committed|failed|indeterminate), but the commit
+      // binding check no longer applies to remote_compact runs, which commit with
+      // summary_text NULL and the encrypted_content pointer instead.
+      yield* tx.run("DROP TRIGGER compaction_run_authority_validate_update")
+      yield* tx.run(`
+        CREATE TRIGGER compaction_run_authority_validate_update
+        BEFORE UPDATE ON compaction_run
+        BEGIN
+          SELECT CASE WHEN NOT (
+            NEW.state = OLD.state OR
+            (OLD.state = 'requested' AND NEW.state IN ('summarizing', 'failed', 'indeterminate')) OR
+            (OLD.state = 'summarizing' AND NEW.state IN ('committed', 'failed', 'indeterminate'))
+          ) THEN RAISE(ABORT, 'compaction_run_invalid_state_transition') END;
+          SELECT CASE WHEN NEW.state IN ('failed', 'indeterminate') AND NEW.terminal_failure_kind IS NULL
+            THEN RAISE(ABORT, 'compaction_run_terminal_failure_without_reason') END;
+          SELECT CASE WHEN OLD.state != 'committed' AND NEW.state = 'committed'
+            AND NEW.compaction_mode != 'remote_compact'
+            AND (
+            NEW.target_prompt_epoch IS NULL OR NEW.committed_summary_message_id IS NULL OR
+            NEW.checkpoint_hash IS NULL OR NEW.summary_text IS NULL OR NEW.recent_context IS NULL OR
+            NEW.completion_reason IS NULL OR NEW.committed_at IS NULL
+          ) THEN RAISE(ABORT, 'compaction_run_commit_binding_incomplete') END;
+          SELECT CASE WHEN OLD.state != 'committed' AND NEW.state = 'committed'
+            AND NEW.compaction_mode = 'remote_compact'
+            AND (
+            NEW.encrypted_content_session IS NULL OR
+            NEW.completion_reason IS NULL OR NEW.committed_at IS NULL
+          ) THEN RAISE(ABORT, 'compaction_run_commit_binding_incomplete') END;
+        END
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260820120000_session_turn_stage_evidence.ts b/packages/core/src/database/migration/20260820120000_session_turn_stage_evidence.ts
new file mode 100644
index 00000000..1bc9b5bd
--- /dev/null
+++ b/packages/core/src/database/migration/20260820120000_session_turn_stage_evidence.ts
@@ -0,0 +1,39 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// BUG-407-012 gap C: durable per-turn stage evidence.
+// One row per (session_id, activity_id), upserted forward-only as a provider turn
+// crosses each boundary (claim -> snapshot -> history -> request -> dispatch -> settle).
+// It exists so a turn stuck between "legacy activity claimed" and "provider receipt
+// created" can be attributed post-hoc; it is observability evidence, NOT an authority.
+export default {
+  id: "20260820120000_session_turn_stage_evidence",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE session_turn_stage_evidence (
+          session_id  TEXT NOT NULL REFERENCES session(id) ON DELETE CASCADE,
+          activity_id TEXT NOT NULL,
+          stage       TEXT NOT NULL CHECK (stage IN (
+            'activity_claimed',
+            'snapshot_started',
+            'snapshot_finished',
+            'snapshot_degraded',
+            'history_loaded',
+            'request_prepared',
+            'provider_dispatch_started',
+            'terminal_settled'
+          )),
+          details     TEXT,       -- JSON stage attribution (e.g. degraded reason, budget numbers)
+          stage_at    INTEGER NOT NULL,
+          updated_at  INTEGER NOT NULL,
+          PRIMARY KEY (session_id, activity_id)
+        )
+      `)
+      yield* tx.run(
+        `CREATE INDEX session_turn_stage_evidence_session_idx
+           ON session_turn_stage_evidence(session_id, updated_at)`,
+      )
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/database/migration/20260820130000_compaction_continuation_fail_closed.ts b/packages/core/src/database/migration/20260820130000_compaction_continuation_fail_closed.ts
new file mode 100644
index 00000000..4b79bd60
--- /dev/null
+++ b/packages/core/src/database/migration/20260820130000_compaction_continuation_fail_closed.ts
@@ -0,0 +1,67 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+// BUG-407-009 §10.1 fail-closed path for committed compaction continuations whose recovery
+// cannot proceed (e.g. the incident sessions have no assistant message for the v2 owner to
+// continue from). The original continuation state machine only allowed pending → admitted, and
+// the admission bindings (receipt id / admitted_at / response fingerprint) cannot exist for a
+// run that never reached admission — so recovery failures could not be recorded, and instance
+// initialization re-woke the same runs forever (log flood, endless retry loop).
+//
+// This migration widens the machine with one transition: pending → failed, exempt from the
+// admission/response binding requirements. Real continuation recovery remains a Maintenance
+// deliverable; this only makes the hotfix fail closed and stop re-advertising the run.
+
+export default {
+  id: "20260820130000_compaction_continuation_fail_closed",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TRIGGER compaction_run_continuation_transition`)
+      yield* tx.run(`
+        CREATE TRIGGER compaction_run_continuation_transition
+        BEFORE UPDATE OF continuation_state ON compaction_run
+        WHEN OLD.continuation_state IS NOT NEW.continuation_state AND NOT (
+          (OLD.continuation_state IS NULL AND NEW.continuation_state = 'pending') OR
+          (OLD.continuation_state = 'pending' AND NEW.continuation_state IN ('admitted', 'failed')) OR
+          (OLD.continuation_state = 'admitted' AND NEW.continuation_state IN ('pending', 'dispatching', 'failed')) OR
+          (OLD.continuation_state = 'dispatching' AND NEW.continuation_state IN ('settled', 'failed', 'indeterminate'))
+        )
+        BEGIN
+          SELECT RAISE(ABORT, 'illegal compaction continuation transition');
+        END
+      `)
+      yield* tx.run(`DROP TRIGGER compaction_run_continuation_binding_validate`)
+      yield* tx.run(`
+        CREATE TRIGGER compaction_run_continuation_binding_validate
+        BEFORE UPDATE ON compaction_run
+        WHEN NOT (OLD.continuation_state = 'pending' AND NEW.continuation_state = 'failed') AND (
+          (NEW.continuation_state IN ('admitted', 'dispatching', 'settled', 'failed', 'indeterminate') AND
+            (NEW.continuation_receipt_id IS NULL OR NEW.continuation_admitted_at IS NULL)) OR
+          (NEW.continuation_state IN ('dispatching', 'settled', 'failed', 'indeterminate') AND
+            NEW.continuation_dispatching_at IS NULL AND NEW.continuation_state != 'failed') OR
+          (NEW.continuation_state IN ('settled', 'failed', 'indeterminate') AND
+            NEW.continuation_terminal_at IS NULL)
+        )
+        BEGIN
+          SELECT RAISE(ABORT, 'incomplete compaction continuation binding');
+        END
+      `)
+      yield* tx.run(`DROP TRIGGER compaction_run_continuation_response_validate`)
+      yield* tx.run(`
+        CREATE TRIGGER compaction_run_continuation_response_validate
+        BEFORE UPDATE OF continuation_state ON compaction_run
+        WHEN NEW.continuation_state IN ('settled', 'failed')
+          AND NOT (OLD.continuation_state = 'pending' AND NEW.continuation_state = 'failed')
+          AND NOT EXISTS (
+            SELECT 1
+            FROM session_tool_request_receipt receipt
+            WHERE receipt.receipt_id = NEW.continuation_receipt_id
+              AND receipt.response_fingerprint IS NOT NULL
+          )
+        BEGIN
+          SELECT RAISE(ABORT, 'compaction continuation response is not durable');
+        END
+      `)
+    })
+  },
+} satisfies DatabaseMigration.Migration
diff --git a/packages/core/src/deepagent/activity-authority.sql.ts b/packages/core/src/deepagent/activity-authority.sql.ts
index f522b63c..4e55bcae 100644
--- a/packages/core/src/deepagent/activity-authority.sql.ts
+++ b/packages/core/src/deepagent/activity-authority.sql.ts
@@ -6,7 +6,9 @@ import { SessionTable } from "../session/sql"
 import type { SessionSchema } from "../session/schema"
 import type { CompletionCriterion } from "./goal-loop"
 
-export type ActivityKind = "legacy" | "v2"
+export type ActivityKind = "legacy" | "v2" | "facade"
+export type FacadeActivitySubkind = "task" | "goal" | "panel"
+export type FacadeActivityState = "active" | "settled" | "failed" | "interrupted" | "recovery_required"
 export type ActivityObjectiveState = "active" | "completed" | "needs_human" | "interrupted" | "recovery_required"
 export type PermissionRequestState =
   | "pending"
@@ -49,6 +51,40 @@ export const SessionActivityObjectiveTable = sqliteTable(
   ],
 )
 
+// FEAT-011 T1 — facade activity base table. Mirrors the session_legacy_activity terminal
+// semantics (active carries no settled_at/reason_code; terminal states require both) and the
+// v2 single-active invariant, scoped per parent session + subkind: opening a new facade
+// activity requires settling the previous active one of the same subkind first (BUG-004).
+export const SessionFacadeActivityTable = sqliteTable(
+  "session_facade_activity",
+  {
+    activity_id: text().primaryKey(),
+    subkind: text().$type<FacadeActivitySubkind>().notNull(),
+    parent_session_id: text()
+      .$type<SessionSchema.ID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    owner_session_id: text()
+      .$type<SessionSchema.ID>()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    spawn_tool_call_id: text(),
+    objective_text: text(),
+    budget_json: text({ mode: "json" }).$type<unknown>(),
+    state: text().$type<FacadeActivityState>().notNull(),
+    reason_code: text(),
+    source: text(),
+    created_at: integer().notNull(),
+    settled_at: integer(),
+    mutation_epoch: integer().notNull(),
+  },
+  (table) => [
+    uniqueIndex("session_facade_activity_active_idx")
+      .on(table.parent_session_id, table.subkind)
+      .where(sql`${table.state} = 'active'`),
+    index("session_facade_activity_parent_idx").on(table.parent_session_id, table.state, table.created_at),
+  ],
+)
+
 export const SessionActivityEvidenceTable = sqliteTable(
   "session_activity_evidence",
   {
diff --git a/packages/core/src/deepagent/activity-authority.ts b/packages/core/src/deepagent/activity-authority.ts
index 0203293c..37de3b97 100644
--- a/packages/core/src/deepagent/activity-authority.ts
+++ b/packages/core/src/deepagent/activity-authority.ts
@@ -23,6 +23,7 @@ import {
   SessionActivityPermissionOnceConsumptionTable,
   SessionActivityPermissionRequestTable,
   SessionActivityProgressObservationTable,
+  SessionFacadeActivityTable,
 } from "./activity-authority.sql"
 
 type DatabaseClient = Database.Interface["db"]
@@ -119,7 +120,7 @@ export type Reconstructed = {
 }
 
 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("ActivityAuthority.NotFoundError", {
-  activityKind: Schema.Literals(["legacy", "v2"]),
+  activityKind: Schema.Literals(["legacy", "v2", "facade"]),
   activityID: Schema.String,
 }) {}
 
@@ -446,6 +447,11 @@ export const settle = Effect.fn("DeepAgentActivityAuthority.settle")(function* (
     .transaction(
       (tx) =>
         Effect.gen(function* () {
+          // FEAT-011 T2 — facade activities are fully isolated from the federation objective
+          // machinery (the objective/permission child tables keep ('legacy','v2') CHECKs), so
+          // settlement is raw CAS on the facade base table keyed by activity_id, mirroring the
+          // legacy branch shape. expectedVersion is the mutation_epoch CAS token.
+          if (input.activityKind === "facade") return yield* settleFacade(tx, input)
           const current = yield* tx.select().from(SessionActivityObjectiveTable).where(activityWhere(input)).get()
           if (!current) return yield* notFound(input)
           if (
@@ -539,6 +545,87 @@ export const settle = Effect.fn("DeepAgentActivityAuthority.settle")(function* (
     .pipe(Effect.catchTag("EffectDrizzleQueryError", Effect.die), Effect.catchTag("SqlError", Effect.die))
 })
 
+// FEAT-011 T2 — facade settlement path. Facade activities never own a federation objective
+// row (the objective/permission child tables keep ('legacy','v2') CHECKs by design), so this
+// settles the facade base table directly with a CAS keyed by activity_id. Three-state mapping
+// mirrors the v2 branch: completed→'settled', interrupted→'interrupted', and
+// recovery_required→'failed' — the facade base has no recovery_required shape of its own, so a
+// recovery-required settlement is persisted as base state 'failed' (same modeling as the v2
+// federation base, where 'failed' means recovery is required). expectedVersion is the
+// mutation_epoch CAS token; the base legal-update trigger additionally enforces the one-shot
+// active→terminal transition with reason_code + settled_at.
+function settleFacade(
+  tx: Transaction,
+  input: ActivityRef & {
+    readonly expectedVersion: number
+    readonly state: "completed" | "interrupted" | "recovery_required"
+    readonly terminalReason: string
+  },
+) {
+  return Effect.gen(function* () {
+    const current = yield* tx
+      .select()
+      .from(SessionFacadeActivityTable)
+      .where(eq(SessionFacadeActivityTable.activity_id, input.activityID))
+      .get()
+    if (!current) return yield* notFound(input)
+    const baseState = input.state === "completed" ? "settled" : input.state === "recovery_required" ? "failed" : "interrupted"
+    const mapped = facadeObjective(current, input.state)
+    if (current.state === baseState && current.reason_code === input.terminalReason && current.settled_at !== null)
+      return mapped
+    if (current.mutation_epoch !== input.expectedVersion)
+      return yield* versionConflict(input.activityID, input.expectedVersion, current.mutation_epoch)
+    if (current.state !== "active")
+      return yield* new ConflictError({ entity: input.activityID, expected: "active", actual: current.state })
+    const now = yield* observedAtInTransaction(tx)
+    const updated = yield* tx
+      .update(SessionFacadeActivityTable)
+      .set({
+        state: baseState,
+        reason_code: input.terminalReason,
+        settled_at: now,
+        mutation_epoch: sql`${SessionFacadeActivityTable.mutation_epoch} + 1`,
+      })
+      .where(
+        and(
+          eq(SessionFacadeActivityTable.activity_id, input.activityID),
+          eq(SessionFacadeActivityTable.state, "active"),
+          eq(SessionFacadeActivityTable.mutation_epoch, input.expectedVersion),
+        ),
+      )
+      .returning()
+      .get()
+    if (!updated) return yield* versionConflict(input.activityID, input.expectedVersion, current.mutation_epoch)
+    return facadeObjective(updated, input.state)
+  })
+}
+
+// Projects a facade base row as the Objective shape settle callers expect (facade activities
+// carry no objective row). version maps mutation_epoch; settlement state maps back from the
+// base shape ('settled'→completed, 'failed'→recovery_required, otherwise as-is).
+function facadeObjective(
+  row: typeof SessionFacadeActivityTable.$inferSelect,
+  state: ActivityObjectiveState,
+): Objective {
+  return {
+    activityKind: "facade",
+    activityID: row.activity_id,
+    sessionID: row.parent_session_id,
+    version: row.mutation_epoch,
+    admissionFingerprint: "facade-spawn:" + (row.spawn_tool_call_id ?? row.activity_id),
+    ...(row.objective_text ? { objectiveText: row.objective_text } : {}),
+    completionCriteria: [],
+    enforcementState: "disabled",
+    state,
+    noProgressCount: 0,
+    latestObservationRevision: -1,
+    ...(row.reason_code ? { terminalReason: row.reason_code } : {}),
+    createdAt: row.created_at,
+    updatedAt: row.settled_at ?? row.created_at,
+    ...(row.settled_at !== null ? { settledAt: row.settled_at } : {}),
+  }
+}
+
 export const reconstruct = Effect.fn("DeepAgentActivityAuthority.reconstruct")(function* (input: ActivityRef) {
   const { db } = yield* Database.Service
   const row = yield* db
@@ -812,11 +899,17 @@ const decidePermissionInternal = Effect.fn("DeepAgentActivityAuthority.decidePer
                 ? yield* tx.get<{ state: string }>(sql`
                     SELECT state FROM session_legacy_activity WHERE activity_id = ${request.activity_id}
                   `)
-                : yield* tx
-                    .select({ state: SessionActivityTable.state })
-                    .from(SessionActivityTable)
-                    .where(eq(SessionActivityTable.activity_id, request.activity_id))
-                    .get()
+                : request.activity_kind === "facade"
+                  ? yield* tx
+                      .select({ state: SessionFacadeActivityTable.state })
+                      .from(SessionFacadeActivityTable)
+                      .where(eq(SessionFacadeActivityTable.activity_id, request.activity_id))
+                      .get()
+                  : yield* tx
+                      .select({ state: SessionActivityTable.state })
+                      .from(SessionActivityTable)
+                      .where(eq(SessionActivityTable.activity_id, request.activity_id))
+                      .get()
             if (objective?.state !== "active" || base?.state !== "active")
               return yield* new ConflictError({
                 entity: request.activity_id,
@@ -981,17 +1074,30 @@ const decidePermissionInternal = Effect.fn("DeepAgentActivityAuthority.decidePer
                       WHERE activity_id = ${request.activity_id} AND state = 'active'
                       RETURNING activity_id
                     `)
-                  : yield* tx
-                      .update(SessionActivityTable)
-                      .set({ state: "interrupted", settled_at: now })
-                      .where(
-                        and(
-                          eq(SessionActivityTable.activity_id, request.activity_id),
-                          eq(SessionActivityTable.state, "active"),
-                        ),
-                      )
-                      .returning({ activityID: SessionActivityTable.activity_id })
-                      .get()
+                  : request.activity_kind === "facade"
+                    ? // FEAT-011 T2 — facade interruption mirrors the v2 branch (CAS on active).
+                      yield* tx
+                        .update(SessionFacadeActivityTable)
+                        .set({ state: "interrupted", reason_code: terminalReason, settled_at: now })
+                        .where(
+                          and(
+                            eq(SessionFacadeActivityTable.activity_id, request.activity_id),
+                            eq(SessionFacadeActivityTable.state, "active"),
+                          ),
+                        )
+                        .returning({ activityID: SessionFacadeActivityTable.activity_id })
+                        .get()
+                    : yield* tx
+                        .update(SessionActivityTable)
+                        .set({ state: "interrupted", settled_at: now })
+                        .where(
+                          and(
+                            eq(SessionActivityTable.activity_id, request.activity_id),
+                            eq(SessionActivityTable.state, "active"),
+                          ),
+                        )
+                        .returning({ activityID: SessionActivityTable.activity_id })
+                        .get()
               if (!base)
                 return yield* new ConflictError({
                   entity: request.activity_id,
@@ -1326,11 +1432,17 @@ export const consumeOnce = Effect.fn("DeepAgentActivityAuthority.consumeOnce")(f
               ? yield* tx.get<{ state: string }>(sql`
                   SELECT state FROM session_legacy_activity WHERE activity_id = ${request.activity_id}
                 `)
-              : yield* tx
-                  .select({ state: SessionActivityTable.state })
-                  .from(SessionActivityTable)
-                  .where(eq(SessionActivityTable.activity_id, request.activity_id))
-                  .get()
+              : request.activity_kind === "facade"
+                ? yield* tx
+                    .select({ state: SessionFacadeActivityTable.state })
+                    .from(SessionFacadeActivityTable)
+                    .where(eq(SessionFacadeActivityTable.activity_id, request.activity_id))
+                    .get()
+                : yield* tx
+                    .select({ state: SessionActivityTable.state })
+                    .from(SessionActivityTable)
+                    .where(eq(SessionActivityTable.activity_id, request.activity_id))
+                    .get()
           if (objective?.state !== "active" || base?.state !== "active")
             return yield* new ConflictError({
               entity: request.activity_id,
@@ -1460,11 +1572,17 @@ export const beginPermissionEffect = Effect.fn("DeepAgentActivityAuthority.begin
               ? yield* tx.get<{ state: string }>(sql`
                   SELECT state FROM session_legacy_activity WHERE activity_id = ${request.activity_id}
                 `)
-              : yield* tx
-                  .select({ state: SessionActivityTable.state })
-                  .from(SessionActivityTable)
-                  .where(eq(SessionActivityTable.activity_id, request.activity_id))
-                  .get()
+              : request.activity_kind === "facade"
+                ? yield* tx
+                    .select({ state: SessionFacadeActivityTable.state })
+                    .from(SessionFacadeActivityTable)
+                    .where(eq(SessionFacadeActivityTable.activity_id, request.activity_id))
+                    .get()
+                : yield* tx
+                    .select({ state: SessionActivityTable.state })
+                    .from(SessionActivityTable)
+                    .where(eq(SessionActivityTable.activity_id, request.activity_id))
+                    .get()
           if (objective?.state !== "active" || base?.state !== "active")
             return yield* new ConflictError({
               entity: request.activity_id,
@@ -1952,17 +2070,30 @@ function recoverPendingPermissionsInTransaction(
                   WHERE activity_id = ${request.activity_id} AND state = 'active'
                   RETURNING activity_id
                 `)
-              : yield* tx
-                  .update(SessionActivityTable)
-                  .set({ state: "interrupted", settled_at: now })
-                  .where(
-                    and(
-                      eq(SessionActivityTable.activity_id, request.activity_id),
-                      eq(SessionActivityTable.state, "active"),
-                    ),
-                  )
-                  .returning({ activityID: SessionActivityTable.activity_id })
-                  .get()
+              : request.activity_kind === "facade"
+                ? // FEAT-011 T2 — facade interruption mirrors the v2 branch (CAS on active).
+                  yield* tx
+                    .update(SessionFacadeActivityTable)
+                    .set({ state: "interrupted", reason_code: terminalReason, settled_at: now })
+                    .where(
+                      and(
+                        eq(SessionFacadeActivityTable.activity_id, request.activity_id),
+                        eq(SessionFacadeActivityTable.state, "active"),
+                      ),
+                    )
+                    .returning({ activityID: SessionFacadeActivityTable.activity_id })
+                    .get()
+                : yield* tx
+                    .update(SessionActivityTable)
+                    .set({ state: "interrupted", settled_at: now })
+                    .where(
+                      and(
+                        eq(SessionActivityTable.activity_id, request.activity_id),
+                        eq(SessionActivityTable.state, "active"),
+                      ),
+                    )
+                    .returning({ activityID: SessionActivityTable.activity_id })
+                    .get()
           if (!base)
             return yield* new ConflictError({
               entity: request.activity_id,
@@ -2191,17 +2322,31 @@ function recoverActivityToRequired(
             WHERE activity_id = ${objective.activity_id} AND state = 'active'
             RETURNING activity_id
           `)
-        : yield* tx
-            .update(SessionActivityTable)
-            .set({ state: "failed", settled_at: now })
-            .where(
-              and(
-                eq(SessionActivityTable.activity_id, objective.activity_id),
-                eq(SessionActivityTable.state, "active"),
-              ),
-            )
-            .returning({ activityID: SessionActivityTable.activity_id })
-            .get()
+        : objective.activity_kind === "facade"
+          ? // FEAT-011 T2 — facade recovery follows the v2 mapping: recovery_required is persisted
+            // as base state 'failed' (CAS on active), unlike legacy which keeps 'recovery_required'.
+            yield* tx
+              .update(SessionFacadeActivityTable)
+              .set({ state: "failed", reason_code: terminalReason, settled_at: now })
+              .where(
+                and(
+                  eq(SessionFacadeActivityTable.activity_id, objective.activity_id),
+                  eq(SessionFacadeActivityTable.state, "active"),
+                ),
+              )
+              .returning({ activityID: SessionFacadeActivityTable.activity_id })
+              .get()
+          : yield* tx
+              .update(SessionActivityTable)
+              .set({ state: "failed", settled_at: now })
+              .where(
+                and(
+                  eq(SessionActivityTable.activity_id, objective.activity_id),
+                  eq(SessionActivityTable.state, "active"),
+                ),
+              )
+              .returning({ activityID: SessionActivityTable.activity_id })
+              .get()
     if (!base)
       return yield* new ConflictError({
         entity: objective.activity_id,
@@ -2266,11 +2411,17 @@ function reconcilePermissionFanout(
           ? yield* tx.get<{ state: string }>(sql`
               SELECT state FROM session_legacy_activity WHERE activity_id = ${sibling.activity_id}
             `)
-          : yield* tx
-              .select({ state: SessionActivityTable.state })
-              .from(SessionActivityTable)
-              .where(eq(SessionActivityTable.activity_id, sibling.activity_id))
-              .get()
+          : sibling.activity_kind === "facade"
+            ? yield* tx
+                .select({ state: SessionFacadeActivityTable.state })
+                .from(SessionFacadeActivityTable)
+                .where(eq(SessionFacadeActivityTable.activity_id, sibling.activity_id))
+                .get()
+            : yield* tx
+                .select({ state: SessionActivityTable.state })
+                .from(SessionActivityTable)
+                .where(eq(SessionActivityTable.activity_id, sibling.activity_id))
+                .get()
       const expired = sibling.expires_at !== null && sibling.expires_at <= input.decidedAt
       const activityTerminal =
         !objective ||
@@ -2372,17 +2523,30 @@ function reconcilePermissionFanout(
               WHERE activity_id = ${sibling.activity_id} AND state = 'active'
               RETURNING activity_id
             `)
-          : yield* tx
-              .update(SessionActivityTable)
-              .set({ state: "interrupted", settled_at: input.decidedAt })
-              .where(
-                and(
-                  eq(SessionActivityTable.activity_id, sibling.activity_id),
-                  eq(SessionActivityTable.state, "active"),
-                ),
-              )
-              .returning({ activityID: SessionActivityTable.activity_id })
-              .get()
+          : sibling.activity_kind === "facade"
+            ? // FEAT-011 T2 — facade interruption mirrors the v2 branch (CAS on active).
+              yield* tx
+                .update(SessionFacadeActivityTable)
+                .set({ state: "interrupted", reason_code: terminalReason, settled_at: input.decidedAt })
+                .where(
+                  and(
+                    eq(SessionFacadeActivityTable.activity_id, sibling.activity_id),
+                    eq(SessionFacadeActivityTable.state, "active"),
+                  ),
+                )
+                .returning({ activityID: SessionFacadeActivityTable.activity_id })
+                .get()
+            : yield* tx
+                .update(SessionActivityTable)
+                .set({ state: "interrupted", settled_at: input.decidedAt })
+                .where(
+                  and(
+                    eq(SessionActivityTable.activity_id, sibling.activity_id),
+                    eq(SessionActivityTable.state, "active"),
+                  ),
+                )
+                .returning({ activityID: SessionActivityTable.activity_id })
+                .get()
       if (!interrupted)
         return yield* new ConflictError({
           entity: sibling.activity_id,
diff --git a/packages/core/src/deepagent/deepagent-event-bus.ts b/packages/core/src/deepagent/deepagent-event-bus.ts
index 1791352b..5256bec6 100644
--- a/packages/core/src/deepagent/deepagent-event-bus.ts
+++ b/packages/core/src/deepagent/deepagent-event-bus.ts
@@ -4,7 +4,7 @@ import { Context, Effect, Layer, PubSub, Stream } from "effect"
 import { and, asc, desc, eq, isNull, lte, lt, gt, notExists, or, sql } from "drizzle-orm"
 import { alias } from "drizzle-orm/sqlite-core"
 import { Database } from "../database/database"
-import { DeepAgentEventDeliveryTable, DeepAgentEventDropTable, DeepAgentEventTable, DeepAgentConsumerGroupTable } from "./deepagent-event-sql"
+import { DeepAgentEventDeliveryTable, DeepAgentEventDropTable, DeepAgentEventTable, DeepAgentConsumerGroupTable, DeepAgentRateLimitBucketTable } from "./deepagent-event-sql"
 import { ApprovalQueueTable } from "./approval-queue-sql"
 import { DeepAgentEvent } from "./deepagent-event"
 import { RateLimiter } from "./rate-limiter"
@@ -71,8 +71,10 @@ export interface Interface {
    * NOT persisted (no row, no dispatch). Otherwise the persisted event is returned as `{ published }`.
    * The discriminated union lets the caller observe the drop (e.g. to log a blocked-push counter).
    *
-   * Keyed per workspaceID (fixed-window, in-memory). This is ADDITIVE — existing `publish` callers are
-   * untouched and bypass the gate entirely.
+   * Keyed per workspaceID (fixed-window, DURABLE — the bucket lives in `deepagent_rate_limit_bucket`
+   * and is updated inside an immediate transaction, so N processes sharing the DB enforce ONE
+   * combined quota; RISK-006). This is ADDITIVE — existing `publish` callers are untouched and
+   * bypass the gate entirely.
    */
   readonly tryPublish: (
     input: DeepAgentEvent.PublishInput,
@@ -134,6 +136,32 @@ export interface Interface {
   }) => Effect.Effect<void>
   /** §A3 retry scan — pending deliveries whose backoff has elapsed (Router/Scheduler drives re-delivery). */
   readonly dueRetries: (now?: number) => Effect.Effect<ReadonlyArray<DeliveryTracker>>
+  /**
+   * RISK-001: atomically claim due pending deliveries for ONE subscription group. Stamps a fresh
+   * claim token + lease inside an immediate transaction; rows under a live lease are skipped and
+   * expired leases are re-claimable. The returned opaque token must be passed to ackClaim/nackClaim
+   * so a stale worker cannot settle a delivery that a newer claimant already owns.
+   */
+  readonly claimDue: (input: {
+    readonly subscriptionGroup: string
+    readonly claimantId: string
+    readonly now?: number
+    readonly limit?: number
+    readonly leaseMs?: number
+  }) => Effect.Effect<{ readonly claimToken: string; readonly deliveries: ReadonlyArray<DeliveryTracker> }>
+  /** Ack conditioned on the claim token; a stale token (or non-pending row) is a no-op → false. */
+  readonly ackClaim: (input: {
+    readonly subscriptionGroup: string
+    readonly eventID: DeepAgentEvent.ID
+    readonly claimToken: string
+  }) => Effect.Effect<boolean>
+  /** Nack conditioned on the claim token; a stale token is a no-op → false. Clears the claim. */
+  readonly nackClaim: (input: {
+    readonly subscriptionGroup: string
+    readonly eventID: DeepAgentEvent.ID
+    readonly claimToken: string
+    readonly reason: string
+  }) => Effect.Effect<boolean>
   /**
    * K40-4: real pending-delivery count per workspace — the durable backlog depth for the
    * backpressure gate. Counts deepagent_event_delivery rows with status='pending' scoped
@@ -163,11 +191,10 @@ export interface Interface {
     readonly limit?: number
   }) => Effect.Effect<{ readonly deletedEvents: number }>
   /**
-   * §E2 — prune the publish rate-limiter's per-workspace buckets whose fixed window has elapsed as of
-   * `now`, bounding the limiter's memory for idle workspaces. Returns how many buckets were dropped.
-   * The limiter lives inside this layer's closure; this exposes its `sweep` so a periodic daemon
-   * (v4-event-runtime) can drive it on a cadence without reaching into private state. `now` defaults to
-   * the injected clock (deterministic in tests). A no-op that never throws — safe to call any time.
+   * §E2 — prune the publish rate-limiter's durable per-workspace buckets
+   * (`deepagent_rate_limit_bucket`) whose fixed window has elapsed as of `now`, bounding the table
+   * for idle workspaces. Returns how many buckets were dropped. `now` defaults to the injected
+   * clock (deterministic in tests). A no-op that never throws — safe to call any time.
    */
   readonly sweepPublishLimiter: (now?: number) => Effect.Effect<{ readonly prunedBuckets: number }>
   /**
@@ -176,8 +203,11 @@ export interface Interface {
    * With durable registration, `publish` writes delivery rows for ALL registered groups — not just the
    * in-memory live ones — so an offline consumer catches up via `dueRetries` + `replay` on reconnect.
    * Idempotent: re-registering the same group updates `last_seen_at`.
+   *
+   * RISK-006: `workspaceID` records the tenant the group consumes for; defaults to "" (global /
+   * unscoped) so existing callers stay source-compatible.
    */
-  readonly registerConsumerGroup: (groupId: string, typeFilter?: string) => Effect.Effect<void>
+  readonly registerConsumerGroup: (groupId: string, typeFilter?: string, workspaceID?: string) => Effect.Effect<void>
   /**
    * K40-2: Durably unregister a consumer group. After this call `publish` will no longer create delivery
    * rows for this group. Live in-memory streams for this group are NOT terminated — they finish naturally.
@@ -187,6 +217,16 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@deepagent-code/DeepAgentEventBus") {}
 
+// RISK-006 — durable priority ordering for dueRetries/claimDue: critical(3) > high(2) > normal(1)
+// > low(0). NULL (pre-migration rows) falls into ELSE and ranks as "normal". Combined with
+// next_attempt_at ASC this keeps FIFO order WITHIN a priority class.
+const priorityRank = sql<number>`case
+  when ${DeepAgentEventDeliveryTable.priority} = 'critical' then 3
+  when ${DeepAgentEventDeliveryTable.priority} = 'high' then 2
+  when ${DeepAgentEventDeliveryTable.priority} = 'low' then 0
+  else 1
+end`
+
 export interface LayerOptions {
   readonly maxAttempts?: number
   readonly backoffBaseMs?: number
@@ -236,10 +276,6 @@ export const layerWith = (options?: LayerOptions) =>
       // `subscribe` for grouped consumers merges both channels (highPriorityLive first), so when
       // multiple events are queued, critical/high are processed before normal/low.
       const highPriorityLive = yield* PubSub.unbounded<DeepAgentEvent.Event>()
-      // §A4/§E2 — ONE in-memory fixed-window limiter for the whole bus, keyed per workspaceID. Only
-      // `tryPublish` consults it; `publish` is unchanged. `now` (the injected clock) drives window
-      // resets so tests cross a boundary deterministically.
-      const publishLimiter = new RateLimiter.Service()
 
       yield* Effect.addFinalizer(() =>
         Effect.all([PubSub.shutdown(live), PubSub.shutdown(highPriorityLive)], { concurrency: "unbounded" }).pipe(
@@ -285,8 +321,9 @@ export const layerWith = (options?: LayerOptions) =>
       const dbGroupsCache = new Map<string, string[]>()
       const invalidateDbGroupsCache = () => dbGroupsCache.clear()
 
-      const groupsFor = (eventType: string): Effect.Effect<ReadonlyArray<string>> => {
-        const cached = dbGroupsCache.get(eventType)
+      const groupsFor = (eventType: string, workspaceID: string): Effect.Effect<ReadonlyArray<string>> => {
+        const cacheKey = `${eventType}\n${workspaceID}`
+        const cached = dbGroupsCache.get(cacheKey)
         if (cached !== undefined) {
           // DB portion is cached; still merge with current live groups (always fresh, no DB).
           const live = liveGroupsFor(eventType)
@@ -300,14 +337,24 @@ export const layerWith = (options?: LayerOptions) =>
           .select({ group_id: DeepAgentConsumerGroupTable.group_id })
           .from(DeepAgentConsumerGroupTable)
           .where(
-            or(isNull(DeepAgentConsumerGroupTable.type_filter), eq(DeepAgentConsumerGroupTable.type_filter, eventType)),
+            and(
+              or(isNull(DeepAgentConsumerGroupTable.type_filter), eq(DeepAgentConsumerGroupTable.type_filter, eventType)),
+              // RISK-006 residual: dispatch routing is workspace-scoped. A workspace-bound consumer
+              // group (workspace_id != "") is owed only its own tenant's events; a global group
+              // (workspace_id = "") keeps receiving every workspace. Live in-memory groups carry no
+              // workspace, so they remain global (all current consumers register globally).
+              or(
+                eq(DeepAgentConsumerGroupTable.workspace_id, ""),
+                eq(DeepAgentConsumerGroupTable.workspace_id, workspaceID),
+              ),
+            ),
           )
           .all()
           .pipe(
             Effect.orDie,
             Effect.map((rows) => {
               const dbGroups = rows.map((r) => r.group_id)
-              dbGroupsCache.set(eventType, dbGroups)
+              dbGroupsCache.set(cacheKey, dbGroups)
               const live = liveGroupsFor(eventType)
               // Union: db-registered + live-only (not yet durable-registered), deduplicated.
               const seen = new Set<string>(dbGroups)
@@ -352,7 +399,7 @@ export const layerWith = (options?: LayerOptions) =>
           // past the read-check above hits UNIQUE(idempotency_key) → 0 rows → not the winner). Dispatch
           // happens AFTER commit, so a subscriber never observes an uncommitted event.
           // K40-2: groupsFor is now async (queries DB for durable groups + in-memory live groups).
-          const owed = yield* groupsFor(event.type)
+          const owed = yield* groupsFor(event.type, event.workspaceID)
           // §F1 event_publish_latency_ms — wall-clock delta (injected clock) around the persist
           // transaction. One now() before, one after; the delta is written on the row so Observability
           // can build the publish-latency histogram. Cheap + additive.
@@ -395,6 +442,9 @@ export const layerWith = (options?: LayerOptions) =>
                           attempts: 0,
                           last_error: null,
                           next_attempt_at: createdAt, // owed immediately until acked
+                          // RISK-006: denormalize the event's priority onto the delivery row so the
+                          // retry/claim scans can order high-priority work first without a join.
+                          priority: event.priority,
                           created_at: createdAt,
                           updated_at: createdAt,
                         })),
@@ -455,16 +505,68 @@ export const layerWith = (options?: LayerOptions) =>
             return { published: yield* publish(input) }
           }
           const limit = opts?.limit ?? RateLimiter.EVENT_PUBLISH_PER_WORKSPACE.limit
-          const admitted = publishLimiter.check(
-            input.workspaceID,
-            limit,
-            RateLimiter.EVENT_PUBLISH_PER_WORKSPACE.windowMs,
-            now(),
-          )
+          const admitted = yield* checkDurableLimit(input.workspaceID, limit, now())
           if (!admitted) return { dropped: "rate_limited" as const }
           return { published: yield* publish(input) }
         })
 
+      // RISK-006 §A4/§E2 — DURABLE fixed-window check-and-increment against
+      // `deepagent_rate_limit_bucket`. The immediate transaction takes the SQLite write lock up front,
+      // so the read-modify-write below cannot interleave with another process/bus instance: every
+      // producer sharing the DB consumes ONE combined per-workspace quota (the old in-memory Map gave
+      // each process its own). Windows are epoch-aligned (floor(now / windowMs)) so independent
+      // processes agree on the current window without coordination. `now` (the injected clock) drives
+      // window boundaries so tests cross them deterministically.
+      const checkDurableLimit = (workspaceID: string, limit: number, at: number) =>
+        db
+          .transaction(
+            () =>
+              Effect.gen(function* () {
+                const windowMs = RateLimiter.EVENT_PUBLISH_PER_WORKSPACE.windowMs
+                const windowStart = Math.floor(at / windowMs) * windowMs
+                const bucket = yield* db
+                  .select()
+                  .from(DeepAgentRateLimitBucketTable)
+                  .where(
+                    and(
+                      eq(DeepAgentRateLimitBucketTable.workspace_id, workspaceID),
+                      eq(DeepAgentRateLimitBucketTable.window_start, windowStart),
+                    ),
+                  )
+                  .get()
+                  .pipe(Effect.orDie)
+                if (bucket) {
+                  if (bucket.count >= limit) return false
+                  yield* db
+                    .update(DeepAgentRateLimitBucketTable)
+                    .set({ count: bucket.count + 1 })
+                    .where(
+                      and(
+                        eq(DeepAgentRateLimitBucketTable.workspace_id, workspaceID),
+                        eq(DeepAgentRateLimitBucketTable.window_start, windowStart),
+                      ),
+                    )
+                    .run()
+                    .pipe(Effect.orDie)
+                  return true
+                }
+                // Fresh window — seed count=1. A conflict cannot happen while we hold the write lock,
+                // but the upsert keeps the insert total should that ever change.
+                yield* db
+                  .insert(DeepAgentRateLimitBucketTable)
+                  .values([{ workspace_id: workspaceID, window_start: windowStart, count: 1 }])
+                  .onConflictDoUpdate({
+                    target: [DeepAgentRateLimitBucketTable.workspace_id, DeepAgentRateLimitBucketTable.window_start],
+                    set: { count: 1 },
+                  })
+                  .run()
+                  .pipe(Effect.orDie)
+                return true
+              }),
+            { behavior: "immediate" },
+          )
+          .pipe(Effect.orDie)
+
       const subscribe: Interface["subscribe"] = (input) => {
         const filtered = Stream.fromPubSub(live).pipe(
           Stream.filter((event) => (input.type ? event.type === input.type : true)),
@@ -747,12 +849,158 @@ export const layerWith = (options?: LayerOptions) =>
                 lte(DeepAgentEventDeliveryTable.next_attempt_at, at),
               ),
             )
-            .orderBy(asc(DeepAgentEventDeliveryTable.next_attempt_at))
+            // RISK-006: persistent priority — high/critical due work drains before normal/low.
+            .orderBy(desc(priorityRank), asc(DeepAgentEventDeliveryTable.next_attempt_at))
             .all()
             .pipe(Effect.orDie)
           return rows.map(trackerOf)
         })
 
+      // RISK-001: locked replacement for the dueRetries scan. The immediate transaction takes the
+      // SQLite write lock up front, so the SELECT-then-UPDATE below cannot interleave with another
+      // writer — exactly one claimant wins each row while its lease is live.
+      const claimDue: Interface["claimDue"] = (input) =>
+        Effect.uninterruptible(
+          db
+            .transaction(
+              () =>
+                Effect.gen(function* () {
+                  const at = input.now ?? now()
+                  const leaseMs = input.leaseMs ?? 5 * 60_000
+                  const limit = input.limit ?? 50
+                  const eligible = yield* db
+                    .select()
+                    .from(DeepAgentEventDeliveryTable)
+                    .where(
+                      and(
+                        eq(DeepAgentEventDeliveryTable.subscription_group, input.subscriptionGroup),
+                        eq(DeepAgentEventDeliveryTable.status, "pending"),
+                        lte(DeepAgentEventDeliveryTable.next_attempt_at, at),
+                        or(
+                          isNull(DeepAgentEventDeliveryTable.claim_token),
+                          lte(DeepAgentEventDeliveryTable.lease_expires_at, at),
+                        ),
+                      ),
+                    )
+                    // RISK-006: persistent priority — a limited claim takes high/critical rows first.
+                    .orderBy(desc(priorityRank), asc(DeepAgentEventDeliveryTable.next_attempt_at))
+                    .limit(limit)
+                    .all()
+                    .pipe(Effect.orDie)
+                  const claimToken = crypto.randomUUID()
+                  if (eligible.length === 0) return { claimToken, deliveries: [] as ReadonlyArray<DeliveryTracker> }
+                  yield* db
+                    .update(DeepAgentEventDeliveryTable)
+                    .set({
+                      claim_token: claimToken,
+                      claimant_id: input.claimantId,
+                      claimed_at: at,
+                      lease_expires_at: at + leaseMs,
+                      updated_at: at,
+                    })
+                    .where(
+                      or(
+                        ...eligible.map((row) =>
+                          and(
+                            eq(DeepAgentEventDeliveryTable.event_id, row.event_id),
+                            eq(DeepAgentEventDeliveryTable.subscription_group, row.subscription_group),
+                          ),
+                        ),
+                      ),
+                    )
+                    .run()
+                    .pipe(Effect.orDie)
+                  return { claimToken, deliveries: eligible.map(trackerOf) }
+                }),
+              { behavior: "immediate" },
+            )
+            .pipe(Effect.orDie),
+        )
+
+      const ackClaim: Interface["ackClaim"] = (input) =>
+        db
+          .update(DeepAgentEventDeliveryTable)
+          .set({
+            status: "delivered",
+            last_error: null,
+            next_attempt_at: null,
+            updated_at: now(),
+          })
+          .where(
+            and(
+              eq(DeepAgentEventDeliveryTable.event_id, input.eventID),
+              eq(DeepAgentEventDeliveryTable.subscription_group, input.subscriptionGroup),
+              eq(DeepAgentEventDeliveryTable.claim_token, input.claimToken),
+              eq(DeepAgentEventDeliveryTable.status, "pending"),
+            ),
+          )
+          .returning({ eventID: DeepAgentEventDeliveryTable.event_id })
+          .all()
+          .pipe(Effect.map((rows) => rows.length > 0), Effect.orDie)
+
+      const nackClaim: Interface["nackClaim"] = (input) =>
+        Effect.gen(function* () {
+          const transition = yield* Effect.uninterruptible(
+            db
+              .transaction(
+                () =>
+                  Effect.gen(function* () {
+                    const current = yield* db
+                      .select()
+                      .from(DeepAgentEventDeliveryTable)
+                      .where(
+                        and(
+                          eq(DeepAgentEventDeliveryTable.event_id, input.eventID),
+                          eq(DeepAgentEventDeliveryTable.subscription_group, input.subscriptionGroup),
+                          eq(DeepAgentEventDeliveryTable.claim_token, input.claimToken),
+                        ),
+                      )
+                      .get()
+                      .pipe(Effect.orDie)
+                    // Stale token or a row that already settled — the claim no longer owns it.
+                    if (!current || current.status !== "pending")
+                      return { applied: false, justDied: false, attempts: 0 }
+                    const attempts = current.attempts + 1
+                    const dead = attempts >= maxAttempts
+                    const at = now()
+                    const nextAttemptAt = dead ? null : at + backoffBaseMs * 2 ** (attempts - 1)
+                    yield* db
+                      .update(DeepAgentEventDeliveryTable)
+                      .set({
+                        status: dead ? "dead" : "pending",
+                        attempts,
+                        last_error: input.reason,
+                        next_attempt_at: nextAttemptAt,
+                        // release the claim: a pending row is eligible for the next claimant; a dead
+                        // row never re-enters the retry scan.
+                        claim_token: null,
+                        claimant_id: null,
+                        claimed_at: null,
+                        lease_expires_at: null,
+                        updated_at: at,
+                      })
+                      .where(
+                        and(
+                          eq(DeepAgentEventDeliveryTable.event_id, input.eventID),
+                          eq(DeepAgentEventDeliveryTable.subscription_group, input.subscriptionGroup),
+                          eq(DeepAgentEventDeliveryTable.claim_token, input.claimToken),
+                        ),
+                      )
+                      .run()
+                      .pipe(Effect.orDie)
+                    return { applied: true, justDied: dead, attempts }
+                  }),
+                { behavior: "immediate" },
+              )
+              .pipe(Effect.orDie),
+          )
+          if (transition.justDied)
+            yield* emitDlqAlert(input.eventID, input.subscriptionGroup, input.reason, transition.attempts).pipe(
+              Effect.catchCause(() => Effect.void),
+            )
+          return transition.applied
+        })
+
       // K40-4: real durable backlog depth per workspace — count pending delivery rows whose source event
       // belongs to the given workspace. This is the authoritative backpressure signal: it reflects the
       // number of events that are owed to at least one consumer group but not yet acked. Uses the existing
@@ -873,22 +1121,41 @@ export const layerWith = (options?: LayerOptions) =>
           )
           .pipe(Effect.orDie)
 
-      // §E2 — drive the in-memory rate-limiter's stale-window prune. Synchronous + total (never fails),
-      // wrapped in Effect.sync so the daemon can schedule it uniformly with the other bus effects.
+      // §E2 — prune elapsed durable rate-limit windows (RISK-006). A bucket's window has elapsed once
+      // `window_start + windowMs <= now`. Returns how many buckets were dropped.
       const sweepPublishLimiter: Interface["sweepPublishLimiter"] = (nowArg) =>
-        Effect.sync(() => ({ prunedBuckets: publishLimiter.sweep(nowArg ?? now()) }))
+        Effect.gen(function* () {
+          const at = nowArg ?? now()
+          const windowMs = RateLimiter.EVENT_PUBLISH_PER_WORKSPACE.windowMs
+          const pruned = yield* db
+            .delete(DeepAgentRateLimitBucketTable)
+            .where(lte(DeepAgentRateLimitBucketTable.window_start, at - windowMs))
+            .returning({ workspace_id: DeepAgentRateLimitBucketTable.workspace_id })
+            .all()
+            .pipe(Effect.orDie)
+          return { prunedBuckets: pruned.length }
+        })
 
       // K40-2: durable consumer group registration — persists group identity so publish writes delivery
       // rows for offline groups too. Both methods are idempotent; registerConsumerGroup upserts.
       // PERF: both methods invalidate dbGroupsCache so the next groupsFor re-reads from DB.
-      const registerConsumerGroup: Interface["registerConsumerGroup"] = (groupId, typeFilter) => {
+      const registerConsumerGroup: Interface["registerConsumerGroup"] = (groupId, typeFilter, workspaceID) => {
         const at = now()
+        const workspace = workspaceID ?? ""
         return db
           .insert(DeepAgentConsumerGroupTable)
-          .values([{ group_id: groupId, type_filter: typeFilter ?? null, registered_at: at, last_seen_at: at }])
+          .values([
+            {
+              group_id: groupId,
+              type_filter: typeFilter ?? null,
+              workspace_id: workspace,
+              registered_at: at,
+              last_seen_at: at,
+            },
+          ])
           .onConflictDoUpdate({
             target: DeepAgentConsumerGroupTable.group_id,
-            set: { type_filter: typeFilter ?? null, last_seen_at: at },
+            set: { type_filter: typeFilter ?? null, workspace_id: workspace, last_seen_at: at },
           })
           .run()
           .pipe(Effect.orDie, Effect.asVoid, Effect.tap(() => Effect.sync(invalidateDbGroupsCache)))
@@ -907,6 +1174,9 @@ export const layerWith = (options?: LayerOptions) =>
         subscribe,
         ack,
         nack,
+        claimDue,
+        ackClaim,
+        nackClaim,
         replay,
         recentByType,
         deadLetters,
diff --git a/packages/core/src/deepagent/deepagent-event-sql.ts b/packages/core/src/deepagent/deepagent-event-sql.ts
index 2ff69ec4..0f05e639 100644
--- a/packages/core/src/deepagent/deepagent-event-sql.ts
+++ b/packages/core/src/deepagent/deepagent-event-sql.ts
@@ -1,4 +1,4 @@
-import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core"
+import { index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core"
 import type { DeepAgentEvent } from "./deepagent-event"
 
 // V4.0 §A3 — durable persistence for the DeepAgent Event Bus. The design principle is "事件先持久化，
@@ -57,6 +57,16 @@ export const DeepAgentEventDeliveryTable = sqliteTable(
     attempts: integer().notNull(),
     last_error: text(),
     next_attempt_at: integer(),
+    // RISK-001: retry claim/lease. A pump atomically stamps token+claimant+lease before executing a
+    // due row; expired leases re-open the row for another claimant (migration 20260815120000).
+    claim_token: text(),
+    claimant_id: text(),
+    claimed_at: integer(),
+    lease_expires_at: integer(),
+    // RISK-006: denormalized event priority (written by publish) so dueRetries/claimDue can order
+    // high-priority work first without joining the event table. NULL = pre-migration rows, treated
+    // as "normal" by the ordering (migration 20260815130000).
+    priority: text().$type<DeepAgentEvent.EventPriority>(),
     created_at: integer().notNull(),
     updated_at: integer().notNull(),
   },
@@ -65,6 +75,8 @@ export const DeepAgentEventDeliveryTable = sqliteTable(
     uniqueIndex("deepagent_event_delivery_unique_idx").on(table.event_id, table.subscription_group),
     // retry scan: pending rows whose backoff has elapsed, oldest first.
     index("deepagent_event_delivery_due_idx").on(table.status, table.next_attempt_at),
+    // group-scoped claim scan (RISK-001).
+    index("deepagent_event_delivery_claim_idx").on(table.subscription_group, table.status, table.next_attempt_at),
   ],
 )
 
@@ -79,6 +91,9 @@ export const DeepAgentConsumerGroupTable = sqliteTable(
     group_id: text().primaryKey(),
     // null = wildcard (all event types); non-null = subscribe to one type only.
     type_filter: text(),
+    // RISK-006: the tenant this group consumes for. Default "" keeps pre-existing global/unscoped
+    // registrations valid (migration 20260815130000).
+    workspace_id: text().notNull().default(""),
     registered_at: integer().notNull(),
     // Updated on every live subscribe/unsubscribe so a sweep can distinguish stale registrations.
     last_seen_at: integer().notNull(),
@@ -86,6 +101,26 @@ export const DeepAgentConsumerGroupTable = sqliteTable(
   (table) => [
     // fast lookup: which groups are registered for a given event type?
     index("deepagent_consumer_group_type_idx").on(table.type_filter),
+    // RISK-006: tenant-scoped group scans.
+    index("deepagent_consumer_group_workspace_idx").on(table.workspace_id),
+  ],
+)
+
+// RISK-006 — durable fixed-window rate-limit buckets for the bus's tryPublish gate. One row per
+// (workspace, window); `window_start` is the epoch-aligned window start (floor(now / windowMs)).
+// The check-and-increment runs inside an immediate transaction, so N processes sharing the DB
+// enforce ONE combined quota per workspace (the in-memory Map gave each process its own ×N).
+export const DeepAgentRateLimitBucketTable = sqliteTable(
+  "deepagent_rate_limit_bucket",
+  {
+    workspace_id: text().notNull(),
+    window_start: integer().notNull(),
+    count: integer().notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.workspace_id, table.window_start] }),
+    // sweepPublishLimiter prunes elapsed windows by window_start alone (cross-workspace).
+    index("deepagent_rate_limit_bucket_window_idx").on(table.window_start),
   ],
 )
 // §A4 event_dropped — the durable DROP LOG. One append-only row per event the router shed (a §A4
diff --git a/packages/core/src/deepagent/domain-pack.ts b/packages/core/src/deepagent/domain-pack.ts
index a61d64be..a3e8265a 100644
--- a/packages/core/src/deepagent/domain-pack.ts
+++ b/packages/core/src/deepagent/domain-pack.ts
@@ -13,6 +13,14 @@ export type ProblemProfile = {
 }
 
 export type ActivateOptions = {
+  // FEAT-001: `override` is the legacy single-pack pin; `overrides` carries multi-pin (GUI pinned
+  // packs). Both are honored — single-value callers keep working unchanged.
   readonly override?: string
+  readonly overrides?: readonly string[]
   readonly threshold?: number
 }
+
+// Merge single + multi pin forms into one deduplicated list (FEAT-001 override type evolution).
+export const overridePackIds = (options?: ActivateOptions): readonly string[] => [
+  ...new Set([...(options?.override ? [options.override] : []), ...(options?.overrides ?? [])]),
+]
diff --git a/packages/core/src/deepagent/handoff-admission-sql.ts b/packages/core/src/deepagent/handoff-admission-sql.ts
new file mode 100644
index 00000000..ceb61b65
--- /dev/null
+++ b/packages/core/src/deepagent/handoff-admission-sql.ts
@@ -0,0 +1,49 @@
+import { index, sqliteTable, text, integer, uniqueIndex } from "drizzle-orm/sqlite-core"
+import type { DeepAgentEvent } from "./deepagent-event"
+
+// FEAT-008 — durable admission receipt for `agent.handoff.requested` processing.
+//
+// WHY A NEW TABLE (and not reuse of an existing one):
+//   - `deepagent_event_delivery` tracks DELIVERY lifecycle only (pending → delivered | dead). It has
+//     no handoff identity and cannot express the BUSINESS terminal states accepted/rejected, so after
+//     a crash it cannot answer "未处理 / 处理中 / 已完成" for a handoff request — only "was the event
+//     acked by this group".
+//   - `task_admission` is the subagent control-plane receipt for task_run admission (keyed by
+//     run/origin_key); its schema and idempotency semantics are orthogonal to handoff admission.
+//   - `agent_execution` is the per-task execution state machine; it is only touched once the handoff
+//     passes validation (a reject during validation — missing original event, security gate, etc. —
+//     must still leave a durable "rejected" receipt), and it never models the in-flight "processing"
+//     admission of the consumer itself.
+//
+// One row per handoffID. The consumer writes `processing` at the START of handling (before any
+// side-effecting decision) and settles to `accepted`/`rejected` on the terminal outcome. A row stuck
+// in `processing` after a crash means "not finished" — the retry pump re-admits it (begin() re-stamps
+// the claimant) once the delivery claim's lease lapses; a TERMINAL row is never overwritten, so a
+// redelivery short-circuits without re-running side effects.
+export const DeepAgentHandoffAdmissionTable = sqliteTable(
+  "deepagent_handoff_admission",
+  {
+    // the handoff request's identity (payload.handoffID) — one admission per handoff request.
+    handoff_id: text().primaryKey(),
+    // the bus event that carries the handoff request (§F2 trace spine).
+    event_id: text().$type<DeepAgentEvent.ID>().notNull(),
+    workspace_id: text().notNull(),
+    // processing → accepted | rejected. `processing` rows are "not finished" and re-admissible.
+    state: text().$type<"processing" | "accepted" | "rejected">().notNull(),
+    // who is currently handling (or last settled) the admission — the delivery claim's claimant id
+    // on the pump path, a stable consumer tag on the live-subscription path.
+    claimant_id: text().notNull(),
+    // the terminal reject reason (mirrors the rejectHandoff reason), null while processing/accepted.
+    reason: text(),
+    started_at: integer().notNull(),
+    updated_at: integer().notNull(),
+    // when the admission reached its terminal state (null while processing).
+    settled_at: integer(),
+  },
+  (table) => [
+    // crash-recovery scan: outstanding (non-terminal) admissions per tenant.
+    index("deepagent_handoff_admission_workspace_state_idx").on(table.workspace_id, table.state),
+    // trace lookup: which admission a handoff event produced.
+    uniqueIndex("deepagent_handoff_admission_event_idx").on(table.event_id),
+  ],
+)
diff --git a/packages/core/src/deepagent/handoff-admission.ts b/packages/core/src/deepagent/handoff-admission.ts
new file mode 100644
index 00000000..2e84f4b0
--- /dev/null
+++ b/packages/core/src/deepagent/handoff-admission.ts
@@ -0,0 +1,182 @@
+export * as HandoffAdmission from "./handoff-admission"
+
+import { Context, Effect, Layer } from "effect"
+import { and, eq } from "drizzle-orm"
+import { Database } from "../database/database"
+import type { DeepAgentEvent } from "./deepagent-event"
+import { DeepAgentHandoffAdmissionTable } from "./handoff-admission-sql"
+
+// FEAT-008 — durable admission receipts for `agent.handoff.requested` handling (table:
+// handoff-admission-sql.ts). Closes the "事件即状态" gap: before this receipt existed, a crash
+// between receiving a handoff event and settling it was indistinguishable from "never processed" —
+// the only record was the delivery row's ack/nack. Now every admission is durably stamped
+// `processing` BEFORE any side-effecting decision and settled to a terminal state exactly once:
+//
+//   no row      → 未处理 (never admitted)
+//   processing  → 处理中 — and after a crash this means "NOT finished": begin() re-admits it
+//                  (re-stamps the claimant) instead of treating it as settled. Recovery itself is
+//                  driven by the bus delivery claim/lease — an unacked delivery whose lease lapsed
+//                  is re-claimed by the retry pump, which re-runs the consumer and thus begin().
+//   accepted /  → 已完成: TERMINAL rows are never overwritten, so a redelivery short-circuits
+//   rejected      (begin() returns the terminal receipt) without re-running side effects.
+export type State = "processing" | "accepted" | "rejected"
+
+export interface Receipt {
+  readonly handoffID: string
+  readonly eventID: DeepAgentEvent.ID
+  readonly workspaceID: string
+  readonly state: State
+  readonly claimantID: string
+  readonly reason?: string
+  readonly startedAt: number
+  readonly updatedAt: number
+  readonly settledAt?: number
+}
+
+export interface Interface {
+  /**
+   * Admit a handoff request for processing. Inserts the `processing` receipt on first admission; a
+   * re-admission (crash recovery / redelivery) re-stamps claimant+updated_at ONLY while the row is
+   * still `processing`. A TERMINAL receipt is returned untouched — the caller must short-circuit.
+   */
+  readonly begin: (input: {
+    readonly handoffID: string
+    readonly eventID: DeepAgentEvent.ID
+    readonly workspaceID: string
+    readonly claimantID: string
+    readonly at?: number
+  }) => Effect.Effect<Receipt>
+  /**
+   * Settle the admission to its terminal state. Conditioned on `state = 'processing'` — settling an
+   * already-terminal (or missing) receipt is a no-op → false, so a stale claimant can never flip a
+   * terminal receipt its successor already settled.
+   */
+  readonly settle: (input: {
+    readonly handoffID: string
+    readonly state: "accepted" | "rejected"
+    readonly reason?: string
+    readonly at?: number
+  }) => Effect.Effect<boolean>
+  readonly get: (handoffID: string) => Effect.Effect<Receipt | undefined>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@deepagent-code/HandoffAdmission") {}
+
+export interface LayerOptions {
+  readonly now?: () => number
+}
+
+const decode = (row: typeof DeepAgentHandoffAdmissionTable.$inferSelect): Receipt => ({
+  handoffID: row.handoff_id,
+  eventID: row.event_id,
+  workspaceID: row.workspace_id,
+  state: row.state,
+  claimantID: row.claimant_id,
+  ...(row.reason != null ? { reason: row.reason } : {}),
+  startedAt: row.started_at,
+  updatedAt: row.updated_at,
+  ...(row.settled_at != null ? { settledAt: row.settled_at } : {}),
+})
+
+export const layerWith = (options?: LayerOptions) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      const now = options?.now ?? Date.now
+
+      const get: Interface["get"] = (handoffID) =>
+        db
+          .select()
+          .from(DeepAgentHandoffAdmissionTable)
+          .where(eq(DeepAgentHandoffAdmissionTable.handoff_id, handoffID))
+          .get()
+          .pipe(
+            Effect.orDie,
+            Effect.map((row) => (row ? decode(row) : undefined)),
+          )
+
+      const begin: Interface["begin"] = (input) =>
+        Effect.gen(function* () {
+          const at = input.at ?? now()
+          const existing = yield* get(input.handoffID)
+          // 已完成 is sticky: a terminal receipt survives every re-admission (crash recovery, lease
+          // re-claim, duplicate redelivery) — the caller observes the terminal state and acks without
+          // re-running accept/reject side effects.
+          if (existing && existing.state !== "processing") return existing
+          if (existing) {
+            // 处理中 after a crash: still "not finished" — take it over (fresh claimant stamp). The
+            // `state = 'processing'` guard keeps a racing terminal settle from being overwritten.
+            yield* db
+              .update(DeepAgentHandoffAdmissionTable)
+              .set({ claimant_id: input.claimantID, updated_at: at })
+              .where(
+                and(
+                  eq(DeepAgentHandoffAdmissionTable.handoff_id, input.handoffID),
+                  eq(DeepAgentHandoffAdmissionTable.state, "processing"),
+                ),
+              )
+              .run()
+              .pipe(Effect.orDie)
+            return { ...existing, claimantID: input.claimantID, updatedAt: at }
+          }
+          // 未处理 → first admission. A racing writer that already settled the row wins the conflict;
+          // re-read so the caller always sees the authoritative (possibly terminal) receipt.
+          yield* db
+            .insert(DeepAgentHandoffAdmissionTable)
+            .values({
+              handoff_id: input.handoffID,
+              event_id: input.eventID,
+              workspace_id: input.workspaceID,
+              state: "processing",
+              claimant_id: input.claimantID,
+              reason: null,
+              started_at: at,
+              updated_at: at,
+              settled_at: null,
+            })
+            .onConflictDoNothing({ target: DeepAgentHandoffAdmissionTable.handoff_id })
+            .run()
+            .pipe(Effect.orDie)
+          const settled = yield* get(input.handoffID)
+          return (
+            settled ?? {
+              handoffID: input.handoffID,
+              eventID: input.eventID,
+              workspaceID: input.workspaceID,
+              state: "processing" as const,
+              claimantID: input.claimantID,
+              startedAt: at,
+              updatedAt: at,
+            }
+          )
+        })
+
+      const settle: Interface["settle"] = (input) =>
+        db
+          .update(DeepAgentHandoffAdmissionTable)
+          .set({
+            state: input.state,
+            reason: input.reason ?? null,
+            updated_at: input.at ?? now(),
+            settled_at: input.at ?? now(),
+          })
+          .where(
+            and(
+              eq(DeepAgentHandoffAdmissionTable.handoff_id, input.handoffID),
+              eq(DeepAgentHandoffAdmissionTable.state, "processing"),
+            ),
+          )
+          .returning({ handoff_id: DeepAgentHandoffAdmissionTable.handoff_id })
+          .all()
+          .pipe(
+            Effect.orDie,
+            Effect.map((rows) => rows.length > 0),
+          )
+
+      return Service.of({ begin, settle, get })
+    }),
+  )
+
+export const layer = layerWith()
+export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
diff --git a/packages/core/src/deepagent/knowledge-retriever.ts b/packages/core/src/deepagent/knowledge-retriever.ts
index baa135e5..aca8db1b 100644
--- a/packages/core/src/deepagent/knowledge-retriever.ts
+++ b/packages/core/src/deepagent/knowledge-retriever.ts
@@ -2,7 +2,7 @@ import type { AgentMode } from "./mode"
 import { knowledgeEnabled, strategyMethodologyEnabled, domainKnowledgeEnabled } from "./mode"
 import type { KnowledgeRefProjection, KnowledgeSynthesis, TaskContext, ToolContext } from "./prompt-policy"
 import * as knowledgeSource from "./knowledge-source"
-import { type ProblemProfile, type ActivateOptions } from "./domain-pack"
+import { type ProblemProfile, type ActivateOptions, overridePackIds } from "./domain-pack"
 import * as Registry from "./domain-pack-registry"
 import type { ExtendedProblemProfile } from "./domain-pack-registry"
 import { DeepAgentReleasedSnapshot, SnapshotIntegrityError } from "./released-snapshot"
@@ -39,6 +39,10 @@ export type RetrievalInput = {
   readonly blockedRefs?: readonly string[]
   readonly profile?: ProblemProfile // V3: activates domain packs (docs/31 §2)
   readonly domainOptions?: ActivateOptions // override / threshold for domain activation
+  // FEAT-002: the authoritative run profile, built ONCE by the gateway (profile-builder). When
+  // present, pack activation uses it verbatim so the recorded active_pack_set and the retrieval
+  // constraints share one source of truth. Absent => profileFromInput() fallback (legacy path).
+  readonly profileOverride?: ExtendedProblemProfile
   // V3.2.1 decision B (docs/34 §8): workspace isolation by path. When set, durable retrieval unions
   // user-global knowledge with project-shared knowledge for THIS workspace; project-shared knowledge
   // from OTHER workspaces is never read (different on-disk store). Absent => user-global only. The
@@ -1026,13 +1030,21 @@ const profileFromInput = (input: RetrievalInput): ExtendedProblemProfile => {
     ],
     repo_signals: [taskText(input), ...(input.profile?.signals ?? [])],
     round_signals: [...new Set(input.previousFailures > 0 ? ["previous_round_failure"] : [])],
-    user_overrides: input.domainOptions?.override ? [input.domainOptions.override] : [],
+    // FEAT-001: merge legacy single `override` with multi-pin `overrides` (GUI pinned packs).
+    user_overrides: [...overridePackIds(input.domainOptions)],
   }
 }
 
-const activateKnowledgePacks = (input: RetrievalInput): KnowledgeActivation => {
-  const profile = profileFromInput(input)
-  const threshold = input.domainOptions?.threshold ?? 0.5
+// FEAT-002: the pack activation computed from ONE profile — score → threshold → user overrides →
+// dependency/conflict resolution → core fallback packs. Exported so the gateway records the run's
+// active_pack_set from the exact same activation its retrieval constrains on (single authority).
+export type PackActivation = {
+  readonly activePackIds: readonly string[]
+  readonly primaryPackIds: readonly string[]
+  readonly activeDomains: readonly string[]
+}
+
+export const activationForProfile = (profile: ExtendedProblemProfile, threshold = 0.5): PackActivation => {
   const manifests = Registry.discover()
   const selected = Registry.score(profile, manifests)
     .filter((s) => s.score >= threshold)
@@ -1049,6 +1061,24 @@ const activateKnowledgePacks = (input: RetrievalInput): KnowledgeActivation => {
       .filter((id) => !CORE_FALLBACK_PACKS.includes(id as (typeof CORE_FALLBACK_PACKS)[number]))
       .sort(),
     activeDomains: [...new Set(activeManifests.flatMap((m) => m.domains))].sort(),
+  }
+}
+
+const activateKnowledgePacks = (input: RetrievalInput): KnowledgeActivation => {
+  // FEAT-002: prefer the gateway-supplied authoritative profile; profileFromInput is the fallback
+  // when no profileOverride is handed in (legacy/unpinned callers keep their previous behavior).
+  const profile = input.profileOverride
+    ? {
+        ...input.profileOverride,
+        // Keep honoring domainOptions pins even when a profileOverride is supplied (FEAT-001).
+        user_overrides: [
+          ...new Set([...input.profileOverride.user_overrides, ...overridePackIds(input.domainOptions)]),
+        ],
+      }
+    : profileFromInput(input)
+  const threshold = input.domainOptions?.threshold ?? 0.5
+  return {
+    ...activationForProfile(profile, threshold),
     keywords: keywordsForTask(input),
   }
 }
diff --git a/packages/core/src/deepagent/learning-lifecycle-trigger.ts b/packages/core/src/deepagent/learning-lifecycle-trigger.ts
index 445379b7..59a2d7ec 100644
--- a/packages/core/src/deepagent/learning-lifecycle-trigger.ts
+++ b/packages/core/src/deepagent/learning-lifecycle-trigger.ts
@@ -31,8 +31,11 @@ export type ProjectBoundary = {
 
 export type ObserveInput = SessionBoundary | ProjectBoundary
 
+// FEAT-004: the skipped reason is DISCRIMINATED — `no_observer_registered` means the notify seam had no
+// runtime observer wired (pure CLI path / observer torn down), while `no_exact_settled_run` means an
+// observer DID run but found no matching settled source run. Telemetry/operators can tell the two apart.
 export type Outcome =
-  | { readonly state: "skipped"; readonly reason: "no_exact_settled_run" }
+  | { readonly state: "skipped"; readonly reason: "no_exact_settled_run" | "no_observer_registered" }
   | { readonly state: "prepared" | "admitted"; readonly receiptId: string; readonly runId: string }
 
 export type RuntimeObserver = {
@@ -65,8 +68,10 @@ export const setRuntimeObserver = (observer: RuntimeObserver | undefined) => {
   runtimeObserver = observer
 }
 
+// FEAT-004: an UNREGISTERED observer is its own skip reason — the trigger never searched for a source
+// run at all (distinct from observe() finding no matching settled run).
 export const notify = (input: ObserveInput): Promise<Outcome> =>
-  runtimeObserver?.observe(input) ?? Promise.resolve({ state: "skipped", reason: "no_exact_settled_run" })
+  runtimeObserver?.observe(input) ?? Promise.resolve({ state: "skipped", reason: "no_observer_registered" })
 
 export const observe = Effect.fn("DeepAgentLearningLifecycleTrigger.observe")(function* (
   db: DatabaseClient,
diff --git a/packages/core/src/deepagent/lmn-events.ts b/packages/core/src/deepagent/lmn-events.ts
index 1a0c8b8c..0c63fe54 100644
--- a/packages/core/src/deepagent/lmn-events.ts
+++ b/packages/core/src/deepagent/lmn-events.ts
@@ -63,6 +63,42 @@ export const PANEL_VERDICT = "panel.verdict"
 // producer (a dead delivery OF a dlq.alert never re-alerts).
 export const DLQ_ALERT = "dlq.alert"
 
+// §9 S10 / FEAT-003 — a domain-pack pin change HAS happened: packsPin/packsUnpin publish this after
+// the pinned-set file is durably written (the file write stays authoritative; the event is a
+// post-commit observation, never a driver). It makes pack mutations EVENTED so downstream surfaces no
+// longer have to wait for their next natural recomputation to notice a pin.
+//
+// BENEFIT BOUNDARY (deliberate, do not widen without review):
+//   - the federation four graphs do NOT read pack scope (the knowledge adapter only ever consumes
+//     released snapshots), so no federation-side reaction is expected from this event;
+//   - intended consumers are legacy retrieval-surface audit + UI notification — they subscribe as
+//     needed; this producer only guarantees the event is emitted and subscribable.
+export const PACK_CHANGED = "pack.changed"
+
+// FEAT-006 — a Wiki/knowledge page HAS changed: WikiService.editKnowledge publishes this after a
+// governed human edit lands (append-only new version, human provenance), and the §L execution
+// archiver publishes it after persisting a session execution-archive page (payload carries
+// `archive:true` + sessionID). Like PACK_CHANGED it is a post-commit observation, never a driver —
+// the DocumentStore write stays authoritative; the event only makes the mutation EVENTED.
+//
+// IDEMPOTENCY (FEAT-003 pattern): idempotencyKey = wiki.page.changed:<docId>:<version> — the
+// doc+version pair is the natural dedup identity of the write; archive writes prefix the key with
+// `archive:` so an archive page and a human edit of the same doc never collide. The bus dedupes on
+// the key, so a redelivered write never double-publishes.
+//
+// SELF-LOOP GUARD: the event-driven archiver consumes ONLY ARCHIVE_TRIGGER_TYPES
+// (session.completed / goal.completed) — wiki.page.changed is NOT an archive trigger (asserted in
+// tests), so an archive write's own event can never re-trigger archival. The consumer-type filter
+// isolates the producer→event→consumer loop by construction (same anti-self-cascade posture as
+// DLQ_ALERT, which is guarded at the producer instead).
+//
+// BENEFIT BOUNDARY (deliberate, do not widen without review — mirrors the PACK_CHANGED contract):
+//   - the federation knowledge graphs only ever consume RELEASED snapshots, so NO federation-side
+//     reaction is expected from this event;
+//   - intended consumers are audit, UI notification, and future cache invalidation — they subscribe
+//     on demand; this producer only guarantees the event is emitted and subscribable.
+export const WIKI_PAGE_CHANGED = "wiki.page.changed"
+
 // §C/§D — a multi-agent subtask that could NOT auto-execute and needs a human: it exceeded the agent's
 // autonomy ceiling, or it is a level_5 suggestion_only action (never auto-runs). The Multi-Agent
 // Runtime publishes this so the §D2 Approval Queue surfaces it for a human decision (rather than the
diff --git a/packages/core/src/deepagent/pinned-packs.ts b/packages/core/src/deepagent/pinned-packs.ts
new file mode 100644
index 00000000..af979551
--- /dev/null
+++ b/packages/core/src/deepagent/pinned-packs.ts
@@ -0,0 +1,39 @@
+// FEAT-001: pinned domain packs (docs/34 §9 S10) persist per-workspace as a small JSON file under
+// the gateway memory dir (`<baseDir>/memory/pinned-packs.json`). The GUI writes it via the HTTP
+// handlers; the agent gateway reads it so pins actually shape retrieval. This module is the single
+// fault-tolerant reader/writer shared by both sides — missing or corrupt files degrade to "no pins",
+// never an error. It lives in core because the gateway (core) must read it and cannot import
+// deepagent-code; the handlers (deepagent-code) import it from core.
+
+import path from "node:path"
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
+
+/** File name of the pinned-pack list inside the workspace memory dir. */
+export const PINNED_PACKS_FILE = "pinned-packs.json"
+
+/** Absolute path of the pinned-pack file for a given memory dir. */
+export const pinnedPacksFile = (memoryDir: string): string => path.join(memoryDir, PINNED_PACKS_FILE)
+
+/**
+ * Read the pinned pack ids from `<memoryDir>/pinned-packs.json`.
+ * Fault-tolerant: a missing file, unreadable file, invalid JSON, or a non-array payload all yield
+ * an empty list (no pins). Non-string entries inside a valid array are dropped.
+ */
+export const readPinnedPacks = (memoryDir: string): string[] => {
+  try {
+    const raw = readFileSync(pinnedPacksFile(memoryDir), "utf8")
+    const parsed: unknown = JSON.parse(raw)
+    return Array.isArray(parsed) ? parsed.filter((entry): entry is string => typeof entry === "string") : []
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Write the pinned pack ids (deduplicated, sorted) to `<memoryDir>/pinned-packs.json`,
+ * creating the memory dir when absent.
+ */
+export const writePinnedPacks = (memoryDir: string, ids: readonly string[]): void => {
+  mkdirSync(memoryDir, { recursive: true })
+  writeFileSync(pinnedPacksFile(memoryDir), JSON.stringify([...new Set(ids)].sort(), null, 2), "utf8")
+}
diff --git a/packages/core/src/deepagent/plan-controller.ts b/packages/core/src/deepagent/plan-controller.ts
index e7f8cba8..4d1a2af9 100644
--- a/packages/core/src/deepagent/plan-controller.ts
+++ b/packages/core/src/deepagent/plan-controller.ts
@@ -138,7 +138,19 @@ export const isLightweightMode = (mode: AgentMode | string): boolean => mode ===
 // soft-blocked while the plan is stale; read/search/diagnosis tools always pass — otherwise a stale
 // plan could never be repaired (inspect first, then call `plan` to update, then continue). The
 // `plan` tool itself is never mutating, so it always passes the gate.
-const MUTATING_TOOLS = new Set(["edit", "write", "patch", "apply_patch", "multiedit"])
+const MUTATING_TOOLS = new Set([
+  "edit",
+  "write",
+  "patch",
+  "apply_patch",
+  "multiedit",
+  // FEAT-011 T5: the unified activity facade's MUTATING entry points — activity_start spawns a
+  // supervised background activity (task/goal/panel) and activity_control pause/resume/stop/steers
+  // one; both mutate execution state and must respect the stale-plan gate. activity_status /
+  // activity_result are read-only projections and stay unlisted.
+  "activity_start",
+  "activity_control",
+])
 const ALWAYS_ALLOWED_TOOLS = new Set(["read", "grep", "glob", "list", "ls", "search", "task", "webfetch"])
 
 export const isMutatingTool = (toolName: string, command?: string | null): boolean => {
diff --git a/packages/core/src/deepagent/profile-builder.ts b/packages/core/src/deepagent/profile-builder.ts
new file mode 100644
index 00000000..54ff532a
--- /dev/null
+++ b/packages/core/src/deepagent/profile-builder.ts
@@ -0,0 +1,168 @@
+// FEAT-002 (docs/34 §4.1/§5): the single authoritative ExtendedProblemProfile builder, lowered into
+// core so the agent gateway (core) constructs the SAME profile it hands to knowledge retrieval and
+// pack-snapshot recording — one activation authority per run. Previously this logic lived only in
+// deepagent-code (profile-detector.ts), which the gateway cannot import; deepagent-code now
+// re-exports from here. Pure logic + workspace-fact detection (package.json / README etc.); no
+// runtime imports outside node builtins.
+
+import { existsSync, readFileSync } from "node:fs"
+import path from "node:path"
+import type { ExtendedProblemProfile } from "./domain-pack-registry"
+
+export type WorkspaceSignals = {
+  readonly cwd: string
+  readonly agentMode: "general" | "high" | "xhigh" | "max" | "ultra"
+  readonly scenarioMode: "direct" | "intelligence"
+  readonly userRequest: string
+  readonly languages?: readonly string[]
+  readonly frameworks?: readonly string[]
+  readonly packageScripts?: Readonly<Record<string, string>>
+  // Optional round signals from prior diagnosis / validation
+  readonly roundSignals?: readonly string[]
+  // User-pinned packs (from settings / HTTP API override)
+  readonly userOverrides?: readonly string[]
+}
+
+const CODE_RISK_KEYWORDS = /security|auth|payment|billing|crypto|encrypt|secret|vuln|cve|pentest/i
+const FINANCE_KEYWORDS = /finance|payment|billing|ledger|accounting|invoice|transaction|audit/i
+const HEALTHCARE_KEYWORDS = /health|medical|patient|ehr|phi|hipaa|dicom|clinical/i
+const PRIVACY_KEYWORDS = /gdpr|pii|personal.?data|privacy|consent|anonymi/i
+const PHI_KEYWORDS = /phi|protected.health|patient.record/i
+const READ_ONLY_QUERY_KEYWORDS =
+  /\b(query|count|list|show|read|inspect|status|diff|log|config|select|explain|grep|rg|find)\b|查一下|查询|统计|列出|显示|读取|看一下|多少个|有哪些|当前状态|日志里|配置里|数据库里/i
+const MUTATION_KEYWORDS =
+  /\b(fix|implement|edit|modify|write|delete|deploy|migrate|migration|backfill|transaction|constraint|insert|update|alter|drop|restart|apply|remove)\b|修复|实现|修改|写入|删除|部署|迁移|更新|重启/i
+
+// Detect languages from the workspace (package.json / pyproject / go.mod / Cargo.toml etc.).
+const detectLanguages = (cwd: string): string[] => {
+  const langs: string[] = []
+  if (existsSync(path.join(cwd, "package.json"))) {
+    langs.push("javascript")
+    try {
+      const pkg = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf8"))
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+      if (deps["typescript"] || deps["@types/node"] || existsSync(path.join(cwd, "tsconfig.json"))) {
+        langs.push("typescript")
+      }
+    } catch {
+      langs.push("typescript")
+    } // assume TS on parse failure
+  }
+  if (existsSync(path.join(cwd, "pyproject.toml")) || existsSync(path.join(cwd, "setup.py"))) langs.push("python")
+  if (existsSync(path.join(cwd, "go.mod"))) langs.push("go")
+  if (existsSync(path.join(cwd, "Cargo.toml"))) langs.push("rust")
+  if (existsSync(path.join(cwd, "CMakeLists.txt"))) langs.push("cpp")
+  return [...new Set(langs)]
+}
+
+// Detect frameworks from package.json deps.
+const detectFrameworks = (cwd: string): string[] => {
+  const fw: string[] = []
+  const pkgFile = path.join(cwd, "package.json")
+  if (!existsSync(pkgFile)) return fw
+  try {
+    const pkg = JSON.parse(readFileSync(pkgFile, "utf8"))
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+    if (deps["react"] || deps["react-dom"]) fw.push("react")
+    if (deps["solid-js"]) fw.push("solidjs")
+    if (deps["vue"]) fw.push("vue")
+    if (deps["svelte"]) fw.push("svelte")
+    if (deps["next"]) fw.push("next.js")
+    if (deps["express"] || deps["fastify"] || deps["hono"] || deps["@hono/core"]) fw.push("backend-framework")
+    if (deps["drizzle-orm"] || deps["prisma"] || deps["typeorm"]) fw.push("orm")
+    if (deps["bun"]) fw.push("bun")
+    if (deps["effect"]) fw.push("effect")
+  } catch {
+    /* skip */
+  }
+  return [...new Set(fw)]
+}
+
+// Derive code_domains from languages, frameworks, and user request.
+const deriveCodeDomains = (langs: string[], frameworks: string[], request: string): string[] => {
+  const d: string[] = ["code"]
+  if (frameworks.some((f) => ["react", "solidjs", "vue", "svelte"].includes(f))) d.push("frontend")
+  if (frameworks.some((f) => f === "backend-framework")) d.push("backend")
+  if (langs.includes("cuda") || langs.includes("cpp") || /\b(kernel|gemm|cuda|gpu|sgemm|rocm)\b/i.test(request)) {
+    d.push("gpu_kernel")
+    if (!langs.includes("cpp")) langs.push("cpp")
+  }
+  if (langs.includes("python")) d.push("data")
+  if (READ_ONLY_QUERY_KEYWORDS.test(request) && !MUTATION_KEYWORDS.test(request)) {
+    d.push("query", "deterministic", "read_only")
+  }
+  return [...new Set(d)]
+}
+
+// Extract risk markers from the user request + repo signals.
+const extractRiskMarkers = (request: string, repoSignals: string[]): string[] => {
+  const m: string[] = []
+  const hay = `${request} ${repoSignals.join(" ")}`.toLowerCase()
+  if (CODE_RISK_KEYWORDS.test(hay)) m.push("security")
+  if (FINANCE_KEYWORDS.test(hay)) m.push("finance")
+  if (HEALTHCARE_KEYWORDS.test(hay)) m.push("healthcare")
+  if (PRIVACY_KEYWORDS.test(hay)) m.push("pii", "privacy")
+  if (PHI_KEYWORDS.test(hay)) m.push("phi")
+  return [...new Set(m)]
+}
+
+// Extract business_domains from request + risk markers.
+const deriveBusinessDomains = (request: string, riskMarkers: string[]): string[] => {
+  const d: string[] = []
+  if (FINANCE_KEYWORDS.test(request) || riskMarkers.includes("finance")) d.push("finance")
+  if (HEALTHCARE_KEYWORDS.test(request) || riskMarkers.includes("healthcare")) d.push("healthcare")
+  return d
+}
+
+// Infer a rough task_kind from the user request (heuristic; good enough for pack scoring).
+const inferTaskKind = (request: string): ExtendedProblemProfile["task_kind"] => {
+  const r = request.toLowerCase()
+  if (/\b(fix|bug|error|fail|broken|crash|traceback)\b/.test(r)) return "debug"
+  if (/\b(review|audit|check|inspect|scan)\b/.test(r)) return "review"
+  if (/\b(test|spec|coverage|unit|e2e|integration)\b/.test(r)) return "test"
+  if (/\b(migrat|upgrade|refactor|rename|move|convert)\b/.test(r)) return "migrate"
+  if (/\b(optim|improv|speed|perf|latency|memory|throughput)\b/.test(r)) return "optimize"
+  if (/\b(explain|document|describe|what|how|why)\b/.test(r)) return "explain"
+  if (/\b(deploy|release|ship|produc|operation)\b/.test(r)) return "operate"
+  return "implement"
+}
+
+// Collect signals from the repo (directory names, config files, README snippet).
+const collectRepoSignals = (cwd: string, userRequest: string): string[] => {
+  const signals: string[] = [userRequest.slice(0, 200)]
+  try {
+    const readmePath = ["README.md", "README.txt", "readme.md"].map((f) => path.join(cwd, f)).find(existsSync)
+    if (readmePath) signals.push(readFileSync(readmePath, "utf8").slice(0, 500))
+  } catch {
+    /* skip */
+  }
+  return signals
+}
+
+// Build a full ExtendedProblemProfile from workspace signals. This is the production entry point
+// called by the gateway/orchestrator before pack activation (docs/34 §5/§9 S5). FEAT-002: this is
+// the ONE profile producer the gateway uses for both retrieval and the recorded pack snapshot.
+export const buildProfile = (signals: WorkspaceSignals): ExtendedProblemProfile => {
+  const langs = signals.languages?.length ? [...signals.languages] : detectLanguages(signals.cwd)
+  const frameworks = signals.frameworks?.length ? [...signals.frameworks] : detectFrameworks(signals.cwd)
+  const repoSignals = collectRepoSignals(signals.cwd, signals.userRequest)
+  const codeDomains = deriveCodeDomains(langs, frameworks, signals.userRequest)
+  const riskMarkers = extractRiskMarkers(signals.userRequest, repoSignals)
+  const businessDomains = deriveBusinessDomains(signals.userRequest, riskMarkers)
+
+  return {
+    scenario_mode: signals.scenarioMode,
+    agent_strength: signals.agentMode,
+    task_kind: inferTaskKind(signals.userRequest),
+    code_domains: codeDomains,
+    business_domains: businessDomains,
+    platforms: [],
+    languages: langs,
+    frameworks,
+    data_classes: riskMarkers.filter((r) => ["pii", "phi"].includes(r)),
+    risk_markers: riskMarkers,
+    repo_signals: repoSignals.slice(0, 3),
+    round_signals: signals.roundSignals ?? [],
+    user_overrides: signals.userOverrides ?? [],
+  }
+}
diff --git a/packages/core/src/deepagent/session-state.ts b/packages/core/src/deepagent/session-state.ts
index 66f29717..9b13b640 100644
--- a/packages/core/src/deepagent/session-state.ts
+++ b/packages/core/src/deepagent/session-state.ts
@@ -112,6 +112,12 @@ export type SessionRunState = {
   // The last soft plan-gate warning claimed by a tool call. A stale latch can span many tool calls;
   // persisting its fingerprint prevents duplicate process-log warnings without touching history.
   lastPlanGateNudgeFingerprint: string | null
+  // FEAT-007: the locked active domain pack snapshot id of the LATEST gateway run for this session
+  // (`pack_snapshot:<hash>`, or the registry's empty/error sentinels). Recorded by the gateway at the
+  // run entry from the SAME activation knowledge retrieval constrains on (single authority, FEAT-002),
+  // and read by the session prompt loop to attribute each tool-request receipt's
+  // context_active_pack_set_snapshot_id. Null when no gateway run locked a snapshot for the session.
+  packSnapshotId: string | null
 }
 
 // V3.9 §D: session-state pointer to a running goal. The GoalLoop's GoalStatus (persisted in the
@@ -175,6 +181,7 @@ export const getOrCreate = (sessionId: string, mode: AgentMode): SessionRunState
     completedAt: null,
     lastAdmissionUserMessageId: undefined,
     lastPlanGateNudgeFingerprint: null,
+    packSnapshotId: null,
   }
   sessions.set(sessionId, state)
   saveToDisk()
@@ -679,6 +686,8 @@ function normalizeState(state: SessionRunState): SessionRunState {
     panelRounds: state.panelRounds ?? null,
     activeGoal: state.activeGoal ?? null,
     lastPlanGateNudgeFingerprint: state.lastPlanGateNudgeFingerprint ?? null,
+    // Backfill: sessions persisted before FEAT-007 have no pack snapshot attribution → null.
+    packSnapshotId: state.packSnapshotId ?? null,
   }
   // PR-4 migration cleanup: the legacy `suppressedFingerprints: string[]` field is carried through by
   // the `...state` spread above. Once its contents are migrated into `suppressedValidations`, drop the
diff --git a/packages/core/src/event.ts b/packages/core/src/event.ts
index c9e15da2..3bb80b07 100644
--- a/packages/core/src/event.ts
+++ b/packages/core/src/event.ts
@@ -128,6 +128,44 @@ export type SerializedSnapshotChunk = {
   readonly chunkHash: string
 }
 
+// RISK-003 ⑤ (BUG-407-010 §9.2/§11.4): the portable, importable aggregate snapshot body.
+// The row/chunk transfer protocol (snapshotRows/snapshotChunks → stage* → importSnapshot) is the
+// durable DB-to-DB path used by warp/sync; this bundle serializes the same authority into one
+// JSON body (chunk data base64) that can be persisted as evidence and atomically imported into an
+// empty copy. `bundleHash` covers the snapshot header, the row manifest, and every chunk body.
+export const SNAPSHOT_BUNDLE_FORMAT = "aggregate-snapshot-bundle.v1"
+
+export const SnapshotBundle = Schema.Struct({
+  format: Schema.Literal(SNAPSHOT_BUNDLE_FORMAT),
+  snapshot: Schema.Struct({
+    snapshotID: Schema.String,
+    aggregateID: Schema.String,
+    throughSeq: NonNegativeInt,
+    syncSeq: NonNegativeInt,
+    codec: Schema.String,
+    schemaVersion: NonNegativeInt,
+    snapshotHash: Schema.String,
+    body: Schema.Record(Schema.String, Schema.Unknown),
+    ownerID: Schema.optional(Schema.String),
+    createdAt: NonNegativeInt,
+  }),
+  rows: Schema.Array(
+    Schema.Struct({
+      snapshotID: Schema.String,
+      rowIndex: NonNegativeInt,
+      tableName: Schema.String,
+      rowKey: Schema.String,
+      rowHash: Schema.String,
+      rowBytes: NonNegativeInt,
+      chunkCount: NonNegativeInt,
+      chainHash: Schema.String,
+    }),
+  ),
+  chunks: Schema.Record(Schema.String, Schema.Array(Schema.String)),
+  bundleHash: Schema.String,
+})
+export type SnapshotBundle = typeof SnapshotBundle.Type
+
 export type SnapshotProjectionRow = {
   readonly cursor: string
   readonly tableName: string
@@ -432,6 +470,8 @@ export interface Interface {
     row: SerializedSnapshotRow,
     chunks: readonly SerializedSnapshotChunk[],
   ) => Effect.Effect<void>
+  readonly exportSnapshotBundle?: (input: { readonly snapshotID: string }) => Effect.Effect<string>
+  readonly importSnapshotBundle?: (bundle: string) => Effect.Effect<SerializedSnapshot>
   readonly compact: (input: {
     readonly aggregateID: string
     readonly throughSeq: Cursor
@@ -1862,6 +1902,135 @@ export const layerWith = (layerOptions?: LayerOptions) =>
         }), { behavior: "immediate" }).pipe(Effect.orDie)
       }
 
+      function exportSnapshotBundle(input: { readonly snapshotID: string }) {
+        return Effect.gen(function* () {
+          const header = yield* db
+            .select({
+              snapshotID: EventSnapshotTable.snapshot_id,
+              aggregateID: EventSnapshotTable.aggregate_id,
+              throughSeq: EventSnapshotTable.through_seq,
+              syncSeq: EventSnapshotTable.sync_seq,
+              codec: EventSnapshotTable.codec,
+              schemaVersion: EventSnapshotTable.schema_version,
+              snapshotHash: EventSnapshotTable.snapshot_hash,
+              body: EventSnapshotTable.body,
+              ownerID: EventSnapshotTable.owner_id,
+              createdAt: EventSnapshotTable.created_at,
+            })
+            .from(EventSnapshotTable)
+            .where(eq(EventSnapshotTable.snapshot_id, input.snapshotID))
+            .get()
+            .pipe(Effect.orDie)
+          if (!header)
+            return yield* Effect.die(
+              new InvalidSyncEventError({ type: "snapshot", message: `Snapshot ${input.snapshotID} not found` }),
+            )
+          const snapshot: SerializedSnapshot = {
+            snapshotID: header.snapshotID,
+            aggregateID: header.aggregateID,
+            throughSeq: header.throughSeq,
+            syncSeq: header.syncSeq,
+            codec: header.codec,
+            schemaVersion: header.schemaVersion,
+            snapshotHash: header.snapshotHash,
+            body: header.body,
+            ...(header.ownerID ? { ownerID: header.ownerID } : {}),
+            createdAt: header.createdAt,
+          }
+          const rows: SerializedSnapshotRow[] = []
+          let after = -1
+          while (true) {
+            const page = yield* snapshotRows({ snapshotID: input.snapshotID, after })
+            rows.push(...page)
+            if (page.length === 0) break
+            after = page[page.length - 1]!.rowIndex
+          }
+          const chunks: Record<string, string[]> = {}
+          for (const row of rows) {
+            const encoded: string[] = []
+            let chunkAfter = -1
+            while (true) {
+              const page = yield* snapshotChunks({ rowHash: row.rowHash, after: chunkAfter })
+              if (page.length === 0) break
+              for (const chunk of page) encoded.push(chunk.data.toString("base64"))
+              chunkAfter = page[page.length - 1]!.chunkIndex
+            }
+            chunks[row.rowHash] = encoded
+          }
+          const bundle = { format: SNAPSHOT_BUNDLE_FORMAT, snapshot, rows, chunks }
+          const text = JSON.stringify({ ...bundle, bundleHash: hashJson(bundle) })
+          if (Buffer.byteLength(text) > SNAPSHOT_MAX_TOTAL_BYTES)
+            return yield* Effect.die(
+              new InvalidSyncEventError({
+                type: "snapshot",
+                message: `Snapshot ${input.snapshotID} bundle exceeds the transfer budget`,
+              }),
+            )
+          return text
+        })
+      }
+
+      function importSnapshotBundle(bundle: string) {
+        return Effect.gen(function* () {
+          if (Buffer.byteLength(bundle) > SNAPSHOT_MAX_TOTAL_BYTES)
+            return yield* Effect.die(
+              new InvalidSyncEventError({ type: "snapshot", message: "Snapshot bundle exceeds the transfer budget" }),
+            )
+          const decoded = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(bundle)
+          const parsed = decoded._tag === "Some" ? decoded.value : undefined
+          const candidate = Schema.decodeUnknownOption(SnapshotBundle)(parsed)
+          if (candidate._tag !== "Some")
+            return yield* Effect.die(
+              new InvalidSyncEventError({
+                type: "snapshot",
+                message: `Snapshot bundle is not a valid ${SNAPSHOT_BUNDLE_FORMAT} body`,
+              }),
+            )
+          const value = candidate.value
+          const { bundleHash, ...rest } = value
+          if (hashJson(rest) !== bundleHash)
+            return yield* Effect.die(
+              new InvalidSyncEventError({ type: "snapshot", message: "Snapshot bundle hash mismatch" }),
+            )
+          const snapshot: SerializedSnapshot = {
+            snapshotID: value.snapshot.snapshotID,
+            aggregateID: value.snapshot.aggregateID,
+            throughSeq: value.snapshot.throughSeq,
+            syncSeq: value.snapshot.syncSeq,
+            codec: value.snapshot.codec,
+            schemaVersion: value.snapshot.schemaVersion,
+            snapshotHash: value.snapshot.snapshotHash,
+            body: value.snapshot.body as Record<string, unknown>,
+            ...(value.snapshot.ownerID ? { ownerID: value.snapshot.ownerID } : {}),
+            createdAt: value.snapshot.createdAt,
+          }
+          // Stage bounded transfer pages (rows, then per-row chunks) before the authoritative
+          // import — the exact protocol the wire transfer uses, so staging CAS guards apply.
+          for (let index = 0; index < value.rows.length; index += SNAPSHOT_TRANSFER_ROWS) {
+            yield* stageSnapshotRows(snapshot, value.rows.slice(index, index + SNAPSHOT_TRANSFER_ROWS))
+          }
+          for (const row of value.rows) {
+            const encoded = value.chunks[row.rowHash]
+            if (!encoded || encoded.length !== row.chunkCount)
+              return yield* Effect.die(
+                new InvalidSyncEventError({
+                  type: "snapshot",
+                  message: `Snapshot bundle row ${row.rowIndex} chunks are missing`,
+                }),
+              )
+            const chunks = encoded.map((data, chunkIndex) => {
+              const buffer = Buffer.from(data, "base64")
+              return { rowHash: row.rowHash, chunkIndex, data: buffer, chunkHash: Hash.sha256(buffer) }
+            })
+            for (let index = 0; index < chunks.length; index += SNAPSHOT_TRANSFER_CHUNKS) {
+              yield* stageSnapshotChunks(snapshot, row, chunks.slice(index, index + SNAPSHOT_TRANSFER_CHUNKS))
+            }
+          }
+          yield* importSnapshot(snapshot)
+          return snapshot
+        })
+      }
+
       function compact(input: {
         readonly aggregateID: string
         readonly throughSeq: Cursor
@@ -2629,6 +2798,8 @@ export const layerWith = (layerOptions?: LayerOptions) =>
         snapshotChunks,
         stageSnapshotRows,
         stageSnapshotChunks,
+        exportSnapshotBundle,
+        importSnapshotBundle,
         backfillSyncIndex,
         remove,
         claim,
diff --git a/packages/core/src/permission/mutating.ts b/packages/core/src/permission/mutating.ts
new file mode 100644
index 00000000..4b20887d
--- /dev/null
+++ b/packages/core/src/permission/mutating.ts
@@ -0,0 +1,15 @@
+// Shared mutating-permission set used by every read-only approval mode.
+//
+// Tools that write, execute, or otherwise mutate state — denied in read-only
+// mode. Everything else (read/glob/grep/list/lsp/webfetch/websearch/
+// todowrite/…) is left to the normal permission flow so the agent can still
+// inspect the workspace.
+//
+// Consumers: the GUI directory read-only mode (packages/app) and the CLI
+// `run --permission-mode read-only` auto-responder (packages/deepagent-code)
+// must agree on this set, so it lives in core.
+export const MUTATING_PERMISSIONS = new Set(["edit", "write", "patch", "bash", "task", "external_directory"])
+
+export function isMutatingPermission(permission: string) {
+  return MUTATING_PERMISSIONS.has(permission)
+}
diff --git a/packages/core/src/session/compaction.ts b/packages/core/src/session/compaction.ts
index 99765f73..bc6b458f 100644
--- a/packages/core/src/session/compaction.ts
+++ b/packages/core/src/session/compaction.ts
@@ -11,7 +11,10 @@ import { Token } from "../util/token"
 
 const DEFAULT_BUFFER = 20_000
 const DEFAULT_KEEP_TOKENS = 8_000
-const TOOL_OUTPUT_MAX_CHARS = 2_000
+// UPD-005: single source of truth for the compaction-side tool-output truncation budget.
+// deepagent-code/src/session/compaction.ts imports this constant (it used to keep a duplicate
+// 2_000 copy); keep the two call sites in sync by editing ONLY this definition.
+export const TOOL_OUTPUT_MAX_CHARS = 2_000
 const SUMMARY_OUTPUT_TOKENS = 4_096
 const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
 <template>
diff --git a/packages/core/src/session/sql.ts b/packages/core/src/session/sql.ts
index 8a3bb575..b4b7aecd 100644
--- a/packages/core/src/session/sql.ts
+++ b/packages/core/src/session/sql.ts
@@ -292,7 +292,18 @@ export const SessionIntentTable = sqliteTable(
       .notNull()
       .references(() => SessionTable.id, { onDelete: "cascade" }),
     source: text().$type<"composer" | "intelligence" | "followup" | "rewrite">().notNull(),
-    state: text().$type<"preparing" | "admitting" | "admitted" | "canceled" | "superseded" | "failed">().notNull(),
+    state: text()
+      .$type<
+        | "preparing"
+        | "awaiting_confirmation"
+        | "selected"
+        | "admitting"
+        | "admitted"
+        | "canceled"
+        | "superseded"
+        | "failed"
+      >()
+      .notNull(),
     selected_variant: text().$type<"original" | "rewritten">(),
     selected_payload_hash: text(),
     delivery: text().$type<"turn" | SessionInput.Delivery>(),
diff --git a/packages/core/src/tool/bash.ts b/packages/core/src/tool/bash.ts
index f209b1ad..a01e400f 100644
--- a/packages/core/src/tool/bash.ts
+++ b/packages/core/src/tool/bash.ts
@@ -10,8 +10,6 @@ import { LocationMutation } from "../location-mutation"
 import { AppProcess } from "../process"
 import { PermissionV2 } from "../permission"
 import { Policy } from "../policy"
-import { makeLocationNode } from "../effect/app-node"
-import { ToolRegistry } from "./registry"
 import { ServerCapabilities } from "../server-capabilities"
 import { PositiveInt } from "../schema"
 import { Tool } from "./tool"
@@ -276,9 +274,3 @@ export const layer = Layer.effectDiscard(
       .pipe(Effect.orDie)
   }),
 )
-
-export const node = makeLocationNode({
-  name: "tool/bash",
-  layer,
-  deps: [ToolRegistry.node, LocationMutation.node, FSUtil.node, AppProcess.node, Config.node, PermissionV2.node, Policy.node],
-})
diff --git a/packages/core/test/agent-gateway.test.ts b/packages/core/test/agent-gateway.test.ts
index 603dc6fe..eb9af3f6 100644
--- a/packages/core/test/agent-gateway.test.ts
+++ b/packages/core/test/agent-gateway.test.ts
@@ -6,6 +6,7 @@ import { tmpdir } from "node:os"
 import { Effect, Stream } from "effect"
 import { LLM, LLMEvent, Model } from "@deepagent-code/llm"
 import { AgentGateway } from "../src/agent-gateway"
+import { writePinnedPacks } from "../src/deepagent/pinned-packs"
 import { DeepAgentDurableLearning } from "../src/deepagent/durable-learning"
 import * as OpenAIChat from "@deepagent-code/llm/protocols/openai-chat"
 import { releasedUserGlobalSelection } from "./deepagent/released-selection-fixture"
@@ -60,6 +61,10 @@ describe("AgentGateway", () => {
       expect(Array.from(events).map((event) => event.type)).toEqual(["text-delta", "finish"])
       expect(await readdir(dir)).toHaveLength(1)
       expect(AgentGateway.systemPrompt("openai").join("\n").length).toBeGreaterThan(0)
+      // FEAT-007: the run entry locks the active pack snapshot id onto the session state so the
+      // session prompt loop can attribute each tool-request receipt (no registry configured here →
+      // the deterministic `pack_snapshot:empty` sentinel, still a valid `pack_snapshot:%` value).
+      expect(AgentGateway.DeepAgentSessionState.get("ses_test")?.packSnapshotId).toMatch(/^pack_snapshot:/)
     } finally {
       AgentGateway.configure({ enabled: false, runsDir: undefined })
       await rm(dir, { recursive: true, force: true })
@@ -1094,3 +1099,134 @@ describe("AgentGateway", () => {
     }
   })
 })
+
+// FEAT-001: GUI-pinned domain packs must actually shape gateway behavior — the pinned pack set read
+// from <baseDir>/memory/pinned-packs.json must appear in the run's active_pack_set and the pinned
+// pack's refs must be force-selected by knowledge retrieval.
+describe("AgentGateway pinned domain packs (FEAT-001)", () => {
+  const genericFeature = "rename a local helper function in the user service module"
+
+  const runMaxTurn = async (root: string) => {
+    const runsDir = path.join(root, "runs")
+    await mkdir(runsDir, { recursive: true })
+    AgentGateway.configure({
+      enabled: true,
+      agentMode: "max",
+      baseDir: root,
+      runsDir,
+      allowProviderExecutedTools: false,
+    })
+    // workspaceID stays non-absolute (user-global retrieval) so the fixture's global released
+    // selection matches the query project; pin wiring is independent of workspace scoping.
+    await Effect.runPromise(
+      AgentGateway.manageStream(
+        {
+          ...deepagentRunInput,
+          feature: genericFeature,
+          releasedKnowledgeSelection: releasedUserGlobalSelection(root),
+        },
+        Stream.make(LLMEvent.textDelta({ id: "text-0", text: "done" }), LLMEvent.finish({ reason: "stop" })),
+      ).pipe(Stream.runCollect),
+    )
+    const runDir = await readOnlyRunDir(runsDir)
+    return readJson(runDir, "MODEL_WORK_PACKAGE.json")
+  }
+
+  test("a pinned pack appears in active_pack_set and its refs are force-selected", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "deepagent-pin-"))
+    try {
+      writePinnedPacks(path.join(root, "memory"), ["code.gpu-kernel"])
+      const workPackage = await runMaxTurn(root)
+      expect(workPackage.active_pack_set).toContain("code.gpu-kernel")
+      const selectedRefs: string[] = workPackage.knowledge_retrieval.selected_refs
+      expect(selectedRefs.some((ref) => ref.includes("gpu"))).toBe(true)
+    } finally {
+      AgentGateway.configure({ enabled: false, runsDir: undefined })
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  test("without pins the pack stays inactive (unpinned behavior unchanged)", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "deepagent-nopin-"))
+    try {
+      const workPackage = await runMaxTurn(root)
+      expect(workPackage.active_pack_set).not.toContain("code.gpu-kernel")
+      const selectedRefs: string[] = workPackage.knowledge_retrieval.selected_refs
+      expect(selectedRefs.some((ref) => ref.includes("gpu"))).toBe(false)
+    } finally {
+      AgentGateway.configure({ enabled: false, runsDir: undefined })
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  test("a corrupt pinned-packs.json degrades to no pins and still completes the run", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "deepagent-corrupt-pin-"))
+    try {
+      await mkdir(path.join(root, "memory"), { recursive: true })
+      await writeFile(path.join(root, "memory", "pinned-packs.json"), "{not json")
+      const workPackage = await runMaxTurn(root)
+      expect(workPackage.active_pack_set).not.toContain("code.gpu-kernel")
+    } finally {
+      AgentGateway.configure({ enabled: false, runsDir: undefined })
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+})
+
+// FEAT-002: ONE pack-activation authority per run. The gateway builds the run profile once at run
+// entry (profile-builder) and both knowledge retrieval (RetrievalInput.profileOverride) and the
+// recorded active_pack_set consume it — so the deterministic read-only policy flip (which consumes
+// active_pack_set via activePackIds.includes("code.query")) is regression-locked end to end.
+describe("AgentGateway unified pack activation authority (FEAT-002)", () => {
+  const runMaxTurn = async (root: string, feature: string) => {
+    const runsDir = path.join(root, "runs")
+    const workspace = path.join(root, "workspace")
+    await mkdir(runsDir, { recursive: true })
+    await mkdir(workspace, { recursive: true })
+    AgentGateway.configure({
+      enabled: true,
+      agentMode: "max",
+      baseDir: root,
+      runsDir,
+      allowProviderExecutedTools: false,
+    })
+    // Absolute workspaceID => the run profile detects workspace facts from an empty dir (no
+    // README/package.json noise), keeping the activation verdict deterministic in this test.
+    await Effect.runPromise(
+      AgentGateway.manageStream(
+        { ...deepagentRunInput, feature, workspaceID: workspace },
+        Stream.make(LLMEvent.textDelta({ id: "text-0", text: "done" }), LLMEvent.finish({ reason: "stop" })),
+      ).pipe(Stream.runCollect),
+    )
+    const runDir = await readOnlyRunDir(runsDir)
+    return readJson(runDir, "MODEL_WORK_PACKAGE.json")
+  }
+
+  test("a deterministic query run records code.query in active_pack_set and flips read-only", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "deepagent-feat002-query-"))
+    try {
+      const workPackage = await runMaxTurn(root, "请查一下数据库里有多少条用户记录")
+      expect(workPackage.active_pack_set).toContain("code.query")
+      // Same source: the recorded set is the retrieval-constrained activation (includes fallbacks).
+      expect(workPackage.active_pack_set).toContain("code.core")
+      expect(workPackage.deterministic_result.enabled).toBe(true)
+      expect(workPackage.deterministic_result.read_only).toBe(true)
+    } finally {
+      AgentGateway.configure({ enabled: false, runsDir: undefined })
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  test("a mutation run keeps code.query out of active_pack_set and tools writable", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "deepagent-feat002-mutation-"))
+    try {
+      const workPackage = await runMaxTurn(root, "请修复登录逻辑并更新依赖")
+      expect(workPackage.active_pack_set).not.toContain("code.query")
+      expect(workPackage.deterministic_result.enabled).toBe(false)
+      expect(workPackage.deterministic_result.read_only).toBe(false)
+    } finally {
+      AgentGateway.configure({ enabled: false, runsDir: undefined })
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+})
diff --git a/packages/core/test/compaction-continuation-fail-closed-migration.test.ts b/packages/core/test/compaction-continuation-fail-closed-migration.test.ts
new file mode 100644
index 00000000..1086f722
--- /dev/null
+++ b/packages/core/test/compaction-continuation-fail-closed-migration.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test"
+import { SqliteClient } from "@effect/sql-sqlite-bun"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
+import { Effect } from "effect"
+import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
+
+const migrationID = "20260820130000_compaction_continuation_fail_closed"
+const makeDb = EffectDrizzleSqlite.makeWithDefaults()
+
+const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
+  Effect.runPromise(effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped))
+
+// Seed a committed run whose continuation never reached admission (the BUG-407-009 incident
+// shape): continuation_state pending with no receipt binding.
+const seedPendingContinuation = (runID: string, sessionID: string) => `
+  INSERT INTO compaction_run (
+    run_id, session_id, from_prompt_epoch, target_prompt_epoch, trigger, state,
+    completion_reason, summary_text, recent_context, committed_at, committed_summary_message_id,
+    checkpoint_ref, checkpoint_hash, continuation_state, created_at,
+    source_window_id, source_effective_history_hash, source_message_count, source_projection_version
+  ) VALUES (
+    '${runID}', '${sessionID}', 0, 0, 'manual', 'committed',
+    'manual', 'summary', 'context', 1, 'msg-seed', 'checkpoint', 'hash', 'pending', 1,
+    'window', 'history-hash', 1, 1
+  )
+`
+
+describe("compaction continuation fail-closed migration", () => {
+  test("allows pending → failed without admission bindings and keeps the rest of the machine intact", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+
+        yield* db.run(`
+          INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+          VALUES ('project-fc', '/repo', '[]', 1, 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session (
+            id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+          ) VALUES ('session-fc', 'project-fc', 'fc', '/repo', 'Fail closed', '1', 0, 1, 1)
+        `)
+        yield* db.run(seedPendingContinuation("run-fc", "session-fc"))
+
+        // The fail-closed transition: pending → failed, no receipt id / admitted_at / terminal_at.
+        yield* db.run(`UPDATE compaction_run SET continuation_state = 'failed' WHERE run_id = 'run-fc'`)
+        const row = yield* db.get<{ continuation_state: string }>(
+          `SELECT continuation_state FROM compaction_run WHERE run_id = 'run-fc'`,
+        )
+        expect(row?.continuation_state).toBe("failed")
+
+        // The rest of the machine is unchanged: pending → settled stays illegal (skip admission).
+        yield* db.run(seedPendingContinuation("run-fc2", "session-fc"))
+        const illegal = yield* db
+          .run(`UPDATE compaction_run SET continuation_state = 'settled' WHERE run_id = 'run-fc2'`)
+          .pipe(Effect.exit)
+        expect(illegal._tag).toBe("Failure")
+
+        // failed → pending stays illegal (no resurrection).
+        const resurrect = yield* db
+          .run(`UPDATE compaction_run SET continuation_state = 'pending' WHERE run_id = 'run-fc'`)
+          .pipe(Effect.exit)
+        expect(resurrect._tag).toBe("Failure")
+      }),
+    )
+  })
+
+  test("migration registers after the stage-evidence batch and applies idempotently", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+        const tracked = yield* db.get<{ id: string }>(`SELECT id FROM migration WHERE id = '${migrationID}'`)
+        expect(tracked?.id).toBe(migrationID)
+        yield* DatabaseMigration.apply(db)
+        expect(
+          yield* db.get<{ count: number }>(`SELECT COUNT(*) AS count FROM migration WHERE id = '${migrationID}'`),
+        ).toEqual({ count: 1 })
+      }),
+    )
+  })
+})
diff --git a/packages/core/test/database-capability.test.ts b/packages/core/test/database-capability.test.ts
index 3114de6e..40158f75 100644
--- a/packages/core/test/database-capability.test.ts
+++ b/packages/core/test/database-capability.test.ts
@@ -39,7 +39,7 @@ describe("database capability", () => {
           Effect.gen(function* () {
             const { db } = yield* Database.Service
             yield* db.run(sql`DROP TRIGGER database_capability_immutable_update`)
-            yield* db.run(sql`UPDATE database_capability SET minimum_reader_protocol = 3, minimum_writer_protocol = 3
+            yield* db.run(sql`UPDATE database_capability SET minimum_reader_protocol = 4, minimum_writer_protocol = 4
               WHERE capability = 'bounded_event_snapshot_v1'`)
           }).pipe(Effect.provide(Database.layerFromPath(filename))),
         ),
@@ -52,4 +52,29 @@ describe("database capability", () => {
       await fs.rm(directory, { recursive: true, force: true })
     }
   })
+
+  test("opens a database marked with the successor fence at protocol 3", async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), "deepagent-code-db-capability-"))
+    const filename = path.join(directory, "database.db")
+    try {
+      await Effect.runPromise(
+        Effect.scoped(
+          Effect.gen(function* () {
+            const { db } = yield* Database.Service
+            yield* db.run(sql`
+              INSERT INTO database_capability(
+                capability, minimum_reader_protocol, minimum_writer_protocol, installed_at
+              ) VALUES ('provider_owner_successor_v1', 3, 3, 0)
+            `)
+          }).pipe(Effect.provide(Database.layerFromPath(filename))),
+        ),
+      )
+      const exit = await Effect.runPromise(
+        Effect.scoped(Database.Service.pipe(Effect.provide(Database.layerFromPath(filename)))).pipe(Effect.exit),
+      )
+      expect(exit._tag).toBe("Success")
+    } finally {
+      await fs.rm(directory, { recursive: true, force: true })
+    }
+  })
 })
diff --git a/packages/core/test/deepagent-event-bus.test.ts b/packages/core/test/deepagent-event-bus.test.ts
index c9a84210..dea3adeb 100644
--- a/packages/core/test/deepagent-event-bus.test.ts
+++ b/packages/core/test/deepagent-event-bus.test.ts
@@ -1,10 +1,15 @@
-import { describe, expect } from "bun:test"
-import { Effect, Fiber, Layer, Stream } from "effect"
+import { describe, expect, test } from "bun:test"
+import { Context, Effect, Fiber, Layer, Stream } from "effect"
 import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
 import { DeepAgentEvent } from "@deepagent-code/core/deepagent/deepagent-event"
-import { DeepAgentEventTable, DeepAgentEventDropTable } from "@deepagent-code/core/deepagent/deepagent-event-sql"
+import {
+  DeepAgentEventTable,
+  DeepAgentEventDropTable,
+  DeepAgentEventDeliveryTable,
+  DeepAgentConsumerGroupTable,
+} from "@deepagent-code/core/deepagent/deepagent-event-sql"
 import { Database } from "@deepagent-code/core/database/database"
-import { eq } from "drizzle-orm"
+import { and, asc, eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 
 // A deterministic mutable clock so retry-backoff / dedupe-window assertions are exact.
@@ -523,4 +528,244 @@ describe("DeepAgentEventBus publish latency (§F1)", () => {
       expect(row?.ms).toBe(0)
     }),
   )
+
+  it.effect("RISK-001: two claimants cannot claim the same due delivery", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(20_000)
+      const event = yield* bus.publish(input({ idempotencyKey: "claim-1" }))
+      yield* bus.nack({ subscriptionGroup: "router", eventID: event.id, reason: "boom" })
+      // due at 21_000 (backoff base 1000)
+      const first = yield* bus.claimDue({ subscriptionGroup: "router", claimantId: "a", now: 21_000 })
+      const second = yield* bus.claimDue({ subscriptionGroup: "router", claimantId: "b", now: 21_000 })
+      expect(first.deliveries.map((d) => d.eventID)).toEqual([event.id])
+      expect(second.deliveries).toEqual([])
+    }),
+  )
+
+  it.effect("RISK-001: an expired lease becomes re-claimable, stale ack is a no-op", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(30_000)
+      const event = yield* bus.publish(input({ idempotencyKey: "claim-2" }))
+      yield* bus.nack({ subscriptionGroup: "router", eventID: event.id, reason: "boom" })
+      const stale = yield* bus.claimDue({
+        subscriptionGroup: "router",
+        claimantId: "slow-worker",
+        now: 31_000,
+        leaseMs: 5_000,
+      })
+      expect(stale.deliveries).toHaveLength(1)
+      // lease expired at 36_000 → a fresh claimant wins the row.
+      const fresh = yield* bus.claimDue({
+        subscriptionGroup: "router",
+        claimantId: "fresh-worker",
+        now: 36_001,
+        leaseMs: 5_000,
+      })
+      expect(fresh.deliveries.map((d) => d.eventID)).toEqual([event.id])
+      // the stale token can no longer settle the delivery…
+      const staleAck = yield* bus.ackClaim({
+        subscriptionGroup: "router",
+        eventID: event.id,
+        claimToken: stale.claimToken,
+      })
+      expect(staleAck).toBe(false)
+      // …but the fresh token can.
+      const freshAck = yield* bus.ackClaim({
+        subscriptionGroup: "router",
+        eventID: event.id,
+        claimToken: fresh.claimToken,
+      })
+      expect(freshAck).toBe(true)
+      const due = yield* bus.dueRetries(99_999)
+      expect(due.filter((d) => d.eventID === event.id)).toEqual([])
+    }),
+  )
+
+  it.effect("RISK-001: nackClaim releases the claim and schedules backoff", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(40_000)
+      const event = yield* bus.publish(input({ idempotencyKey: "claim-3" }))
+      yield* bus.nack({ subscriptionGroup: "router", eventID: event.id, reason: "boom" })
+      const claim = yield* bus.claimDue({ subscriptionGroup: "router", claimantId: "w", now: 41_000 })
+      const applied = yield* bus.nackClaim({
+        subscriptionGroup: "router",
+        eventID: event.id,
+        claimToken: claim.claimToken,
+        reason: "still failing",
+      })
+      expect(applied).toBe(true)
+      // claim released → immediately re-claimable once the new backoff (attempt 2 → +2000) elapses.
+      const early = yield* bus.claimDue({ subscriptionGroup: "router", claimantId: "w2", now: 41_001 })
+      expect(early.deliveries).toEqual([])
+      const later = yield* bus.claimDue({ subscriptionGroup: "router", claimantId: "w2", now: 43_000 })
+      expect(later.deliveries.map((d) => d.eventID)).toEqual([event.id])
+      expect(later.deliveries[0]?.attempts).toBe(2)
+    }),
+  )
+
+  it.effect("RISK-001: null-lease legacy rows remain claimable", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(50_000)
+      const event = yield* bus.publish(input({ idempotencyKey: "claim-4" }))
+      // plain nack creates a pending row without claim columns (legacy shape)
+      yield* bus.nack({ subscriptionGroup: "router", eventID: event.id, reason: "boom" })
+      const claim = yield* bus.claimDue({ subscriptionGroup: "router", claimantId: "w", now: 51_000 })
+      expect(claim.deliveries.map((d) => d.eventID)).toEqual([event.id])
+    }),
+  )
+})
+
+describe("DeepAgentEventBus RISK-006 (multi-process extensions)", () => {
+  it.effect("consumer groups from different workspaces coexist (workspace_id persisted, default '')", () =>
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(1_000)
+      yield* bus.registerConsumerGroup("grp-a", undefined, "wrk_a")
+      yield* bus.registerConsumerGroup("grp-b", "ci.failure", "wrk_b")
+      yield* bus.registerConsumerGroup("grp-legacy") // no workspaceID → "" (back-compat)
+      const rows = yield* db
+        .select()
+        .from(DeepAgentConsumerGroupTable)
+        .orderBy(asc(DeepAgentConsumerGroupTable.group_id))
+        .all()
+        .pipe(Effect.orDie)
+      expect(rows.map((r) => [r.group_id, r.workspace_id])).toEqual([
+        ["grp-a", "wrk_a"],
+        ["grp-b", "wrk_b"],
+        ["grp-legacy", ""],
+      ])
+      // RISK-006 residual — delivery routing is workspace-scoped: a wrk_a event is owed to the
+      // wrk_a group and the global ("") group, but NOT to the wrk_b group.
+      yield* bus.publish(input({ idempotencyKey: "ws-1", workspaceID: "wrk_a" }))
+      const due = yield* bus.dueRetries(2_000)
+      expect(due.map((d) => d.subscriptionGroup).sort()).toEqual(["grp-a", "grp-legacy"])
+      // unregister stays keyed by group_id only (compat)
+      yield* bus.unregisterConsumerGroup("grp-a")
+      const remaining = yield* db
+        .select({ group_id: DeepAgentConsumerGroupTable.group_id })
+        .from(DeepAgentConsumerGroupTable)
+        .orderBy(asc(DeepAgentConsumerGroupTable.group_id))
+        .all()
+        .pipe(Effect.orDie)
+      expect(remaining.map((r) => r.group_id)).toEqual(["grp-b", "grp-legacy"])
+      // re-registering upserts workspace_id (idempotent)
+      yield* bus.registerConsumerGroup("grp-b", "ci.failure", "wrk_c")
+      const moved = yield* db
+        .select({ workspace_id: DeepAgentConsumerGroupTable.workspace_id })
+        .from(DeepAgentConsumerGroupTable)
+        .where(eq(DeepAgentConsumerGroupTable.group_id, "grp-b"))
+        .get()
+        .pipe(Effect.orDie)
+      expect(moved?.workspace_id).toBe("wrk_c")
+    }),
+  )
+
+  it.effect("high/critical deliveries are returned by dueRetries/claimDue before normal/low", () =>
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(100_000)
+      yield* bus.registerConsumerGroup("prio-grp", undefined, "wrk_p")
+      const low = yield* bus.publish(input({ idempotencyKey: "p-low", priority: "low", workspaceID: "wrk_p" }))
+      setNow(100_001)
+      const normal = yield* bus.publish(input({ idempotencyKey: "p-normal", priority: "normal", workspaceID: "wrk_p" }))
+      setNow(100_002)
+      const high = yield* bus.publish(input({ idempotencyKey: "p-high", priority: "high", workspaceID: "wrk_p" }))
+      setNow(100_003)
+      const critical = yield* bus.publish(input({ idempotencyKey: "p-crit", priority: "critical", workspaceID: "wrk_p" }))
+      // the event's priority is denormalized onto the delivery row at publish time.
+      const hiRow = yield* db
+        .select({ priority: DeepAgentEventDeliveryTable.priority })
+        .from(DeepAgentEventDeliveryTable)
+        .where(
+          and(
+            eq(DeepAgentEventDeliveryTable.event_id, high.id),
+            eq(DeepAgentEventDeliveryTable.subscription_group, "prio-grp"),
+          ),
+        )
+        .get()
+        .pipe(Effect.orDie)
+      expect(hiRow?.priority).toBe("high")
+      // dueRetries orders priority DESC even though normal was owed EARLIER than high/critical.
+      const due = yield* bus.dueRetries(100_004)
+      expect(due.map((d) => d.eventID)).toEqual([critical.id, high.id, normal.id, low.id])
+      // claimDue follows the same persistent ordering.
+      const claim = yield* bus.claimDue({ subscriptionGroup: "prio-grp", claimantId: "w", now: 100_004, limit: 10 })
+      expect(claim.deliveries.map((d) => d.eventID)).toEqual([critical.id, high.id, normal.id, low.id])
+    }),
+  )
+
+  it.effect("NULL-priority legacy delivery rows rank as normal in the ordering", () =>
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      const bus = yield* DeepAgentEventBus.Service
+      setNow(200_000)
+      yield* bus.registerConsumerGroup("null-grp", undefined, "wrk_n")
+      const low = yield* bus.publish(input({ idempotencyKey: "np-low", priority: "low", workspaceID: "wrk_n" }))
+      setNow(200_001)
+      const legacy = yield* bus.publish(input({ idempotencyKey: "np-legacy", workspaceID: "wrk_n" }))
+      setNow(200_002)
+      const high = yield* bus.publish(input({ idempotencyKey: "np-high", priority: "high", workspaceID: "wrk_n" }))
+      // simulate a pre-migration row: NULL priority reads back as "normal".
+      yield* db
+        .update(DeepAgentEventDeliveryTable)
+        .set({ priority: null })
+        .where(
+          and(
+            eq(DeepAgentEventDeliveryTable.event_id, legacy.id),
+            eq(DeepAgentEventDeliveryTable.subscription_group, "null-grp"),
+          ),
+        )
+        .run()
+        .pipe(Effect.orDie)
+      const due = yield* bus.dueRetries(200_003)
+      expect(due.map((d) => d.eventID)).toEqual([high.id, legacy.id, low.id])
+    }),
+  )
+})
+
+describe("DeepAgentEventBus RISK-006 durable rate limiter (multi-process semantics)", () => {
+  // The core multi-process test: TWO independent bus instances (each builds its own layer, exactly
+  // like two OS processes) over ONE shared DB must enforce ONE combined per-workspace quota — the
+  // old in-memory Map gave every instance its own (quota ×N). The ONE database layer is built
+  // once and handed to two bus layers built independently on top of it.
+  test("two bus instances sharing one DB enforce ONE combined quota per workspace", () =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        const dbService = Context.get(yield* Layer.build(Database.layerFromPath(":memory:")), Database.Service)
+        const mkBus = () =>
+          DeepAgentEventBus.layerWith({ now }).pipe(Layer.provide(Layer.succeed(Database.Service, dbService)))
+        const busA = Context.get(yield* Layer.build(mkBus()), DeepAgentEventBus.Service)
+        const busB = Context.get(yield* Layer.build(mkBus()), DeepAgentEventBus.Service)
+        const mkInput = (key: string, workspaceID: string): DeepAgentEvent.PublishInput => ({
+          type: "ci.failure",
+          source: "ci",
+          workspaceID,
+          payload: {},
+          idempotencyKey: key,
+        })
+        setNow(300_000)
+        // instance A consumes the whole limit=2 quota of wrk_mp.
+        const r1 = yield* busA.tryPublish(mkInput("mp-a1", "wrk_mp"), { limit: 2 })
+        const r2 = yield* busA.tryPublish(mkInput("mp-a2", "wrk_mp"), { limit: 2 })
+        expect("published" in r1).toBe(true)
+        expect("published" in r2).toBe(true)
+        // instance B (fresh in-memory state, SAME durable buckets) sees the quota already exhausted.
+        const dropped = yield* busB.tryPublish(mkInput("mp-b1", "wrk_mp"), { limit: 2 })
+        expect(dropped).toEqual({ dropped: "rate_limited" })
+        // …but another workspace's quota is untouched (still per-workspace, just durable now).
+        const other = yield* busB.tryPublish(mkInput("mp-b2", "wrk_other"), { limit: 2 })
+        expect("published" in other).toBe(true)
+        // crossing the fixed window re-admits (epoch-aligned windows agree across instances).
+        setNow(360_001)
+        const after = yield* busB.tryPublish(mkInput("mp-a3", "wrk_mp"), { limit: 2 })
+        expect("published" in after).toBe(true)
+      }).pipe(Effect.scoped),
+    ),
+  )
 })
diff --git a/packages/core/test/deepagent/activity-authority-facade.test.ts b/packages/core/test/deepagent/activity-authority-facade.test.ts
new file mode 100644
index 00000000..d82fc114
--- /dev/null
+++ b/packages/core/test/deepagent/activity-authority-facade.test.ts
@@ -0,0 +1,432 @@
+import { describe, expect, test } from "bun:test"
+import { SqliteClient } from "@effect/sql-sqlite-bun"
+import { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
+import { Effect, Exit } from "effect"
+import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import { migrations } from "@deepagent-code/core/database/migration.gen"
+import facadeActivityMigration from "@deepagent-code/core/database/migration/20260816073717_session_facade_activity"
+import { DeepAgentActivityAuthority } from "@deepagent-code/core/deepagent/activity-authority"
+
+const makeDb = EffectDrizzleSqlite.makeWithDefaults()
+const facadeRef = (activityID: string) => ({ activityKind: "facade" as const, activityID })
+
+describe("DeepAgentActivityAuthority facade branch (FEAT-011 T1+T2)", () => {
+  test("fresh path applies the facade migration and reapplication is journal-idempotent", async () => {
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run("PRAGMA foreign_keys = ON")
+        yield* DatabaseMigration.apply(db)
+        yield* DatabaseMigration.applyOnly(db, [facadeActivityMigration])
+        expect(
+          yield* db.get("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session_facade_activity'"),
+        ).toEqual({ name: "session_facade_activity" })
+        expect(
+          yield* db.get(
+            "SELECT count(*) AS count FROM migration WHERE id = '20260816073717_session_facade_activity'",
+          ),
+        ).toEqual({ count: 1 })
+        // The isolation fence stays intact: the objective table keeps its ('legacy','v2') CHECK.
+        expect(
+          yield* db.get(
+            "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'session_activity_objective' AND sql LIKE '%facade%'",
+          ),
+        ).toBeUndefined()
+      }).pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+    )
+  })
+
+  test("upgrade path preserves legacy/v2 objective rows and keeps the kind CHECK fenced", async () => {
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run("PRAGMA foreign_keys = ON")
+        const facadeIndex = migrations.findIndex((migration) => migration.id === facadeActivityMigration.id)
+        expect(facadeIndex).toBeGreaterThan(0)
+        yield* DatabaseMigration.applyOnly(db, migrations.slice(0, facadeIndex))
+        yield* seed(db)
+        // Seed one legacy and one v2 objective row before the facade migration runs.
+        yield* db.run(
+          "INSERT INTO session_input (id, session_id, prompt, delivery, admitted_seq, promoted_seq, time_created) VALUES ('upgrade-input', 'session-1', '{}', 'queue', 1, 1, 30)",
+        )
+        // Both objective rows are auto-projected by admission triggers (legacy during seed,
+        // v2 on session_activity insert); the facade migration must preserve them untouched.
+        yield* db.run(
+          "INSERT INTO session_activity (activity_id, session_id, ordinal, trigger_input_id, delivery, state, created_at, settled_at) VALUES ('upgrade-v2', 'session-1', 0, 'upgrade-input', 'queue', 'active', 30, NULL)",
+        )
+
+        yield* DatabaseMigration.applyOnly(db, [facadeActivityMigration])
+
+        expect(
+          yield* db.all(
+            "SELECT activity_kind, activity_id, version, state, admission_fingerprint FROM session_activity_objective ORDER BY activity_kind",
+          ),
+        ).toEqual([
+          {
+            activity_kind: "legacy",
+            activity_id: "activity-1",
+            version: 1,
+            state: "active",
+            admission_fingerprint: "admission-payload-1",
+          },
+          {
+            activity_kind: "v2",
+            activity_id: "upgrade-v2",
+            version: 1,
+            state: "active",
+            admission_fingerprint: "session-input:upgrade-input",
+          },
+        ])
+        // The facade base table accepts new rows, while the objective CHECK keeps rejecting
+        // 'facade' — that CHECK is the isolation fence between facade and the federation machinery.
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-upgrade', 'panel', 'session-1', 'active', 40, 0)",
+        )
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "INSERT INTO session_activity_objective (activity_kind, activity_id, session_id, version, admission_fingerprint, completion_criteria, enforcement_state, state, no_progress_count, latest_observation_revision, created_at, updated_at) VALUES ('facade', 'facade-upgrade', 'session-1', 1, 'facade-spawn:facade-upgrade', '[]', 'disabled', 'active', 0, -1, 40, 40)",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+      }).pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+    )
+  })
+
+  test("facade never owns an objective row: reconstruct fails closed with NotFoundError", async () => {
+    await run(
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, spawn_tool_call_id, state, created_at, mutation_epoch) VALUES ('facade-spawned', 'task', 'session-1', 'call-spawn-1', 'active', 40, 0)",
+        )
+        // Facade settlement bypasses the objective table entirely, so reconstruct has nothing
+        // to read and must fail closed instead of leaking into the v2 branch.
+        const notFound = yield* DeepAgentActivityAuthority.reconstruct(facadeRef("facade-spawned")).pipe(
+          Effect.flip,
+        )
+        expect(notFound._tag).toBe("ActivityAuthority.NotFoundError")
+        expect(notFound).toMatchObject({ activityKind: "facade", activityID: "facade-spawned" })
+        // And objective rows for facade stay rejected at the schema level.
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "INSERT INTO session_activity_objective (activity_kind, activity_id, session_id, version, admission_fingerprint, completion_criteria, enforcement_state, state, no_progress_count, latest_observation_revision, created_at, updated_at) VALUES ('facade', 'facade-nonexistent', 'session-1', 1, 'forged', '[]', 'disabled', 'active', 0, -1, 40, 40)",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+      }),
+    )
+  })
+
+  test("preserves facade terminal reasons and exact retries for every terminal state", async () => {
+    for (const [state, baseState] of [
+      ["completed", "settled"],
+      ["interrupted", "interrupted"],
+      ["recovery_required", "failed"],
+    ] as const) {
+      await run(
+        Effect.gen(function* () {
+          const activityID = "facade-settle-" + state
+          const facadeRefForState = facadeRef(activityID)
+          const terminalReason = "terminal-reason-" + state
+          const { db } = yield* Database.Service
+          yield* db.run(
+            `INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('${activityID}', 'goal', 'session-1', 'active', 40, 0)`,
+          )
+
+          // Fresh rows start at mutation_epoch 0; settlement bumps it to 1.
+          const settled = yield* DeepAgentActivityAuthority.settle({
+            ...facadeRefForState,
+            expectedVersion: 0,
+            state,
+            terminalReason,
+          })
+          expect(settled).toMatchObject({
+            activityKind: "facade",
+            version: 1,
+            state,
+            terminalReason,
+            sessionID: "session-1",
+          })
+          // Exact retry is idempotent: same terminal state + reason returns the same projection.
+          expect(
+            yield* DeepAgentActivityAuthority.settle({
+              ...facadeRefForState,
+              expectedVersion: 0,
+              state,
+              terminalReason,
+            }),
+          ).toEqual(settled)
+          // Three-state mapping lands on the base table; no objective row is ever written.
+          expect(
+            yield* db.get(
+              `SELECT state, reason_code FROM session_facade_activity WHERE activity_id = '${activityID}'`,
+            ),
+          ).toEqual({ state: baseState, reason_code: terminalReason })
+          expect(
+            yield* db.get(
+              `SELECT count(*) AS count FROM session_activity_objective WHERE activity_kind = 'facade' AND activity_id = '${activityID}'`,
+            ),
+          ).toEqual({ count: 0 })
+        }),
+      )
+    }
+  })
+
+  test("facade settlement is CAS-guarded against version and base drift", async () => {
+    await run(
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-cas', 'panel', 'session-1', 'active', 40, 0)",
+        )
+        // Stale expectedVersion (mutation_epoch token) fails closed before touching the base table.
+        expect(
+          Exit.isFailure(
+            yield* DeepAgentActivityAuthority.settle({
+              ...facadeRef("facade-cas"),
+              expectedVersion: 99,
+              state: "completed",
+              terminalReason: "stale_version",
+            }).pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        expect(
+          yield* db.get("SELECT state FROM session_facade_activity WHERE activity_id = 'facade-cas'"),
+        ).toEqual({ state: "active" })
+
+        // A base that was settled out of band conflicts on settle (no replayable transition).
+        yield* db.run(
+          "UPDATE session_facade_activity SET state = 'interrupted', reason_code = 'out_of_band', settled_at = 41 WHERE activity_id = 'facade-cas'",
+        )
+        expect(
+          Exit.isFailure(
+            yield* DeepAgentActivityAuthority.settle({
+              ...facadeRef("facade-cas"),
+              expectedVersion: 0,
+              state: "completed",
+              terminalReason: "activity_complete",
+            }).pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        expect(
+          yield* db.get("SELECT state, reason_code FROM session_facade_activity WHERE activity_id = 'facade-cas'"),
+        ).toEqual({ state: "interrupted", reason_code: "out_of_band" })
+
+        // Settling an already-terminal base with a different outcome is rejected.
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-cas-terminal', 'task', 'session-1', 'active', 42, 0)",
+        )
+        yield* DeepAgentActivityAuthority.settle({
+          ...facadeRef("facade-cas-terminal"),
+          expectedVersion: 0,
+          state: "interrupted",
+          terminalReason: "first_interrupt",
+        })
+        expect(
+          Exit.isFailure(
+            yield* DeepAgentActivityAuthority.settle({
+              ...facadeRef("facade-cas-terminal"),
+              expectedVersion: 1,
+              state: "completed",
+              terminalReason: "late_completion",
+            }).pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        expect(
+          yield* db.get(
+            "SELECT state, reason_code FROM session_facade_activity WHERE activity_id = 'facade-cas-terminal'",
+          ),
+        ).toEqual({ state: "interrupted", reason_code: "first_interrupt" })
+
+        // Settling an unknown facade activity fails closed with NotFoundError.
+        const missing = yield* DeepAgentActivityAuthority.settle({
+          ...facadeRef("facade-missing"),
+          expectedVersion: 0,
+          state: "completed",
+          terminalReason: "missing",
+        }).pipe(Effect.flip)
+        expect(missing._tag).toBe("ActivityAuthority.NotFoundError")
+        expect(missing).toMatchObject({ activityKind: "facade", activityID: "facade-missing" })
+      }),
+    )
+  })
+
+  test("partial unique index fails closed on a second active facade activity per parent and subkind", async () => {
+    await run(
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-index-first', 'task', 'session-1', 'active', 40, 0)",
+        )
+        // Same parent + subkind while the first is still active: BUG-004 shape is rejected.
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-index-second', 'task', 'session-1', 'active', 41, 0)",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        // A different subkind does not collide.
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-index-other-subkind', 'goal', 'session-1', 'active', 42, 0)",
+        )
+        // Settling frees the slot for the next active activity of that subkind.
+        yield* DeepAgentActivityAuthority.settle({
+          ...facadeRef("facade-index-first"),
+          expectedVersion: 0,
+          state: "completed",
+          terminalReason: "activity_complete",
+        })
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-index-next', 'task', 'session-1', 'active', 43, 0)",
+        )
+        expect(
+          yield* db.get(
+            "SELECT count(*) AS count FROM session_facade_activity WHERE parent_session_id = 'session-1' AND subkind = 'task' AND state = 'active'",
+          ),
+        ).toEqual({ count: 1 })
+      }),
+    )
+  })
+
+  test("facade base lifecycle triggers mirror the legacy legal-update fence", async () => {
+    await run(
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-lifecycle', 'task', 'session-1', 'active', 40, 0)",
+        )
+        // Binding columns (including source) are immutable.
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run("UPDATE session_facade_activity SET subkind = 'goal' WHERE activity_id = 'facade-lifecycle'")
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run("UPDATE session_facade_activity SET source = 'forged' WHERE activity_id = 'facade-lifecycle'")
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        // Terminal transitions require settled_at + reason_code in one shot.
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "UPDATE session_facade_activity SET state = 'settled', settled_at = 41 WHERE activity_id = 'facade-lifecycle'",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        yield* db.run(
+          "UPDATE session_facade_activity SET state = 'settled', reason_code = 'stop', settled_at = 41, mutation_epoch = mutation_epoch + 1 WHERE activity_id = 'facade-lifecycle'",
+        )
+        // Terminal rows are single-shot: no further updates are legal.
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "UPDATE session_facade_activity SET state = 'interrupted', reason_code = 'late', settled_at = 42 WHERE activity_id = 'facade-lifecycle'",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+      }),
+    )
+  })
+
+  test("recoverActivityToRequired facade branch is fenced fail-closed by permission child tables", async () => {
+    await run(
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* db.run(
+          "INSERT INTO session_facade_activity (activity_id, subkind, parent_session_id, state, created_at, mutation_epoch) VALUES ('facade-recover', 'panel', 'session-1', 'active', 40, 0)",
+        )
+        // T1 scope keeps permission request/dispatch child tables on ('legacy','v2') CHECKs, so
+        // facade activities can never own a started permission effect; the recover branch's
+        // objective-table CAS is unreachable for facade and the fence guarantees it. Recovery
+        // intent for facade is expressed through settle(state: 'recovery_required') → 'failed'.
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "INSERT INTO session_activity_permission_request (request_id, activity_kind, activity_id, session_id, project_id, request_kind, idempotency_key, permission, patterns, always_patterns, metadata_hash, state, authority_epoch, requested_scope, owner_type, owner_id, created_at) VALUES ('facade-recover-request', 'facade', 'facade-recover', 'session-1', 'project-1', 'tool', 'facade-recover-key', 'bash', '[\"touch facade\"]', '[\"touch facade\"]', 'meta-1', 'pending', 0, 'once', 'runtime', 'runtime-facade', 40)",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        expect(
+          Exit.isFailure(
+            yield* db
+              .run(
+                "INSERT INTO session_activity_permission_effect_dispatch (receipt_id, request_id, activity_kind, activity_id, session_id, project_id, tool_message_id, tool_call_id, tool_name, consumer_id, idempotency_key, owner_id, state, version, started_at) VALUES ('facade-recover-receipt', 'request-missing', 'facade', 'facade-recover', 'session-1', 'project-1', 'assistant-facade', 'call-facade', 'bash', 'tool:assistant-facade:call-facade', 'facade-recover-effect', 'runtime-facade', 'started', 1, 40)",
+              )
+              .pipe(Effect.exit),
+          ),
+        ).toBe(true)
+        // Recovery-required settlement lands as base state 'failed' (v2 mapping), leaving the
+        // base in a terminal shape that recoverActivityToRequired would recognize as done.
+        const settled = yield* DeepAgentActivityAuthority.settle({
+          ...facadeRef("facade-recover"),
+          expectedVersion: 0,
+          state: "recovery_required",
+          terminalReason: "permission_effect_outcome_unknown_after_restart",
+        })
+        expect(settled).toMatchObject({ version: 1, state: "recovery_required" })
+        expect(
+          yield* db.get("SELECT state, reason_code FROM session_facade_activity WHERE activity_id = 'facade-recover'"),
+        ).toEqual({ state: "failed", reason_code: "permission_effect_outcome_unknown_after_restart" })
+      }),
+    )
+  })
+})
+
+function run<A, E>(effect: Effect.Effect<A, E, Database.Service>) {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const db = yield* makeDb
+      yield* db.run("PRAGMA foreign_keys = ON")
+      yield* DatabaseMigration.apply(db)
+      yield* seed(db)
+      return yield* effect.pipe(Effect.provideService(Database.Service, { db }))
+    }).pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+  )
+}
+
+function seed(db: Effect.Success<typeof makeDb>) {
+  return Effect.gen(function* () {
+    yield* db.run(
+      "INSERT INTO project (id, worktree, sandboxes, time_created, time_updated) VALUES ('project-1', '/tmp/project-1', '[]', 1, 1)",
+    )
+    yield* db.run(
+      "INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_updated) VALUES ('session-1', 'project-1', 'session-1', '/tmp/project-1', 'Activity', '1', 1, 1)",
+    )
+    yield* db.run(
+      "INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_updated) VALUES ('session-2', 'project-1', 'session-2', '/tmp/project-1', 'Other', '1', 1, 1)",
+    )
+    yield* db.run(
+      "INSERT INTO session_intent (intent_id, session_id, source, state, selected_variant, selected_payload_hash, delivery, admitted_message_id, mutation_epoch, version, time_created, time_admitted, time_updated) VALUES ('intent-1', 'session-1', 'composer', 'admitted', 'original', 'admission-payload-1', 'turn', 'message-1', 0, 1, 1, 1, 1)",
+    )
+    yield* db.run(
+      "INSERT INTO session_activity_admission (admission_id, session_id, source_kind, legacy_intent_id, admitted_message_id, delivery, payload_fingerprint_kind, payload_fingerprint, created_at) VALUES ('admission-1', 'session-1', 'legacy_intent', 'intent-1', 'message-1', 'turn', 'payload_hash', 'admission-payload-1', 1)",
+    )
+    yield* db.run(
+      "INSERT INTO session_legacy_activity (activity_id, session_id, ordinal, trigger_admission_id, owner_token, state, terminal_reason, created_at, settled_at) VALUES ('activity-1', 'session-1', 0, 'admission-1', 'owner-1', 'active', NULL, 1, NULL)",
+    )
+    yield* db.run(
+      "INSERT INTO session_legacy_activity_admission (activity_id, admission_id, ordinal, role, attached_at) VALUES ('activity-1', 'admission-1', 0, 'trigger', 1)",
+    )
+  })
+}
diff --git a/packages/core/test/deepagent/domain-pack-retrieval-isolation.test.ts b/packages/core/test/deepagent/domain-pack-retrieval-isolation.test.ts
index 706678e2..3e7693dd 100644
--- a/packages/core/test/deepagent/domain-pack-retrieval-isolation.test.ts
+++ b/packages/core/test/deepagent/domain-pack-retrieval-isolation.test.ts
@@ -6,6 +6,7 @@ import * as knowledgeSource from "../../src/deepagent/knowledge-source"
 import { seedCoreKnowledge } from "../../src/deepagent/knowledge-seed"
 import { openUserGlobalStore } from "../../src/deepagent/durable-knowledge-store"
 import { retrieve } from "../../src/deepagent/knowledge-retriever"
+import type { ActivateOptions } from "../../src/deepagent/domain-pack"
 import type { TaskContext, ToolContext } from "../../src/deepagent/prompt-policy"
 import type { Selection } from "../../src/deepagent/released-snapshot"
 import { releasedUserGlobalSelection } from "./released-selection-fixture"
@@ -33,7 +34,7 @@ const task = (userRequest: string): TaskContext => ({
   validationCommands: [],
 })
 
-const selectedRefs = (userRequest: string, releasedSelection: Selection) => {
+const selectedRefs = (userRequest: string, releasedSelection: Selection, domainOptions?: ActivateOptions) => {
   const result = retrieve({
     mode: "max",
     task: task(userRequest),
@@ -41,6 +42,7 @@ const selectedRefs = (userRequest: string, releasedSelection: Selection) => {
     round: 1,
     previousFailures: 0,
     releasedSelection,
+    ...(domainOptions ? { domainOptions } : {}),
   })
   return [...(result?.strategyRefs ?? []), ...(result?.methodologyRefs ?? [])]
 }
@@ -147,4 +149,40 @@ describe("domain pack retrieval isolation", () => {
       )
     })
   })
+
+  // FEAT-001: pinned packs (user overrides) must force their refs into the selection even when
+  // the task text activates the pack nowhere.
+  describe("pinned packs (domainOptions overrides)", () => {
+    const genericTask = "rename a local helper function in the user service module"
+
+    test("unpinned generic task does not select gpu refs", () => {
+      withSeededKnowledge((releasedSelection) => {
+        expectDomainSelection(genericTask, [], releasedSelection, ["gpu"])
+      })
+    })
+
+    test("legacy single-value override still force-selects the pinned pack refs", () => {
+      withSeededKnowledge((releasedSelection) => {
+        const refs = selectedRefs(genericTask, releasedSelection, { override: "code.gpu-kernel" })
+        expect(refs.some((ref) => ref.includes("gpu"))).toBe(true)
+      })
+    })
+
+    test("multi-pin overrides force-select every pinned pack's refs", () => {
+      withSeededKnowledge((releasedSelection) => {
+        const refs = selectedRefs(genericTask, releasedSelection, { overrides: ["code.gpu-kernel"] })
+        expect(refs.some((ref) => ref.includes("gpu"))).toBe(true)
+      })
+    })
+
+    test("override and overrides merge without duplicates", () => {
+      withSeededKnowledge((releasedSelection) => {
+        const refs = selectedRefs(genericTask, releasedSelection, {
+          override: "code.gpu-kernel",
+          overrides: ["code.gpu-kernel"],
+        })
+        expect(refs.some((ref) => ref.includes("gpu"))).toBe(true)
+      })
+    })
+  })
 })
diff --git a/packages/core/test/deepagent/pack-activation-authority.test.ts b/packages/core/test/deepagent/pack-activation-authority.test.ts
new file mode 100644
index 00000000..e540cfff
--- /dev/null
+++ b/packages/core/test/deepagent/pack-activation-authority.test.ts
@@ -0,0 +1,126 @@
+// FEAT-002 regression suite: ONE pack-activation authority per run. Locks that the unified
+// gateway profile (profile-builder.buildProfile) and the retriever's activationForProfile produce
+// the same active pack set, and that the deterministic read-only policy flip follows that SAME
+// active_pack_set the run records. Also pins the pre/post-unification verdict comparison so the
+// deterministic-task.ts:86-91 `activePackIds.includes("code.query")` flip cannot silently regress.
+
+import { describe, expect, test, beforeAll } from "bun:test"
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { buildProfile } from "../../src/deepagent/profile-builder"
+import { activationForProfile } from "../../src/deepagent/knowledge-retriever"
+import { configureRegistry, type ExtendedProblemProfile } from "../../src/deepagent/domain-pack-registry"
+import { deterministicToolPolicy, shouldActivateQueryControls } from "../../src/deepagent/deterministic-task"
+
+beforeAll(() => configureRegistry(undefined))
+
+const withWorkspace = (fn: (cwd: string) => void) => {
+  const cwd = mkdtempSync(path.join(tmpdir(), "deepagent-feat002-"))
+  try {
+    fn(cwd)
+  } finally {
+    rmSync(cwd, { recursive: true, force: true })
+  }
+}
+
+// The pre-FEAT-002 profile the gateway hardcoded for the recorded pack snapshot (audit finding:
+// scenario_mode/task_kind/languages fixed, repo_signals = run.input.feature only).
+const legacyHardcodedProfile = (feature: string): ExtendedProblemProfile => ({
+  scenario_mode: "intelligence",
+  agent_strength: "high",
+  task_kind: "implement",
+  code_domains: ["code"],
+  business_domains: [],
+  platforms: [],
+  languages: ["typescript"],
+  frameworks: [],
+  data_classes: [],
+  risk_markers: [],
+  repo_signals: [feature],
+  round_signals: [],
+  user_overrides: [],
+})
+
+describe("FEAT-002 unified pack activation authority", () => {
+  test("read-only query request activates code.query and flips the deterministic policy read-only", () => {
+    withWorkspace((cwd) => {
+      const request = "请查一下数据库里有多少条用户记录"
+      const profile = buildProfile({ cwd, agentMode: "max", scenarioMode: "intelligence", userRequest: request })
+      const activation = activationForProfile(profile)
+      expect(activation.activePackIds).toContain("code.query")
+      const policy = deterministicToolPolicy({ raw: request, activePackIds: activation.activePackIds })
+      expect(policy.read_only).toBe(true)
+      expect(policy.denied_actions).toContain("update")
+    })
+  })
+
+  test("mutation request never activates code.query and keeps mutation tools allowed", () => {
+    withWorkspace((cwd) => {
+      const request = "请修复登录逻辑并更新依赖"
+      const profile = buildProfile({ cwd, agentMode: "max", scenarioMode: "intelligence", userRequest: request })
+      const activation = activationForProfile(profile)
+      expect(activation.activePackIds).not.toContain("code.query")
+      expect(deterministicToolPolicy({ raw: request, activePackIds: activation.activePackIds }).read_only).toBe(false)
+    })
+  })
+
+  test("authority flip: state-inspection queries missed by the legacy hardcoded profile are now covered", () => {
+    withWorkspace((cwd) => {
+      const request = "看一下当前状态"
+      // Pre-unification record truth: the hardcoded profile could NOT activate code.query here.
+      const legacy = activationForProfile(legacyHardcodedProfile(request))
+      expect(legacy.activePackIds).not.toContain("code.query")
+      // Post-unification: the single authoritative profile activates it.
+      const unified = activationForProfile(
+        buildProfile({ cwd, agentMode: "max", scenarioMode: "intelligence", userRequest: request }),
+      )
+      expect(unified.activePackIds).toContain("code.query")
+      // The deterministic verdict stays read-only on BOTH sides — the flip is about WHO decides
+      // (pack authority), and the verdict must not regress in either direction.
+      expect(shouldActivateQueryControls({ raw: request, activePackIds: legacy.activePackIds })).toBe(true)
+      expect(shouldActivateQueryControls({ raw: request, activePackIds: unified.activePackIds })).toBe(true)
+    })
+  })
+
+  test("count queries activated under the legacy profile stay activated after unification", () => {
+    withWorkspace((cwd) => {
+      const request = "请查一下数据库里有多少条用户记录"
+      const legacy = activationForProfile(legacyHardcodedProfile(request))
+      const unified = activationForProfile(
+        buildProfile({ cwd, agentMode: "max", scenarioMode: "intelligence", userRequest: request }),
+      )
+      // Both authorities agree on the pack that drives the read-only flip — no silent regression.
+      expect(legacy.activePackIds).toContain("code.query")
+      expect(unified.activePackIds).toContain("code.query")
+      expect(deterministicToolPolicy({ raw: request, activePackIds: unified.activePackIds }).read_only).toBe(true)
+    })
+  })
+
+  test("active_pack_set membership alone can activate query controls (deterministic-task.ts:86-91 lock)", () => {
+    const neutral = "run the scheduled job"
+    expect(shouldActivateQueryControls({ raw: neutral })).toBe(false)
+    expect(shouldActivateQueryControls({ raw: neutral, activePackIds: ["code.query"] })).toBe(true)
+    // Mutation intent still wins even when code.query is active (locked behavior).
+    expect(shouldActivateQueryControls({ raw: "请删除旧记录", activePackIds: ["code.query"] })).toBe(false)
+  })
+
+  test("activation is deterministic and honors pinned overrides (FEAT-001 behavior preserved)", () => {
+    withWorkspace((cwd) => {
+      const signals = {
+        cwd,
+        agentMode: "max" as const,
+        scenarioMode: "intelligence" as const,
+        userRequest: "rename a local helper function",
+      }
+      const a = activationForProfile(buildProfile(signals))
+      const b = activationForProfile(buildProfile(signals))
+      expect(b.activePackIds).toEqual(a.activePackIds)
+      // Core fallback packs are part of the retrieval-constrained active set the gateway records.
+      expect(a.activePackIds).toContain("code.core")
+      // Pins remain force-included through the unified authority.
+      const pinned = activationForProfile(buildProfile({ ...signals, userOverrides: ["code.gpu-kernel"] }))
+      expect(pinned.activePackIds).toContain("code.gpu-kernel")
+    })
+  })
+})
diff --git a/packages/core/test/deepagent/pinned-packs.test.ts b/packages/core/test/deepagent/pinned-packs.test.ts
new file mode 100644
index 00000000..50f37b27
--- /dev/null
+++ b/packages/core/test/deepagent/pinned-packs.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { PINNED_PACKS_FILE, pinnedPacksFile, readPinnedPacks, writePinnedPacks } from "../../src/deepagent/pinned-packs"
+
+const withTempMemoryDir = (fn: (memoryDir: string) => void) => {
+  const dir = mkdtempSync(path.join(tmpdir(), "deepagent-pinned-packs-"))
+  try {
+    fn(path.join(dir, "memory"))
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+describe("pinned-packs module (FEAT-001)", () => {
+  test("missing file reads as no pins", () => {
+    withTempMemoryDir((memoryDir) => {
+      expect(readPinnedPacks(memoryDir)).toEqual([])
+    })
+  })
+
+  test("corrupt JSON degrades to no pins instead of throwing", () => {
+    withTempMemoryDir((memoryDir) => {
+      mkdirSync(memoryDir, { recursive: true })
+      writeFileSync(pinnedPacksFile(memoryDir), "{not json")
+      expect(readPinnedPacks(memoryDir)).toEqual([])
+    })
+  })
+
+  test("non-array JSON payload degrades to no pins", () => {
+    withTempMemoryDir((memoryDir) => {
+      mkdirSync(memoryDir, { recursive: true })
+      writeFileSync(pinnedPacksFile(memoryDir), JSON.stringify({ packs: ["code.core"] }))
+      expect(readPinnedPacks(memoryDir)).toEqual([])
+    })
+  })
+
+  test("non-string entries are filtered out", () => {
+    withTempMemoryDir((memoryDir) => {
+      mkdirSync(memoryDir, { recursive: true })
+      writeFileSync(pinnedPacksFile(memoryDir), JSON.stringify(["code.core", 42, null, { id: "x" }, "risk.security"]))
+      expect(readPinnedPacks(memoryDir)).toEqual(["code.core", "risk.security"])
+    })
+  })
+
+  test("write then read round-trips pins (deduplicated, sorted)", () => {
+    withTempMemoryDir((memoryDir) => {
+      writePinnedPacks(memoryDir, ["risk.security", "code.core", "risk.security"])
+      expect(readPinnedPacks(memoryDir)).toEqual(["code.core", "risk.security"])
+    })
+  })
+
+  test("write creates the memory dir on demand and pins the canonical file name", () => {
+    withTempMemoryDir((memoryDir) => {
+      expect(PINNED_PACKS_FILE).toBe("pinned-packs.json")
+      writePinnedPacks(memoryDir, ["code.core"])
+      expect(pinnedPacksFile(memoryDir)).toBe(path.join(memoryDir, PINNED_PACKS_FILE))
+      expect(readPinnedPacks(memoryDir)).toEqual(["code.core"])
+    })
+  })
+})
diff --git a/packages/core/test/deepagent/plan-controller.test.ts b/packages/core/test/deepagent/plan-controller.test.ts
index fd993181..eff1dd19 100644
--- a/packages/core/test/deepagent/plan-controller.test.ts
+++ b/packages/core/test/deepagent/plan-controller.test.ts
@@ -102,6 +102,13 @@ describe("tool classification", () => {
     }
   })
 
+  test("FEAT-011 T5: facade activity_start/activity_control are mutating; status/result are read-only", () => {
+    expect(isMutatingTool("activity_start")).toBe(true)
+    expect(isMutatingTool("activity_control")).toBe(true)
+    expect(isMutatingTool("activity_status")).toBe(false)
+    expect(isMutatingTool("activity_result")).toBe(false)
+  })
+
   test("read/search/plan/task are never mutating (must pass even when stale)", () => {
     for (const t of ["read", "grep", "glob", "list", "search", "plan", "task", "webfetch"]) {
       expect(isMutatingTool(t)).toBe(false)
diff --git a/packages/core/test/event-snapshot.test.ts b/packages/core/test/event-snapshot.test.ts
index 144f57a9..89083174 100644
--- a/packages/core/test/event-snapshot.test.ts
+++ b/packages/core/test/event-snapshot.test.ts
@@ -535,4 +535,76 @@ describe("EventV2 canonical projection snapshots", () => {
       expect(yield* db.select().from(EventSnapshotChunkTable).all()).toEqual([])
     }),
   )
+
+  // RISK-003 ⑤ (BUG-407-010 §9.2/§11.4): the importable aggregate snapshot body. The bundle is
+  // the portable evidence form of the same authority the row/chunk wire transfer carries.
+  it.effect("exports an aggregate snapshot as an importable bundle and imports it into an empty database", () =>
+    Effect.gen(function* () {
+      const source = yield* EventV2.Service
+      const sourceDb = (yield* Database.Service).db
+      const bundleSessionID = SessionV2.ID.make("ses_snapshot_bundle_roundtrip")
+      yield* sourceDb.insert(ProjectTable).values({ id: projectID, worktree: AbsolutePath.make("/project"), sandboxes: [] }).run().pipe(Effect.orDie)
+      yield* source.publish(SessionV1.Event.Created, {
+        sessionID: bundleSessionID,
+        info: SessionV1.SessionInfo.make({
+          id: bundleSessionID, slug: "bundle", version: "test", projectID, directory: "/project", title: "bundle",
+          cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, time: { created: 1, updated: 1 },
+        }),
+      })
+      yield* source.publish(SessionV1.Event.MessageUpdated, {
+        sessionID: bundleSessionID,
+        info: {
+          id: SessionV1.MessageID.make("msg_bundle_one"),
+          sessionID: bundleSessionID,
+          role: "user" as const,
+          time: { created: 1 },
+          agent: "build",
+          model: { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("test") },
+          system: "bundled",
+        },
+      })
+      const snapshot = yield* source.checkpoint({
+        aggregateID: bundleSessionID,
+        throughSeq: EventV2.Cursor.make(1),
+        expectedLatest: EventV2.Cursor.make(1),
+        codec: "session-projection",
+        schemaVersion: 1,
+      })
+
+      const bundle = yield* source.exportSnapshotBundle!({ snapshotID: snapshot.snapshotID })
+      const parsed = JSON.parse(bundle) as Record<string, unknown>
+      expect(parsed.format).toBe(EventV2.SNAPSHOT_BUNDLE_FORMAT)
+      expect(typeof parsed.bundleHash).toBe("string")
+      expect((parsed.rows as unknown[]).length).toBeGreaterThan(0)
+
+      const tamperedChunk = JSON.parse(bundle) as { chunks: Record<string, string[]> }
+      const tamperedRowHash = Object.keys(tamperedChunk.chunks)[0]!
+      tamperedChunk.chunks[tamperedRowHash] = [...tamperedChunk.chunks[tamperedRowHash]!.slice(0, -1), Buffer.from("tampered").toString("base64")]
+      const tampered = JSON.stringify(tamperedChunk)
+
+      const tmp = yield* Effect.acquireRelease(Effect.promise(() => tmpdir()), (value) => Effect.promise(() => value[Symbol.asyncDispose]()))
+      const targetDatabase = Database.layerFromPath(path.join(tmp.path, "bundle-target.sqlite"))
+      const targetEvents = EventV2.layer.pipe(Layer.provide(targetDatabase))
+      const targetProjector = SessionProjector.layer.pipe(Layer.provide(targetEvents), Layer.provide(targetDatabase))
+      yield* Effect.gen(function* () {
+        const target = yield* EventV2.Service
+        const targetDb = (yield* Database.Service).db
+        yield* targetDb.insert(ProjectTable).values({ id: projectID, worktree: AbsolutePath.make("/project"), sandboxes: [] }).run().pipe(Effect.orDie)
+        const invalid = yield* target.importSnapshotBundle!("not-json").pipe(Effect.catchDefect(Effect.succeed))
+        expect(invalid).toBeInstanceOf(EventV2.InvalidSyncEventError)
+        const corrupted = yield* target.importSnapshotBundle!(tampered).pipe(Effect.catchDefect(Effect.succeed))
+        expect(corrupted).toBeInstanceOf(EventV2.InvalidSyncEventError)
+        expect(yield* targetDb.select().from(EventSnapshotRowTable).all()).toEqual([])
+
+        const imported = yield* target.importSnapshotBundle!(bundle)
+        expect(imported).toMatchObject({ snapshotID: snapshot.snapshotID, aggregateID: bundleSessionID, throughSeq: 1 })
+        expect(yield* targetDb.select().from(SessionTable).where(eq(SessionTable.id, bundleSessionID)).get().pipe(Effect.orDie)).toBeDefined()
+        expect(yield* targetDb.select().from(MessageTable).where(eq(MessageTable.id, SessionV1.MessageID.make("msg_bundle_one"))).get().pipe(Effect.orDie)).toBeDefined()
+        expect(yield* targetDb.select().from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, bundleSessionID)).get().pipe(Effect.orDie))
+          .toMatchObject({ seq: 1, retention_floor_seq: 1, snapshot_id: snapshot.snapshotID })
+        yield* target.importSnapshotBundle!(bundle)
+        expect(yield* targetDb.select().from(EventSnapshotRowTable).where(eq(EventSnapshotRowTable.aggregate_id, bundleSessionID)).all()).not.toHaveLength(0)
+      }).pipe(Effect.provide(Layer.fresh(Layer.mergeAll(targetDatabase, targetEvents, targetProjector))))
+    }),
+  )
 })
diff --git a/packages/core/test/event.test.ts b/packages/core/test/event.test.ts
index a17e4dad..7c95ff13 100644
--- a/packages/core/test/event.test.ts
+++ b/packages/core/test/event.test.ts
@@ -1708,4 +1708,71 @@ describe("EventV2", () => {
       expect(received[0]?.data).toEqual({ id: aggregateID, text: "replayed" })
     }),
   )
+
+  // BUG-407-010 / REL-002: until the canonical owner handoff completes, a durable source fence
+  // (`event_sequence.write_fence_transfer_id` backed by an admitted transfer operation) must fail
+  // closed for both replay and local publish — no event may land on the fenced aggregate.
+  it.effect("a durable transfer write fence fails closed for replay and publish before handoff completes", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const { db } = yield* Database.Service
+      const aggregateID = "session-transfer-fenced"
+      // fixture-exempt: bare project/session rows exist only to satisfy the
+      // session_transfer_operation FK so the fence authority trigger admits the transfer.
+      yield* db.run(sql`
+        INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+        VALUES ('project-transfer-fence', '/tmp/transfer-fence', '[]', 1, 1)
+      `)
+      // fixture-exempt: bare session row anchors the transfer fence aggregate (see above).
+      yield* db.run(sql`
+        INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_updated)
+        VALUES (${aggregateID}, 'project-transfer-fence', 'transfer-fence', '/tmp/transfer-fence', 'Transfer fence', 'test', 1, 1)
+      `)
+      yield* events.publish(SyncMessage, { id: aggregateID, text: "before handoff" })
+      // fixture-exempt: seeds an admitted (in-flight) transfer operation; the handoff never
+      // advances, so the source fence must keep the aggregate fail closed.
+      yield* db.run(sql`
+        INSERT INTO session_transfer_operation (
+          transfer_id, session_id, source_owner_id, target_owner_id,
+          source_event_seq, source_mutation_epoch, state, request_hash, created_at, updated_at
+        ) VALUES (
+          'transfer-fence', ${aggregateID}, 'source-owner', 'target-owner',
+          0, 0, 'admitted', ${"f".repeat(64)}, 1, 1
+        )
+      `)
+      yield* db
+        .update(EventSequenceTable)
+        .set({ write_fence_transfer_id: "transfer-fence" })
+        .where(eq(EventSequenceTable.aggregate_id, aggregateID))
+        .run()
+        .pipe(Effect.orDie)
+
+      const replayExit = yield* events
+        .replay(
+          {
+            id: EventV2.ID.create(),
+            type: EventV2.versionedType(SyncMessage.type, 1),
+            seq: 1,
+            aggregateID,
+            data: { id: aggregateID, text: "stolen" },
+          },
+          { ownerID: "target-owner", strictOwner: true },
+        )
+        .pipe(Effect.exit)
+      expect(String(replayExit)).toContain("is fenced by transfer transfer-fence")
+
+      const publishExit = yield* events
+        .publish(SyncMessage, { id: aggregateID, text: "local write after fence" })
+        .pipe(Effect.exit)
+      expect(String(publishExit)).toContain("is fenced by transfer transfer-fence")
+
+      const rows = yield* db
+        .select({ seq: EventTable.seq })
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, aggregateID))
+        .all()
+        .pipe(Effect.orDie)
+      expect(rows.map((row) => row.seq)).toEqual([0])
+    }),
+  )
 })
diff --git a/packages/core/test/lmn-events.test.ts b/packages/core/test/lmn-events.test.ts
index 02152044..4089df62 100644
--- a/packages/core/test/lmn-events.test.ts
+++ b/packages/core/test/lmn-events.test.ts
@@ -10,6 +10,21 @@ describe("LMNEvents", () => {
     expect(LMNEvents.GOAL_COMPLETED).toBe("goal.completed")
     expect(LMNEvents.PANEL_VERDICT).toBe("panel.verdict")
     expect(LMNEvents.IM_MESSAGE_CREATED).toBe("im.message.created") // §B1 double-write
+    expect(LMNEvents.PACK_CHANGED).toBe("pack.changed") // FEAT-003 pack pin/unpin eventing
+    expect(LMNEvents.WIKI_PAGE_CHANGED).toBe("wiki.page.changed") // FEAT-006 wiki/knowledge change eventing
+  })
+
+  test("FEAT-003 pack.changed is a pure observation — NOT an approval-queue / archive trigger", () => {
+    expect(LMNEvents.isApprovalQueueCandidate(LMNEvents.PACK_CHANGED)).toBe(false)
+    expect(LMNEvents.isArchiveTrigger(LMNEvents.PACK_CHANGED)).toBe(false)
+  })
+
+  test("FEAT-006 wiki.page.changed is a pure observation — NOT an approval-queue / archive trigger", () => {
+    // The archive-trigger exclusion is the FEAT-006 SELF-LOOP GUARD: the event-driven archiver
+    // consumes only session.completed/goal.completed, so its own archive writes' wiki.page.changed
+    // can never re-trigger archival (no archiver→event→archiver cascade).
+    expect(LMNEvents.isApprovalQueueCandidate(LMNEvents.WIKI_PAGE_CHANGED)).toBe(false)
+    expect(LMNEvents.isArchiveTrigger(LMNEvents.WIKI_PAGE_CHANGED)).toBe(false)
   })
 
   test("§B im.message.created is NOT an approval-queue / archive trigger", () => {
diff --git a/packages/core/test/remote-compact-persistence-migration.test.ts b/packages/core/test/remote-compact-persistence-migration.test.ts
new file mode 100644
index 00000000..1fa44ca6
--- /dev/null
+++ b/packages/core/test/remote-compact-persistence-migration.test.ts
@@ -0,0 +1,239 @@
+import { describe, expect, test } from "bun:test"
+import { SqliteClient } from "@effect/sql-sqlite-bun"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
+import { Effect, Exit } from "effect"
+import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
+import remoteCompactPersistence from "../src/database/migration/20260820000000_remote_compact_persistence"
+
+// UPD-005 Gap 1 + Gap 2 schema migration. The migration is not registered in
+// migration.gen.ts yet (mainline registers it), so this test applies the tracked
+// history first and then the single migration via applyOnly.
+const migrationID = "20260820000000_remote_compact_persistence"
+
+const makeDb = EffectDrizzleSqlite.makeWithDefaults()
+const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
+  Effect.runPromise(
+    effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+  )
+
+describe("remote compact persistence migration", () => {
+  test("creates the encrypted content table and the mode columns, and stays idempotent", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+        expect(remoteCompactPersistence.id).toBe(migrationID)
+
+        // Seed a historical compaction_run BEFORE the migration: it must read back
+        // as the 'local_summary' default afterwards.
+        yield* db.run(`
+          INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+          VALUES ('project-remote-compact', '/repo', '[]', 1, 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session (
+            id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+          ) VALUES (
+            'session-remote-compact', 'project-remote-compact', 'remote-compact', '/repo',
+            'Remote compact', '1', 0, 1, 1
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO compaction_run (
+            run_id, session_id, from_prompt_epoch, "trigger", state, created_at,
+            source_window_id, source_effective_history_hash, source_message_count, source_projection_version
+          ) VALUES (
+            'run-pre-remote-compact', 'session-remote-compact', 1, 'manual', 'committed', 1,
+            'window-1', 'hash-1', 3, 0
+          )
+        `)
+
+        yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistence])
+
+        // Gap 1: the blob table exists with the documented shape.
+        const tableCheck = yield* db.get<{ sql: string }>(
+          `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'session_compaction_encrypted_content'`,
+        )
+        expect(tableCheck).toBeDefined()
+        const tableSql = tableCheck!.sql.replace(/\s+/g, " ")
+        expect(tableSql).toContain("session_id TEXT NOT NULL PRIMARY KEY REFERENCES session(id) ON DELETE CASCADE")
+        expect(tableSql).toContain("encrypted_content TEXT NOT NULL")
+        expect(tableSql).toContain("provider_id TEXT NOT NULL")
+
+        const columns = yield* db.all<{ name: string }>(`PRAGMA table_info(session_compaction_encrypted_content)`)
+        expect(columns.map((column) => column.name).sort()).toEqual(
+          ["created_at", "encrypted_content", "model_id", "provider_id", "session_id", "source_run_id", "updated_at"].sort(),
+        )
+
+        // Gap 2: the two mode columns land on compaction_run.
+        const runColumns = yield* db.all<{ name: string; dflt_value: string | null }>(
+          `PRAGMA table_info(compaction_run)`,
+        )
+        const modeColumn = runColumns.find((column) => column.name === "compaction_mode")
+        expect(modeColumn).toBeDefined()
+        expect(modeColumn!.dflt_value).toBe("'local_summary'")
+        expect(runColumns.some((column) => column.name === "encrypted_content_session")).toBe(true)
+
+        // Historical rows read back as local_summary with no blob pointer.
+        expect(
+          yield* db.get(`
+            SELECT compaction_mode, encrypted_content_session
+            FROM compaction_run WHERE run_id = 'run-pre-remote-compact'
+          `),
+        ).toEqual({ compaction_mode: "local_summary", encrypted_content_session: null })
+
+        // The CHECK constraint rejects unknown modes.
+        const rejectedMode = yield* db
+          .run(`UPDATE compaction_run SET compaction_mode = 'hybrid' WHERE run_id = 'run-pre-remote-compact'`)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(rejectedMode)).toBe(true)
+
+        // Blob rows are keyed by session and enforce uniqueness (latest-wins is an
+        // upsert at the write site, not duplicate rows).
+        yield* db.run(`
+          INSERT INTO session_compaction_encrypted_content (
+            session_id, encrypted_content, provider_id, model_id, source_run_id, created_at, updated_at
+          ) VALUES ('session-remote-compact', 'blob-v1', 'openai', 'gpt-x', 'run-pre-remote-compact', 1, 1)
+        `)
+        const duplicate = yield* db
+          .run(`
+            INSERT INTO session_compaction_encrypted_content (
+              session_id, encrypted_content, provider_id, model_id, source_run_id, created_at, updated_at
+            ) VALUES ('session-remote-compact', 'blob-v2', 'openai', 'gpt-x', 'run-pre-remote-compact', 2, 2)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(duplicate)).toBe(true)
+
+        // Session deletion cascades the blob row.
+        yield* db.run(`DELETE FROM session WHERE id = 'session-remote-compact'`)
+        expect(
+          yield* db.get(`SELECT count(*) AS count FROM session_compaction_encrypted_content`),
+        ).toEqual({ count: 0 })
+        expect(yield* db.all(`PRAGMA foreign_key_check`)).toEqual([])
+
+        // Forward-only idempotence: reapplying is a tracked no-op.
+        const before = yield* db.get<{ count: number }>(`SELECT count(*) AS count FROM migration`)
+        yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistence])
+        expect(yield* db.get(`SELECT count(*) AS count FROM migration`)).toEqual(before)
+      }),
+    )
+  })
+
+  test("rebuilt authority trigger admits remote commits without a TEXT summary and keeps local binding strict", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+        yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistence])
+
+        yield* db.run(`
+          INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+          VALUES ('project-trigger-check', '/repo', '[]', 1, 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session (
+            id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+          ) VALUES (
+            'session-trigger-check', 'project-trigger-check', 'trigger-check', '/repo',
+            'Trigger check', '1', 0, 1, 1
+          )
+        `)
+        const seedRun = (runID: string) =>
+          db.run(`
+            INSERT INTO compaction_run (
+              run_id, session_id, from_prompt_epoch, "trigger", state, created_at,
+              source_window_id, source_effective_history_hash, source_message_count, source_projection_version
+            ) VALUES (
+              '${runID}', 'session-trigger-check', 1, 'manual', 'requested', 1,
+              'window-1', 'hash-1', 3, 0
+            )
+          `)
+
+        // Remote mode: requested → summarizing → committed succeeds with
+        // summary_text NULL, gated only on the encrypted_content pointer.
+        yield* seedRun("run-remote-ok")
+        yield* db.run(`UPDATE compaction_run SET state = 'summarizing' WHERE run_id = 'run-remote-ok'`)
+        yield* db.run(`
+          UPDATE compaction_run
+          SET state = 'committed', compaction_mode = 'remote_compact',
+              encrypted_content_session = 'session-trigger-check',
+              completion_reason = 'manual', committed_at = 2
+          WHERE run_id = 'run-remote-ok'
+        `)
+        expect(
+          yield* db.get(`SELECT state, summary_text FROM compaction_run WHERE run_id = 'run-remote-ok'`),
+        ).toEqual({ state: "committed", summary_text: null })
+
+        // Remote mode without the blob pointer still fails the binding check.
+        yield* seedRun("run-remote-no-pointer")
+        yield* db.run(`UPDATE compaction_run SET state = 'summarizing' WHERE run_id = 'run-remote-no-pointer'`)
+        const noPointer = yield* db
+          .run(`
+            UPDATE compaction_run
+            SET state = 'committed', compaction_mode = 'remote_compact',
+                completion_reason = 'manual', committed_at = 2
+            WHERE run_id = 'run-remote-no-pointer'
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(noPointer)).toBe(true)
+        // Terminate the stuck run so the next seed passes the single-active-run check.
+        yield* db.run(`
+          UPDATE compaction_run SET state = 'failed', terminal_failure_kind = 'test'
+          WHERE run_id = 'run-remote-no-pointer'
+        `)
+
+        // Local mode keeps the strict TEXT-summary binding (zero regression).
+        yield* seedRun("run-local-no-summary")
+        yield* db.run(`UPDATE compaction_run SET state = 'summarizing' WHERE run_id = 'run-local-no-summary'`)
+        const localNoSummary = yield* db
+          .run(`
+            UPDATE compaction_run
+            SET state = 'committed', completion_reason = 'manual', committed_at = 2
+            WHERE run_id = 'run-local-no-summary'
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(localNoSummary)).toBe(true)
+        yield* db.run(`
+          UPDATE compaction_run SET state = 'failed', terminal_failure_kind = 'test'
+          WHERE run_id = 'run-local-no-summary'
+        `)
+
+        // The state machine itself is unchanged: skipping summarizing is rejected.
+        yield* seedRun("run-skip-state")
+        const skip = yield* db
+          .run(`
+            UPDATE compaction_run
+            SET state = 'committed', compaction_mode = 'remote_compact',
+                encrypted_content_session = 'session-trigger-check',
+                completion_reason = 'manual', committed_at = 2
+            WHERE run_id = 'run-skip-state'
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(skip)).toBe(true)
+      }),
+    )
+  })
+
+  test("blob row FK rejects unknown sessions", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+        yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistence])
+
+        const rejected = yield* db
+          .run(`
+            INSERT INTO session_compaction_encrypted_content (
+              session_id, encrypted_content, provider_id, model_id, source_run_id, created_at, updated_at
+            ) VALUES ('session-missing', 'blob', 'openai', NULL, NULL, 1, 1)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(rejected)).toBe(true)
+      }),
+    )
+  })
+})
diff --git a/packages/core/test/session-context-reconciliation.test.ts b/packages/core/test/session-context-reconciliation.test.ts
new file mode 100644
index 00000000..bd8d41e0
--- /dev/null
+++ b/packages/core/test/session-context-reconciliation.test.ts
@@ -0,0 +1,322 @@
+import { describe, expect, test } from "bun:test"
+import { SqliteClient } from "@effect/sql-sqlite-bun"
+import { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
+import { sql } from "drizzle-orm"
+import { Effect, Exit } from "effect"
+import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
+import { Database } from "../src/database/database"
+import { DatabaseMigration } from "../src/database/migration"
+import receiptActivePackSetMigration from "../src/database/migration/20260816080000_receipt_active_pack_set_attribution"
+import reconciliationMigration from "../src/database/migration/20260816081000_session_context_reconciliation"
+import { ContextReconciliation } from "../src/context-federation/reconciliation"
+
+const sessionId = "reconciliation-session"
+const activityId = "reconciliation-activity"
+const projectionRefs = [
+  { graph: "knowledge" as const, entityId: "doc-a", revision: "rev-1" },
+  { graph: "memory" as const, entityId: "mem-b", revision: "rev-2" },
+  { graph: "code" as const, entityId: "file-c", revision: "rev-3" },
+]
+
+describe("context reconciliation pure functions", () => {
+  test("refKeys sorts and de-duplicates; fingerprint is order and duplicate insensitive", () => {
+    const reversed = [...projectionRefs].reverse()
+    expect(ContextReconciliation.refKeys(projectionRefs)).toEqual(ContextReconciliation.refKeys(reversed))
+    expect(ContextReconciliation.refsFingerprint(projectionRefs)).toEqual(
+      ContextReconciliation.refsFingerprint([...projectionRefs, projectionRefs[0]!]),
+    )
+    expect(ContextReconciliation.duplicateCount(projectionRefs)).toBe(0)
+    expect(ContextReconciliation.duplicateCount([...projectionRefs, projectionRefs[0]!])).toBe(1)
+  })
+
+  test("diffRefKeys partitions two ref key sets", () => {
+    const diff = ContextReconciliation.diffRefKeys(["a", "b"], ["b", "c"])
+    expect(diff).toEqual({ onlyInA: ["a"], onlyInB: ["c"], sharedCount: 1 })
+  })
+
+  test("evaluate without legacy refs records projection-internal consistency", () => {
+    const evaluated = ContextReconciliation.evaluate({ projectionRefs })
+    expect(evaluated.outcome).toBe("legacy_unavailable_projection_consistent")
+    expect(evaluated.legacyFingerprint).toBeUndefined()
+    expect(evaluated.diffSummary.mode).toBe("projection_internal")
+    expect(evaluated.diffSummary.refCount).toBe(3)
+    expect(evaluated.diffSummary.duplicateCount).toBe(0)
+    expect(evaluated.diffSummary.perGraph).toEqual({ knowledge: 1, memory: 1, code: 1 })
+
+    const duplicated = ContextReconciliation.evaluate({ projectionRefs: [...projectionRefs, projectionRefs[0]!] })
+    expect(duplicated.outcome).toBe("legacy_unavailable_projection_duplicate_refs")
+    expect(duplicated.diffSummary.duplicateCount).toBe(1)
+  })
+
+  test("evaluate with legacy refs reports match and mismatch with the diff partition", () => {
+    const match = ContextReconciliation.evaluate({ projectionRefs, legacyRefs: [...projectionRefs].reverse() })
+    expect(match.outcome).toBe("legacy_match")
+    expect(match.legacyFingerprint).toBe(ContextReconciliation.refsFingerprint(projectionRefs))
+    expect(match.diffSummary.mode).toBe("legacy_vs_projection")
+
+    const mismatch = ContextReconciliation.evaluate({
+      projectionRefs,
+      legacyRefs: [
+        projectionRefs[0]!,
+        { graph: "knowledge" as const, entityId: "doc-legacy-only", revision: "rev-9" },
+      ],
+    })
+    expect(mismatch.outcome).toBe("legacy_mismatch")
+    expect(mismatch.diffSummary.legacy).toEqual({
+      refCount: 2,
+      onlyInLegacy: ["knowledge:doc-legacy-only:rev-9"],
+      onlyInProjection: ["code:file-c:rev-3", "memory:mem-b:rev-2"],
+      sharedCount: 1,
+    })
+  })
+})
+
+describe("context reconciliation durable record", () => {
+  test("writes one idempotent row per federated turn receipt", async () => {
+    await runCurrent(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        yield* seedSession(db)
+        const input = {
+          sessionId,
+          activityId,
+          turnReceiptId: "receipt-turn-1",
+          selectionId: "selection-1",
+          projectionRefs,
+          now: 42,
+        }
+        yield* ContextReconciliation.record(db, input)
+        yield* ContextReconciliation.record(db, input)
+
+        const rows = yield* db.all<{
+          reconciliation_id: string
+          session_id: string
+          activity_id: string
+          turn_receipt_id: string
+          selection_id: string
+          legacy_refs_fingerprint: string | null
+          projection_refs_fingerprint: string
+          outcome: string
+          diff_summary: string
+          created_at: number
+        }>(sql`SELECT * FROM session_context_reconciliation`)
+        expect(rows.length).toBe(1)
+        const row = rows[0]!
+        expect(row.reconciliation_id).toBe(ContextReconciliation.reconciliationId("receipt-turn-1"))
+        expect(row.session_id).toBe(sessionId)
+        expect(row.activity_id).toBe(activityId)
+        expect(row.turn_receipt_id).toBe("receipt-turn-1")
+        expect(row.selection_id).toBe("selection-1")
+        expect(row.legacy_refs_fingerprint).toBeNull()
+        expect(row.projection_refs_fingerprint).toBe(ContextReconciliation.refsFingerprint(projectionRefs))
+        expect(row.outcome).toBe("legacy_unavailable_projection_consistent")
+        expect(JSON.parse(row.diff_summary).mode).toBe("projection_internal")
+        expect(row.created_at).toBe(42)
+
+        const secondTurn = yield* ContextReconciliation.record(db, {
+          ...input,
+          turnReceiptId: "receipt-turn-2",
+          projectionRefs: [projectionRefs[0]!],
+          now: 43,
+        })
+        expect(secondTurn.outcome).toBe("legacy_unavailable_projection_consistent")
+        expect((yield* db.all(sql`SELECT reconciliation_id FROM session_context_reconciliation`)).length).toBe(2)
+      }),
+    )
+  })
+
+  test("records the legacy fingerprint when legacy refs are provided", async () => {
+    await runCurrent(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        yield* seedSession(db)
+        yield* ContextReconciliation.record(db, {
+          sessionId,
+          activityId,
+          turnReceiptId: "receipt-turn-legacy",
+          projectionRefs,
+          legacyRefs: projectionRefs,
+        })
+        expect(yield* db.get(sql`
+          SELECT legacy_refs_fingerprint, projection_refs_fingerprint, outcome
+          FROM session_context_reconciliation
+          WHERE turn_receipt_id = 'receipt-turn-legacy'
+        `)).toEqual({
+          legacy_refs_fingerprint: ContextReconciliation.refsFingerprint(projectionRefs),
+          projection_refs_fingerprint: ContextReconciliation.refsFingerprint(projectionRefs),
+          outcome: "legacy_match",
+        })
+      }),
+    )
+  })
+
+  test("fresh schema exposes the reconciliation table, indexes, and the receipt attribution column", async () => {
+    await runCurrent(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        expect(
+          (yield* db.all<{ name: string }>(sql`
+            SELECT name FROM pragma_table_info('session_context_reconciliation')
+          `)).map((column) => column.name),
+        ).toEqual([
+          "reconciliation_id",
+          "session_id",
+          "activity_id",
+          "turn_receipt_id",
+          "selection_id",
+          "legacy_refs_fingerprint",
+          "projection_refs_fingerprint",
+          "outcome",
+          "diff_summary",
+          "created_at",
+        ])
+        expect(
+          (yield* db.all<{ name: string; unique: number }>(sql`
+            SELECT name, "unique"
+            FROM pragma_index_list('session_context_reconciliation')
+            WHERE name NOT LIKE 'sqlite_%'
+            ORDER BY name
+          `)).map((index) => index),
+        ).toEqual([
+          { name: "session_context_reconciliation_receipt_idx", unique: 1 },
+          { name: "session_context_reconciliation_session_idx", unique: 0 },
+        ])
+        expect(
+          (yield* db.all<{ name: string }>(sql`
+            SELECT name FROM pragma_table_info('session_tool_request_receipt')
+          `)).map((column) => column.name),
+        ).toEqual(expect.arrayContaining(["context_active_pack_set_snapshot_id"]))
+        expect(
+          yield* db.all<{ name: string; partial: number }>(sql`
+            SELECT name, partial
+            FROM pragma_index_list('session_tool_request_receipt')
+            WHERE name = 'session_tool_request_receipt_active_pack_set_idx'
+          `),
+        ).toEqual([{ name: "session_tool_request_receipt_active_pack_set_idx", partial: 1 }])
+      }),
+    )
+  })
+})
+
+describe("FEAT-007 migrations upgrade a historical schema", () => {
+  test("adds the attribution column and reconciliation table without touching existing rows", async () => {
+    await runRaw(
+      Effect.gen(function* () {
+        const db = yield* EffectDrizzleSqlite.makeWithDefaults()
+        yield* db.run(sql`
+          CREATE TABLE session (id TEXT PRIMARY KEY)
+        `)
+        yield* db.run(sql`
+          CREATE TABLE session_activity (activity_id TEXT PRIMARY KEY, session_id TEXT)
+        `)
+        yield* db.run(sql`
+          CREATE TABLE session_tool_request_receipt (
+            receipt_id TEXT PRIMARY KEY,
+            session_id TEXT,
+            provider_state TEXT
+          )
+        `)
+        yield* db.run(sql`
+          INSERT INTO session_tool_request_receipt (receipt_id, session_id, provider_state)
+          VALUES ('historical-receipt', 'historical-session', 'prepared')
+        `)
+
+        yield* DatabaseMigration.applyOnly(db, [receiptActivePackSetMigration, reconciliationMigration])
+
+        expect(
+          (yield* db.all<{ name: string }>(sql`
+            SELECT name FROM pragma_table_info('session_tool_request_receipt')
+          `)).map((column) => column.name),
+        ).toEqual(expect.arrayContaining(["context_active_pack_set_snapshot_id"]))
+        expect(
+          yield* db.get(sql`
+            SELECT context_active_pack_set_snapshot_id FROM session_tool_request_receipt
+            WHERE receipt_id = 'historical-receipt'
+          `),
+        ).toEqual({ context_active_pack_set_snapshot_id: null })
+
+        const invalid = yield* db
+          .run(sql`
+            UPDATE session_tool_request_receipt
+            SET context_active_pack_set_snapshot_id = 'not-a-pack-snapshot'
+            WHERE receipt_id = 'historical-receipt'
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(invalid)).toBe(true)
+        yield* db.run(sql`
+          UPDATE session_tool_request_receipt
+          SET context_active_pack_set_snapshot_id = 'pack_snapshot:abcdef0123456789'
+          WHERE receipt_id = 'historical-receipt'
+        `)
+        expect(
+          yield* db.get(sql`
+            SELECT context_active_pack_set_snapshot_id FROM session_tool_request_receipt
+            WHERE receipt_id = 'historical-receipt'
+          `),
+        ).toEqual({ context_active_pack_set_snapshot_id: "pack_snapshot:abcdef0123456789" })
+
+        expect(
+          yield* db.get(sql`
+            SELECT name FROM sqlite_master
+            WHERE type = 'table' AND name = 'session_context_reconciliation'
+          `),
+        ).toEqual({ name: "session_context_reconciliation" })
+
+        const malformedFingerprint = yield* db
+          .run(sql`
+            INSERT INTO session_context_reconciliation (
+              reconciliation_id, session_id, activity_id, turn_receipt_id,
+              projection_refs_fingerprint, outcome, diff_summary, created_at
+            ) VALUES ('malformed', 'historical-session', 'historical-activity', 'receipt-x',
+              'short', 'legacy_match', '{}', 1)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(malformedFingerprint)).toBe(true)
+        const malformedSummary = yield* db
+          .run(sql`
+            INSERT INTO session_context_reconciliation (
+              reconciliation_id, session_id, activity_id, turn_receipt_id,
+              projection_refs_fingerprint, outcome, diff_summary, created_at
+            ) VALUES ('malformed-summary', 'historical-session', 'historical-activity', 'receipt-x',
+              ${"a".repeat(64)}, 'legacy_match', '[]', 1)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(malformedSummary)).toBe(true)
+      }),
+    )
+  })
+})
+
+function runCurrent<A, E>(effect: Effect.Effect<A, E, Database.Service>) {
+  return Effect.runPromise(effect.pipe(Effect.provide(Database.layerFromPath(":memory:")), Effect.scoped))
+}
+
+function runRaw<A, E>(effect: Effect.Effect<A, E, SqlClientService>) {
+  return Effect.runPromise(
+    effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+  )
+}
+
+type DatabaseClient = Database.Interface["db"]
+
+function seedSession(db: DatabaseClient) {
+  return Effect.gen(function* () {
+    yield* db.run(sql`
+      INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+      VALUES ('reconciliation-project', '/tmp/reconciliation', '[]', 1, 1)
+    `)
+    yield* db.run(sql`
+      INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_updated)
+      VALUES (${sessionId}, 'reconciliation-project', 'reconciliation-session', '/tmp/reconciliation', 'Reconciliation session', 'test', 1, 1)
+    `)
+    yield* db.run(sql`
+      INSERT INTO session_input (id, session_id, prompt, delivery, admitted_seq, promoted_seq, time_created)
+      VALUES ('reconciliation-input', ${sessionId}, '{"text":"reconciliation"}', 'steer', 0, 0, 1)
+    `)
+    yield* db.run(sql`
+      INSERT INTO session_activity (
+        activity_id, session_id, ordinal, trigger_input_id, delivery, state, created_at
+      ) VALUES (${activityId}, ${sessionId}, 0, 'reconciliation-input', 'steer', 'active', 1)
+    `)
+  })
+}
diff --git a/packages/core/test/session-intent-confirmation-state-migration.test.ts b/packages/core/test/session-intent-confirmation-state-migration.test.ts
new file mode 100644
index 00000000..b6797c41
--- /dev/null
+++ b/packages/core/test/session-intent-confirmation-state-migration.test.ts
@@ -0,0 +1,424 @@
+import { describe, expect, test } from "bun:test"
+import { SqliteClient } from "@effect/sql-sqlite-bun"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import { migrations } from "@deepagent-code/core/database/migration.gen"
+import { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
+import { Effect, Exit } from "effect"
+import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
+
+const migrationID = "20260819120000_session_intent_confirmation_state"
+const documentedStates = [
+  "preparing",
+  "awaiting_confirmation",
+  "selected",
+  "admitting",
+  "admitted",
+  "canceled",
+  "superseded",
+  "failed",
+] as const
+
+// sha256("[]") — the released-refs fingerprint used by unrelated receipt seeds.
+const emptyReleasedRefsFingerprint = "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"
+
+const makeDb = EffectDrizzleSqlite.makeWithDefaults()
+const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
+  Effect.runPromise(
+    effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+  )
+
+describe("session intent confirmation state migration", () => {
+  test("enforces the BUG-405-003 state contract on a fresh database and stays idempotent", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        // Mirror the runtime connection (Database.layer enables FK before migrating).
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+
+        const check = yield* db.get<{ sql: string }>(
+          `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'session_intent'`,
+        )
+        expect(check).toBeDefined()
+        for (const state of documentedStates) expect(check!.sql).toContain(`'${state}'`)
+
+        yield* db.run(`
+          INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+          VALUES ('project-intent-check', '/repo', '[]', 1, 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session (
+            id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+          ) VALUES (
+            'session-intent-check', 'project-intent-check', 'intent-check', '/repo',
+            'Intent check', '1', 0, 1, 1
+          )
+        `)
+
+        for (const [index, state] of documentedStates.entries()) {
+          yield* db.run(`
+            INSERT INTO session_intent (
+              intent_id, session_id, source, state, time_created, time_updated
+            ) VALUES (
+              'intent-check-${state}', 'session-intent-check', 'composer', '${state}', ${index + 1}, ${index + 1}
+            )
+          `)
+        }
+        expect(
+          yield* db.get(`SELECT count(*) AS count FROM session_intent WHERE session_id = 'session-intent-check'`),
+        ).toEqual({ count: documentedStates.length })
+
+        for (const invalidState of ["awaiting_review", "confirmed", "drafted"]) {
+          const rejected = yield* db
+            .run(`
+              INSERT INTO session_intent (
+                intent_id, session_id, source, state, time_created, time_updated
+              ) VALUES (
+                'intent-check-invalid-${invalidState}', 'session-intent-check', 'composer',
+                '${invalidState}', 1, 1
+              )
+            `)
+            .pipe(Effect.exit)
+          expect(Exit.isFailure(rejected)).toBe(true)
+        }
+        expect(
+          yield* db.get(`SELECT count(*) AS count FROM session_intent WHERE session_id = 'session-intent-check'`),
+        ).toEqual({ count: documentedStates.length })
+
+        const before = yield* db.get<{ count: number }>(`SELECT count(*) AS count FROM migration`)
+        yield* DatabaseMigration.apply(db)
+        expect(yield* db.get(`SELECT count(*) AS count FROM migration`)).toEqual(before)
+        expect(yield* db.all(`PRAGMA foreign_key_check`)).toEqual([])
+      }),
+    )
+  })
+
+  test("preserves durable intent receipts and the legacy activity chain while widening the state CHECK", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        const migrationIndex = migrations.findIndex((migration) => migration.id === migrationID)
+        expect(migrationIndex).toBeGreaterThan(0)
+        yield* DatabaseMigration.applyOnly(db, migrations.slice(0, migrationIndex))
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+
+        // Historical databases predate the widened contract: only the legacy six states exist.
+        const rejectedBefore = yield* db
+          .run(`
+            INSERT INTO session_intent (
+              intent_id, session_id, source, state, time_created, time_updated
+            ) VALUES ('intent-pre-check', 'session-missing', 'composer', 'awaiting_confirmation', 1, 1)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(rejectedBefore)).toBe(true)
+
+        yield* db.run(`
+          INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+          VALUES ('project-intent-state', '/repo', '[]', 1, 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session (
+            id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+          ) VALUES (
+            'session-intent-state', 'project-intent-state', 'intent-state', '/repo',
+            'Intent state', '1', 2, 1, 1
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO message (id, session_id, time_created, time_updated, data)
+          VALUES ('message-intent-state', 'session-intent-state', 1, 1, '{}')
+        `)
+        yield* db.run(`
+          INSERT INTO session_provider_owner_lease (owner_token, registered_at, heartbeat_at, lease_expires_at)
+          VALUES (
+            'owner-intent-state',
+            CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+            CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+            CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER) + 10000
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO context_security_namespace (id, kind, binding_hash, created_at)
+          VALUES ('sec_intent_state', 'implicit_local', 'receipt-namespace-binding', 1)
+        `)
+        yield* db.run(`
+          INSERT INTO context_project_scope_identity (
+            security_namespace_id, project_scope_key, project_kind, project_identity_hash, created_at
+          ) VALUES (
+            'sec_intent_state', 'prjctx_intent_state', 'registered_root', 'receipt-project-identity', 1
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_tool_request_receipt (
+            receipt_id, request_ordinal, session_id, user_message_id, assistant_message_id,
+            provider_id, model_id, registry_tool_ids, permission_filtered_tool_ids,
+            final_offered_tool_ids, call_ids, released_knowledge_security_namespace_id,
+            released_knowledge_project_scope_key, released_knowledge_binding_state,
+            released_knowledge_exact_refs, released_knowledge_exact_refs_fingerprint,
+            owner_token, request_state, created_at
+          ) VALUES (
+            'receipt-intent-state', 1, 'session-intent-state', 'message-intent-state',
+            'message-intent-state', 'provider-test', 'model-test', '[]', '[]', '[]', '[]',
+            'sec_intent_state', 'prjctx_intent_state', 'unavailable', '[]',
+            '${emptyReleasedRefsFingerprint}', 'owner-intent-state', 'dispatched', 1
+          )
+        `)
+
+        for (const [index, state] of ["preparing", "admitting", "canceled", "superseded", "failed"].entries()) {
+          yield* db.run(`
+            INSERT INTO session_intent (
+              intent_id, session_id, source, state, time_created, time_updated
+            ) VALUES (
+              'intent-state-${state}', 'session-intent-state', 'composer', '${state}', ${index + 1}, ${index + 1}
+            )
+          `)
+        }
+        // Admitted intent A backs an active activity with a claimed run.
+        yield* db.run(`
+          INSERT INTO session_intent (
+            intent_id, session_id, source, state, selected_variant, selected_payload_hash,
+            delivery, admitted_message_id, mutation_epoch, execution_mode, execution_state,
+            execution_claim_id, execution_claimed_at, version, time_created, time_selected,
+            time_admitted, time_updated
+          ) VALUES (
+            'intent-state-a', 'session-intent-state', 'composer', 'admitted', 'original',
+            'payload-intent-state-a', 'turn', 'message-intent-state', 3, 'run_now', 'claimed',
+            'run-intent-state-a', 2, 1, 1, 1, 1, 2
+          )
+        `)
+        // Admitted intent B backs an activity settled outside a run (recovery terminal path).
+        yield* db.run(`
+          INSERT INTO session_intent (
+            intent_id, session_id, source, state, selected_variant, selected_payload_hash,
+            delivery, admitted_message_id, mutation_epoch, execution_mode, execution_state,
+            version, time_created, time_selected, time_admitted, time_updated
+          ) VALUES (
+            'intent-state-b', 'session-intent-state', 'intelligence', 'admitted', 'rewritten',
+            'payload-intent-state-b', 'turn', 'message-intent-state', 4, 'run_now', 'pending',
+            1, 1, 1, 1, 2
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_activity_admission (
+            admission_id, session_id, source_kind, legacy_intent_id, admitted_message_id,
+            delivery, payload_fingerprint_kind, payload_fingerprint, created_at, execution_mode
+          ) VALUES (
+            'admission-intent-state-a', 'session-intent-state', 'legacy_intent', 'intent-state-a',
+            'message-intent-state', 'turn', 'payload_hash', 'payload-intent-state-a', 1, 'run_now'
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_activity_admission (
+            admission_id, session_id, source_kind, legacy_intent_id, admitted_message_id,
+            delivery, payload_fingerprint_kind, payload_fingerprint, created_at, execution_mode
+          ) VALUES (
+            'admission-intent-state-b', 'session-intent-state', 'legacy_intent', 'intent-state-b',
+            'message-intent-state', 'turn', 'payload_hash', 'payload-intent-state-b', 1, 'run_now'
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity (
+            activity_id, session_id, ordinal, trigger_admission_id, owner_token,
+            state, terminal_reason, created_at, settled_at
+          ) VALUES (
+            'activity-intent-state-a', 'session-intent-state', 0, 'admission-intent-state-a',
+            'owner-intent-state', 'active', NULL, 1, NULL
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity (
+            activity_id, session_id, ordinal, trigger_admission_id, owner_token,
+            state, terminal_reason, created_at, settled_at
+          ) VALUES (
+            'activity-intent-state-b', 'session-intent-state', 1, 'admission-intent-state-b',
+            'owner-intent-state', 'settled', 'user completed', 1, 3
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity_admission (
+            activity_id, admission_id, ordinal, role, attached_at
+          ) VALUES ('activity-intent-state-a', 'admission-intent-state-a', 0, 'trigger', 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity_admission (
+            activity_id, admission_id, ordinal, role, attached_at
+          ) VALUES ('activity-intent-state-b', 'admission-intent-state-b', 0, 'trigger', 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session_activity_progress (
+            activity_id, revision, assistant_message_id, provider_receipt_id, state,
+            created_at, settled_at, input_membership_ordinal
+          ) VALUES (
+            'activity-intent-state-a', 0, 'message-intent-state', 'receipt-intent-state',
+            'progress', 1, 2, 0
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity_run (
+            run_id, activity_id, session_id, mutation_epoch, generation, owner_token,
+            state, started_at
+          ) VALUES (
+            'run-intent-state-a', 'activity-intent-state-a', 'session-intent-state', 3, 0,
+            'owner-intent-state', 'running', 1
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity_terminal (
+            activity_id, session_id, mutation_epoch, state, reason_code, source,
+            operation_id, membership_ordinal, owner_token, created_at
+          ) VALUES (
+            'activity-intent-state-b', 'session-intent-state', 4, 'settled', 'user completed',
+            'restart_recovery', 'operation-intent-state-b', 0, 'owner-intent-state', 3
+          )
+        `)
+        yield* db.run(`
+          INSERT INTO session_legacy_activity_migration_receipt (
+            receipt_id, batch_id, activity_id, classifier_version, before_state, after_state,
+            evidence_hash, terminal_operation_id, created_at
+          ) VALUES (
+            'receipt-migration-intent-state', 'batch-intent-state', 'activity-intent-state-b',
+            'legacy-terminal-state-v1', 'settled', 'settled', 'evidence-intent-state',
+            'operation-intent-state-b', 3
+          )
+        `)
+
+        const snapshot = {
+          intents: yield* db.all(`SELECT intent_id, state FROM session_intent ORDER BY intent_id`),
+          admissions: yield* db.all(`SELECT admission_id, execution_mode FROM session_activity_admission ORDER BY admission_id`),
+          activities: yield* db.all(`SELECT activity_id, state FROM session_legacy_activity ORDER BY activity_id`),
+          joins: yield* db.all(`SELECT activity_id, role FROM session_legacy_activity_admission ORDER BY activity_id`),
+          progress: yield* db.all(`SELECT activity_id, state FROM session_activity_progress ORDER BY activity_id, revision`),
+          runs: yield* db.all(`SELECT run_id, state FROM session_legacy_activity_run ORDER BY run_id`),
+          terminals: yield* db.all(`SELECT activity_id, state, source FROM session_legacy_activity_terminal ORDER BY activity_id`),
+          receipts: yield* db.all(`SELECT receipt_id, after_state FROM session_legacy_activity_migration_receipt ORDER BY receipt_id`),
+        }
+
+        yield* DatabaseMigration.applyOnly(db, migrations.slice(migrationIndex, migrationIndex + 1))
+        // Apply the migrations registered after the intent rebuild too, so the full-history
+        // re-apply below asserts a true no-op against the current registry.
+        yield* DatabaseMigration.applyOnly(db, migrations.slice(migrationIndex + 1))
+
+        const widenedCheck = yield* db.get<{ sql: string }>(
+          `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'session_intent'`,
+        )
+        expect(widenedCheck).toBeDefined()
+        expect(widenedCheck!.sql).toContain("'awaiting_confirmation'")
+        expect(widenedCheck!.sql).toContain("'selected'")
+
+        expect(yield* db.all(`SELECT intent_id, state FROM session_intent ORDER BY intent_id`)).toEqual(
+          snapshot.intents,
+        )
+        expect(
+          yield* db.all(`SELECT admission_id, execution_mode FROM session_activity_admission ORDER BY admission_id`),
+        ).toEqual(snapshot.admissions)
+        expect(yield* db.all(`SELECT activity_id, state FROM session_legacy_activity ORDER BY activity_id`)).toEqual(
+          snapshot.activities,
+        )
+        expect(
+          yield* db.all(`SELECT activity_id, role FROM session_legacy_activity_admission ORDER BY activity_id`),
+        ).toEqual(snapshot.joins)
+        expect(
+          yield* db.all(`SELECT activity_id, state FROM session_activity_progress ORDER BY activity_id, revision`),
+        ).toEqual(snapshot.progress)
+        expect(yield* db.all(`SELECT run_id, state FROM session_legacy_activity_run ORDER BY run_id`)).toEqual(
+          snapshot.runs,
+        )
+        expect(
+          yield* db.all(`SELECT activity_id, state, source FROM session_legacy_activity_terminal ORDER BY activity_id`),
+        ).toEqual(snapshot.terminals)
+        expect(
+          yield* db.all(
+            `SELECT receipt_id, after_state FROM session_legacy_activity_migration_receipt ORDER BY receipt_id`,
+          ),
+        ).toEqual(snapshot.receipts)
+        expect(
+          yield* db.get(`
+            SELECT execution_claim_id, selected_payload_hash, mutation_epoch
+            FROM session_intent WHERE intent_id = 'intent-state-a'
+          `),
+        ).toEqual({
+          execution_claim_id: "run-intent-state-a",
+          selected_payload_hash: "payload-intent-state-a",
+          mutation_epoch: 3,
+        })
+
+        expect(
+          yield* db.all(`
+            SELECT name FROM sqlite_master
+            WHERE type = 'trigger' AND name IN (
+              'session_intent_execution_validate_insert',
+              'session_intent_execution_validate_update',
+              'session_activity_admission_validate_insert',
+              'session_activity_admission_immutable',
+              'session_activity_admission_execution_mode_validate_insert',
+              'session_legacy_activity_legal_update',
+              'session_legacy_activity_objective_insert',
+              'session_legacy_activity_objective_terminal_projection',
+              'session_legacy_activity_permission_effect_terminal_guard',
+              'session_legacy_activity_admission_validate_insert',
+              'session_legacy_activity_admission_immutable',
+              'session_activity_progress_validate_insert',
+              'session_activity_progress_legal_update',
+              'session_legacy_activity_run_validate_insert',
+              'session_legacy_activity_run_legal_update',
+              'session_legacy_activity_terminal_validate_insert',
+              'session_legacy_activity_terminal_immutable_update',
+              'session_legacy_activity_terminal_immutable_delete',
+              'session_legacy_activity_migration_receipt_immutable_update',
+              'session_legacy_activity_migration_receipt_immutable_delete'
+            )
+            ORDER BY name
+          `),
+        ).toHaveLength(20)
+        expect(
+          yield* db.all(`
+            SELECT name FROM sqlite_master
+            WHERE type = 'index' AND name IN (
+              'session_intent_session_state_idx',
+              'session_legacy_activity_active_idx',
+              'session_legacy_activity_run_generation_idx',
+              'session_legacy_activity_live_run_idx',
+              'session_legacy_activity_terminal_operation_idx',
+              'session_legacy_activity_migration_batch_idx',
+              'session_legacy_activity_migration_terminal_idx'
+            )
+            ORDER BY name
+          `),
+        ).toHaveLength(7)
+        expect(yield* db.all(`PRAGMA foreign_key_check`)).toEqual([])
+
+        // The widened contract now accepts the confirmation window and the CAS selection.
+        yield* db.run(`
+          INSERT INTO session_intent (
+            intent_id, session_id, source, state, time_created, time_updated
+          ) VALUES ('intent-state-confirm', 'session-intent-state', 'intelligence', 'awaiting_confirmation', 9, 9)
+        `)
+        yield* db.run(`
+          INSERT INTO session_intent (
+            intent_id, session_id, source, state, selected_variant, selected_payload_hash,
+            time_created, time_selected, time_updated
+          ) VALUES (
+            'intent-state-selected', 'session-intent-state', 'intelligence', 'selected', 'rewritten',
+            'payload-intent-state-selected', 9, 9, 9
+          )
+        `)
+        const rejectedAfter = yield* db
+          .run(`
+            INSERT INTO session_intent (
+              intent_id, session_id, source, state, time_created, time_updated
+            ) VALUES ('intent-state-invalid', 'session-intent-state', 'composer', 'awaiting_review', 1, 1)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(rejectedAfter)).toBe(true)
+
+        // Reapplying the tracked history must remain a no-op (forward-only, idempotent).
+        const before = yield* db.get<{ count: number }>(`SELECT count(*) AS count FROM migration`)
+        yield* DatabaseMigration.apply(db)
+        expect(yield* db.get(`SELECT count(*) AS count FROM migration`)).toEqual(before)
+        expect(yield* db.all(`SELECT intent_id, state FROM session_intent ORDER BY intent_id`)).not.toEqual(
+          snapshot.intents,
+        )
+      }),
+    )
+  })
+})
diff --git a/packages/core/test/turn-stage-evidence-migration.test.ts b/packages/core/test/turn-stage-evidence-migration.test.ts
new file mode 100644
index 00000000..54f87d8c
--- /dev/null
+++ b/packages/core/test/turn-stage-evidence-migration.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test"
+import { SqliteClient } from "@effect/sql-sqlite-bun"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import { migrations } from "@deepagent-code/core/database/migration.gen"
+import turnStageEvidenceMigration from "@deepagent-code/core/database/migration/20260820120000_session_turn_stage_evidence"
+import { EffectDrizzleSqlite } from "@deepagent-code/effect-drizzle-sqlite"
+import { Effect, Exit } from "effect"
+import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
+
+const documentedStages = [
+  "activity_claimed",
+  "snapshot_started",
+  "snapshot_finished",
+  "snapshot_degraded",
+  "history_loaded",
+  "request_prepared",
+  "provider_dispatch_started",
+  "terminal_settled",
+] as const
+
+const makeDb = EffectDrizzleSqlite.makeWithDefaults()
+const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
+  Effect.runPromise(
+    effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
+  )
+
+describe("session turn stage evidence migration", () => {
+  test("creates the BUG-407-012 gap C evidence table with the documented stage contract", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        // Mirror the runtime connection (Database.layer enables FK before migrating).
+        yield* db.run(`PRAGMA foreign_keys = ON`)
+        yield* DatabaseMigration.apply(db)
+        yield* DatabaseMigration.applyOnly(db, [turnStageEvidenceMigration])
+
+        const check = yield* db.get<{ sql: string }>(
+          `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'session_turn_stage_evidence'`,
+        )
+        expect(check).toBeDefined()
+        for (const stage of documentedStages) expect(check!.sql).toContain(`'${stage}'`)
+        expect(check!.sql).toContain(`PRIMARY KEY (session_id, activity_id)`)
+        expect(check!.sql).toContain(`REFERENCES session(id) ON DELETE CASCADE`)
+
+        // One row per (session_id, activity_id).
+        const duplicate = yield* db
+          .run(`
+            INSERT INTO session_turn_stage_evidence (session_id, activity_id, stage, stage_at, updated_at)
+            VALUES ('session-missing', 'activity-dup', 'activity_claimed', 1, 1)
+          `)
+          .pipe(Effect.exit)
+        // FK violation fires first (session row absent) — the PK shape is asserted via sqlite_master above.
+        expect(Exit.isFailure(duplicate)).toBe(true)
+
+        yield* db.run(`
+          INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+          VALUES ('project-stage-evidence', '/repo', '[]', 1, 1)
+        `)
+        yield* db.run(`
+          INSERT INTO session (
+            id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+          ) VALUES (
+            'session-stage-evidence', 'project-stage-evidence', 'stage-evidence', '/repo',
+            'Stage evidence', '1', 0, 1, 1
+          )
+        `)
+
+        for (const [index, stage] of documentedStages.entries()) {
+          yield* db.run(`
+            INSERT INTO session_turn_stage_evidence (session_id, activity_id, stage, stage_at, updated_at)
+            VALUES ('session-stage-evidence', 'activity-${stage}', '${stage}', ${index + 1}, ${index + 1})
+          `)
+        }
+        expect(
+          yield* db.get(
+            `SELECT count(*) AS count FROM session_turn_stage_evidence WHERE session_id = 'session-stage-evidence'`,
+          ),
+        ).toEqual({ count: documentedStages.length })
+
+        const invalidStage = yield* db
+          .run(`
+            INSERT INTO session_turn_stage_evidence (session_id, activity_id, stage, stage_at, updated_at)
+            VALUES ('session-stage-evidence', 'activity-invalid', 'dispatched', 1, 1)
+          `)
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(invalidStage)).toBe(true)
+
+        // ON DELETE CASCADE: deleting the session removes its stage evidence.
+        yield* db.run(`DELETE FROM session WHERE id = 'session-stage-evidence'`)
+        expect(
+          yield* db.get(
+            `SELECT count(*) AS count FROM session_turn_stage_evidence WHERE session_id = 'session-stage-evidence'`,
+          ),
+        ).toEqual({ count: 0 })
+
+        const indexRow = yield* db.get<{ name: string }>(
+          `SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'session_turn_stage_evidence_session_idx'`,
+        )
+        expect(indexRow).toBeDefined()
+
+        // Idempotent replay + clean FK graph.
+        const before = yield* db.get<{ count: number }>(`SELECT count(*) AS count FROM migration`)
+        yield* DatabaseMigration.applyOnly(db, [turnStageEvidenceMigration])
+        expect(yield* db.get(`SELECT count(*) AS count FROM migration`)).toEqual(before)
+        expect(yield* db.all(`PRAGMA foreign_key_check`)).toEqual([])
+      }),
+    )
+  })
+
+  test("orders after every migration registered before it", async () => {
+    const index = migrations.findIndex((registered) => registered.id === turnStageEvidenceMigration.id)
+    for (const registered of migrations.slice(0, index)) {
+      expect(turnStageEvidenceMigration.id > registered.id).toBe(true)
+    }
+  })
+})
diff --git a/packages/deepagent-code/script/live-llm/providers.ts b/packages/deepagent-code/script/live-llm/providers.ts
new file mode 100644
index 00000000..6236ea2b
--- /dev/null
+++ b/packages/deepagent-code/script/live-llm/providers.ts
@@ -0,0 +1,165 @@
+/**
+ * Provider matrix for the live LLM all-tests runner (script/run-live-llm-all.ts).
+ *
+ * Endpoint allowlisting stays fail-closed: only providers registered here, or endpoints
+ * explicitly appended through DEEPAGENT_CODE_LIVE_LLM_ALLOWED_ENDPOINTS, are accepted.
+ */
+
+export type LiveLLMProviderEndpoint = {
+  /** Canonical base URL for the provider, e.g. https://api.deepseek.com */
+  baseURL: string
+  /** Additional official aliases for the same provider (e.g. the China endpoint). */
+  aliases?: ReadonlyArray<string>
+}
+
+export type LiveLLMProvider = {
+  /** Stable provider identifier used for fingerprints and key file naming. */
+  id: string
+  /** Human-readable provider label for error messages and logs. */
+  label: string
+  endpoints: ReadonlyArray<LiveLLMProviderEndpoint>
+}
+
+/** Environment variable that appends custom allowed endpoints to the fail-closed allowlist. */
+export const LIVE_LLM_ALLOWED_ENDPOINTS_ENV = "DEEPAGENT_CODE_LIVE_LLM_ALLOWED_ENDPOINTS"
+
+/**
+ * Official provider registry. IDs follow the models.dev-style identifiers used by the
+ * repository models snapshot (deepseek / moonshotai / zai / openai); labels keep the
+ * product names (Kimi, GLM) that the evidence chain reports.
+ */
+export const liveLLMProviders: ReadonlyArray<LiveLLMProvider> = [
+  {
+    id: "deepseek",
+    label: "DeepSeek",
+    endpoints: [{ baseURL: "https://api.deepseek.com" }],
+  },
+  {
+    id: "moonshotai",
+    label: "Kimi (Moonshot)",
+    endpoints: [
+      { baseURL: "https://api.moonshot.ai/v1" },
+      { baseURL: "https://api.moonshot.cn/v1" },
+    ],
+  },
+  {
+    id: "zai",
+    label: "GLM (Zhipu / Z.AI)",
+    endpoints: [
+      { baseURL: "https://api.z.ai/api/paas/v4" },
+      { baseURL: "https://open.bigmodel.cn/api/paas/v4" },
+    ],
+  },
+  {
+    id: "openai",
+    label: "OpenAI",
+    endpoints: [{ baseURL: "https://api.openai.com/v1" }],
+  },
+]
+
+/** A resolved provider: either a registered provider or an explicitly allowed custom endpoint. */
+export type ResolvedLiveLLMProvider = {
+  id: string
+  label: string
+  /** Normalized base URL (no trailing slash) that was matched. */
+  baseURL: string
+  registered: boolean
+}
+
+/** Recommended chmod 600 key file location for a provider, derived from its identifier. */
+export function recommendedLiveLLMKeyFile(providerID: string) {
+  return `~/.deepagent/code/tmp/live-llm-${providerID}.key`
+}
+
+/** Normalizes a base URL: requires https, lowercased hostname, no trailing slash. */
+export function normalizeLiveLLMEndpoint(baseURL: string) {
+  if (!URL.canParse(baseURL)) throw new Error("baseURL must be a valid URL")
+  const url = new URL(baseURL)
+  if (url.protocol !== "https:") {
+    throw new Error(`Live LLM endpoints must use https, received ${baseURL}`)
+  }
+  return `${url.origin}${url.pathname.replace(/\/$/, "")}`
+}
+
+/** Matches a base URL against the built-in official provider registry only. */
+export function matchRegisteredLiveLLMProvider(baseURL: string): ResolvedLiveLLMProvider | undefined {
+  const normalized = normalizeLiveLLMEndpoint(baseURL)
+  for (const provider of liveLLMProviders) {
+    for (const endpoint of provider.endpoints) {
+      for (const candidate of [endpoint.baseURL, ...(endpoint.aliases ?? [])]) {
+        if (normalizeLiveLLMEndpoint(candidate) === normalized) {
+          return { id: provider.id, label: provider.label, baseURL: normalized, registered: true }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Parses DEEPAGENT_CODE_LIVE_LLM_ALLOWED_ENDPOINTS entries.
+ *
+ * Entries are comma- or whitespace-separated; each entry is either `https://host[/path]`
+ * or `provider-id@https://host[/path]` when the fingerprint identifier should not be
+ * derived from the hostname.
+ */
+export function parseCustomAllowedEndpoints(raw: string | undefined): Array<{ id?: string; baseURL: string }> {
+  if (!raw?.trim()) return []
+  return raw.split(/[\s,]+/).flatMap((entry) => {
+    const trimmed = entry.trim()
+    if (!trimmed) return []
+    const separator = trimmed.indexOf("@")
+    const idPart = separator === -1 ? undefined : trimmed.slice(0, separator)
+    const urlPart = separator === -1 ? trimmed : trimmed.slice(separator + 1)
+    const id = idPart?.trim()
+    if (id && !/^[a-z0-9][a-z0-9_-]*$/.test(id)) {
+      throw new Error(
+        `${LIVE_LLM_ALLOWED_ENDPOINTS_ENV} provider id "${id}" must match /^[a-z0-9][a-z0-9_-]*$/`,
+      )
+    }
+    if (!URL.canParse(urlPart)) {
+      throw new Error(`${LIVE_LLM_ALLOWED_ENDPOINTS_ENV} contains an invalid URL: ${urlPart}`)
+    }
+    return [{ ...(id ? { id } : {}), baseURL: urlPart }]
+  })
+}
+
+function customProviderID(baseURL: string) {
+  const hostname = new URL(baseURL).hostname.toLowerCase()
+  const derived = hostname.split(".")[0]?.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "")
+  if (!derived || !/^[a-z0-9]/.test(derived)) return "custom"
+  return derived
+}
+
+/**
+ * Resolves the provider for a base URL. Registered providers always win; otherwise the
+ * endpoint is only accepted when explicitly listed in the allowed-endpoints environment
+ * variable (fail-closed). Throws when the endpoint is not allowed.
+ */
+export function resolveLiveLLMProvider(
+  baseURL: string,
+  environment: Readonly<Record<string, string | undefined>> = process.env,
+): ResolvedLiveLLMProvider {
+  const normalized = normalizeLiveLLMEndpoint(baseURL)
+  const registered = matchRegisteredLiveLLMProvider(normalized)
+  if (registered) return registered
+  const custom = parseCustomAllowedEndpoints(environment[LIVE_LLM_ALLOWED_ENDPOINTS_ENV]).find(
+    (entry) => normalizeLiveLLMEndpoint(entry.baseURL) === normalized,
+  )
+  if (custom) {
+    const id = custom.id ?? customProviderID(normalized)
+    return { id, label: id, baseURL: normalized, registered: false }
+  }
+  throw new Error(
+    `Real LLM suites currently require an official provider endpoint; official https://api.deepseek.com ` +
+      `(deepseek) is the historical default, also allowed: ` +
+      `${officialEndpointList()}; extend via ${LIVE_LLM_ALLOWED_ENDPOINTS_ENV}=provider@https://host/path, ` +
+      `received ${baseURL}`,
+  )
+}
+
+/** Comma-separated list of every officially registered endpoint (for error messages). */
+export function officialEndpointList() {
+  return liveLLMProviders
+    .flatMap((provider) => provider.endpoints.map((endpoint) => endpoint.baseURL))
+    .join(", ")
+}
diff --git a/packages/deepagent-code/script/live-llm/routes.ts b/packages/deepagent-code/script/live-llm/routes.ts
index 8fd4ca82..eae9c557 100644
--- a/packages/deepagent-code/script/live-llm/routes.ts
+++ b/packages/deepagent-code/script/live-llm/routes.ts
@@ -683,6 +683,8 @@ export const routeManifest = [
       "packages/deepagent-code/src/session/activity-crash-test.ts",
       "packages/deepagent-code/src/session/activity-owner.ts",
       "packages/deepagent-code/src/session/activity-sql.ts",
+      "packages/deepagent-code/src/session/facade-activity.ts",
+      "packages/deepagent-code/src/tool/activity_facade.ts",
       "packages/deepagent-code/src/session/legacy-provider-resolution.ts",
       "packages/deepagent-code/src/session/processor.ts",
       "packages/deepagent-code/src/session/recovery-transfer-guard.ts",
@@ -691,6 +693,9 @@ export const routeManifest = [
       "packages/deepagent-code/src/session/prompt-intent.ts",
       "packages/deepagent-code/src/session/prompt.ts",
       "packages/deepagent-code/src/session/steer.ts",
+      "packages/deepagent-code/src/session/turn-deadline-watchdog.ts",
+      "packages/deepagent-code/src/session/turn-stage-evidence.sql.ts",
+      "packages/deepagent-code/src/session/turn-stage-evidence.ts",
     ],
     checks: ["live-llm-routes", "prompt-intent", "session-continuation", "ui-runtime"],
     runs: [activityProgressLifecycle, activityProgressRestart, activityProgressPackage, longSession],
@@ -724,6 +729,7 @@ export const routeManifest = [
       "packages/deepagent-code/src/session/steer.ts",
       "packages/deepagent-code/src/session/compaction.ts",
       "packages/deepagent-code/src/session/compaction-sql.ts",
+      "packages/deepagent-code/src/session/remote-compact.ts",
       "packages/deepagent-code/src/session/context-ledger.ts",
       "packages/deepagent-code/src/session/prompt-epoch.ts",
       "packages/deepagent-code/src/session/prompt-epoch.sql.ts",
@@ -767,6 +773,8 @@ export const routeManifest = [
       "packages/deepagent-code/src/session/run-state.ts",
       "packages/deepagent-code/src/session/schema.ts",
       "packages/deepagent-code/src/session/session*.ts",
+      "packages/deepagent-code/src/session/__tests__/snapshot.test.ts",
+      "packages/deepagent-code/src/session/snapshot.ts",
       "packages/deepagent-code/src/session/status.ts",
       "packages/deepagent-code/src/session/summary.ts",
       "packages/deepagent-code/src/session/supervisor-notifier.ts",
diff --git a/packages/deepagent-code/script/models-data.ts b/packages/deepagent-code/script/models-data.ts
index 567d8ea7..78ef9813 100644
--- a/packages/deepagent-code/script/models-data.ts
+++ b/packages/deepagent-code/script/models-data.ts
@@ -24,13 +24,25 @@ export async function loadModelsData(
     return result(configured, configuredFile)
   }
 
-  const modelsURL = (environment.DEEPAGENT_CODE_MODELS_URL?.trim() || "https://models.dev").replace(/\/$/, "")
-  const remote = await fetch(`${modelsURL}/api.json`, {
-    signal: AbortSignal.timeout(options.requestTimeoutMs ?? 10_000),
-  })
-    .then(async (response) => (response.ok ? catalog(await response.json()) : undefined))
-    .catch(() => undefined)
-  if (remote) {
+  // Clean-build policy: DEEPAGENT_CODE_MODELS_URL accepts a comma-separated ordered list of fresh
+  // remote endpoints. Default chain: models.dev (primary) then the Gitee mirror of
+  // deepagent-ltd/models.dev (hourly-synced, reachable from CN networks). Every source must serve
+  // the live catalog; we never fall back to a stale local snapshot — if all endpoints fail, the
+  // build fails closed.
+  const modelsURLs = (
+    environment.DEEPAGENT_CODE_MODELS_URL?.trim() ||
+    "https://models.dev,https://gitee.com/deepagent-ai/models.dev/raw/main"
+  )
+    .split(",")
+    .map((url) => url.trim().replace(/\/$/, ""))
+    .filter((url) => url.length > 0)
+  for (const modelsURL of modelsURLs) {
+    const remote = await fetch(`${modelsURL}/api.json`, {
+      signal: AbortSignal.timeout(options.requestTimeoutMs ?? 10_000),
+    })
+      .then(async (response) => (response.ok ? catalog(await response.json()) : undefined))
+      .catch(() => undefined)
+    if (!remote) continue
     if (options.cacheFile) {
       await persistCatalog(options.cacheFile, remote).catch((error) =>
         console.warn(
@@ -41,7 +53,9 @@ export async function loadModelsData(
     return result(remote, `${modelsURL}/api.json`)
   }
 
-  throw new Error(`Unable to load models.dev catalog from ${modelsURL}; refusing to use a local snapshot`)
+  throw new Error(
+    `Unable to load models.dev catalog from ${modelsURLs.join(", ")}; refusing to use a local snapshot`,
+  )
 }
 
 function result(data: Record<string, unknown>, source: string) {
diff --git a/packages/deepagent-code/script/rel-001-drill.ts b/packages/deepagent-code/script/rel-001-drill.ts
new file mode 100644
index 00000000..ad2b894e
--- /dev/null
+++ b/packages/deepagent-code/script/rel-001-drill.ts
@@ -0,0 +1,215 @@
+#!/usr/bin/env bun
+
+import path from "node:path"
+import { copyFile, stat } from "node:fs/promises"
+import { randomUUID } from "node:crypto"
+import { Effect, Exit, Layer, Ref, Stream } from "effect"
+import { sql } from "drizzle-orm"
+import { Database } from "@deepagent-code/core/database/database"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { BackgroundJob } from "@/background/job"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Session } from "@/session/session"
+import { SessionLegacyProviderResolution } from "@/session/legacy-provider-resolution"
+import { LLM } from "@/session/llm"
+import { MessageID, SessionID } from "@/session/schema"
+import { EventV2 } from "@deepagent-code/core/event"
+import { ProjectV2 } from "@deepagent-code/core/project"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
+import { InstanceRef } from "@/effect/instance-ref"
+
+// REL-001 release drill (BUG-407-009). Runs against a COPY of the production snapshot only:
+// the source path must contain "drill" (the live database is never opened for writing).
+// Steps: incident state check, 0-provider-invocation abandoned recovery, fork smoke,
+// and a new message write on the original session.
+
+const INCIDENT_SESSIONS = ["ses_00c3f7decfffhjQSy69Q5gSd1S", "ses_0149b8afffffWlu80cVGdzFI9s"]
+const INCIDENT_DIRECTORY = "/Users/xiuranli/code/hygon/vllm"
+const INCIDENT_PROJECT_ID = "6337bf4e27be43039900d3258a454af34b9b62ad"
+
+// The drill boots services directly (no desktop instance), so the fork path gets a minimal
+// instance context matching the incident project rows in the drill database.
+const drillInstanceContext = {
+  directory: INCIDENT_DIRECTORY,
+  worktree: INCIDENT_DIRECTORY,
+  project: {
+    id: ProjectV2.ID.make(INCIDENT_PROJECT_ID),
+    worktree: INCIDENT_DIRECTORY,
+    vcs: "git" as const,
+    time: { created: 1784826016726, updated: 1786691614012 },
+    sandboxes: [],
+  },
+}
+
+const arg = (name: string) => {
+  const index = process.argv.indexOf(name)
+  if (index === -1) return undefined
+  return process.argv[index + 1]
+}
+
+export async function copyForDrill(source: string) {
+  const info = await stat(source)
+  if (!info.isFile()) throw new Error(`drill source is not a file: ${source}`)
+  if (!path.basename(source).includes("drill"))
+    throw new Error(`refusing to drill without a drill copy; source basename must contain "drill": ${source}`)
+  const target = path.join(path.dirname(source), `rel-001-drill-${Date.now()}-${randomUUID().slice(0, 8)}.db`)
+  await copyFile(source, target)
+  return target
+}
+
+type Evidence = { step: string; detail: string }
+
+const evidenceLines: Evidence[] = []
+const evidence = (step: string, detail: string) => {
+  evidenceLines.push({ step, detail })
+  console.log(`REL-001 ${step}: ${detail}`)
+}
+
+const fakeLLM = Layer.effect(
+  LLM.Service,
+  Effect.gen(function* () {
+    const invocations = yield* Ref.make(0)
+    return LLM.Service.of({
+      stream: () =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* Ref.update(invocations, (n) => n + 1)
+            return Stream.failSync(
+              () => new Error("drill oracle: provider invoked during abandoned recovery — oracle violated"),
+            )
+          }),
+        ),
+    })
+  }),
+)
+
+const layersFor = (database: string) => {
+  // EventV2.defaultLayer bakes Database.defaultLayer (the channel-local DB), so every consumer must
+  // be wired to the drill path explicitly — a merged default provider silently steals the service.
+  const eventV2 = EventV2.layer.pipe(Layer.provide(Database.layerFromPath(database)))
+  const bridge = EventV2Bridge.layer.pipe(Layer.provide(eventV2))
+  // The session projector materializes session.created events into session rows (fork children too).
+  const sessionProjector = SessionProjector.layer.pipe(
+    Layer.provide(eventV2),
+    Layer.provide(Database.layerFromPath(database)),
+  )
+  return Layer.mergeAll(
+    Session.layer.pipe(
+      Layer.provide(BackgroundJob.defaultLayer),
+      Layer.provide(Database.layerFromPath(database)),
+      Layer.provide(bridge),
+      Layer.provide(RuntimeFlags.defaultLayer),
+    ),
+    SessionLegacyProviderResolution.layer.pipe(
+      Layer.provide(Database.layerFromPath(database)),
+      Layer.provide(bridge),
+    ),
+    sessionProjector,
+    eventV2,
+    Database.layerFromPath(database),
+    fakeLLM,
+  )
+}
+
+export function runDrill(database: string) {
+  return Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    const resolution = yield* SessionLegacyProviderResolution.Service
+    const sessions = yield* Session.Service
+
+    for (const sessionID of INCIDENT_SESSIONS) {
+      const history = yield* db
+        .get<{ state: string; reason: string | null }>(sql`SELECT state, reason FROM session_history_state WHERE session_id = ${sessionID}`)
+        .pipe(Effect.orDie)
+      evidence(
+        "incident-state",
+        `${sessionID} history=${history?.state} reason=${history?.reason ?? "n/a"}`,
+      )
+      if (history?.state !== "recovery_required") return yield* Effect.die(`incident session not in recovery state`)
+    }
+
+    for (const sessionID of INCIDENT_SESSIONS) {
+      const descriptors = yield* resolution.describe(SessionID.make(sessionID))
+      evidence("describe", `${sessionID} descriptors=${descriptors.length} supported=${descriptors.filter((d) => d.resolutionSupported).length}`)
+      for (const descriptor of descriptors) {
+        if (!descriptor.resolutionSupported) {
+          evidence(
+            "describe-unsupported",
+            `${sessionID} receipt=${descriptor.receiptID} reasons=${descriptor.unsupportedReasons.join(",")}`,
+          )
+          return yield* Effect.die(`incident receipt is not resolvable: ${descriptor.receiptID}`)
+        }
+        const resolved = yield* resolution.resolve({
+          sessionID: SessionID.make(sessionID),
+          commandID: `rel-001-drill-${randomUUID().slice(0, 8)}`,
+          receiptID: descriptor.receiptID,
+          decision: "abandoned",
+          expected: {
+            providerState: "indeterminate_after_crash",
+            promptEpoch: descriptor.promptEpoch,
+            sessionMutationEpoch: descriptor.sessionMutationEpoch,
+            requestHash: descriptor.requestHash,
+            historyHash: descriptor.historyHash,
+            worldStateBaselineHash: descriptor.worldStateBaselineHash,
+          },
+          reason: "REL-001 drill: provider outcome unknown after restart",
+          riskAcknowledged: false,
+          actorID: "rel-001-drill",
+        }).pipe(
+          Effect.mapError(
+            (error) =>
+              `resolve conflict: ${error instanceof SessionLegacyProviderResolution.Conflict ? error.reason : error._tag}`,
+          ),
+        )
+        evidence("resolve", `${sessionID} receipt=${descriptor.receiptID} resolution=${resolved.resolutionID}`)
+      }
+    }
+
+    for (const sessionID of INCIDENT_SESSIONS) {
+      const history = yield* db
+        .get<{ state: string }>(sql`SELECT state FROM session_history_state WHERE session_id = ${sessionID}`)
+        .pipe(Effect.orDie)
+      evidence("post-recovery", `${sessionID} history=${history?.state}`)
+      if (history?.state === "recovery_required") return yield* Effect.die(`session still recovery_required after resolution`)
+    }
+
+    evidence("oracle", "provider invocations during abandoned recovery = 0 (any invocation fails the drill)")
+
+    const forkTarget = INCIDENT_SESSIONS[0]
+    const forkResult = yield* sessions
+      .fork({ sessionID: SessionID.make(forkTarget), intentID: `rel-001-drill-fork-${randomUUID().slice(0, 8)}` })
+      .pipe(Effect.provideService(InstanceRef, drillInstanceContext), Effect.exit)
+    if (Exit.isFailure(forkResult)) return yield* Effect.die(`fork smoke failed: ${forkResult.cause}`)
+    evidence("fork", `${forkTarget} fork intent admitted`)
+
+    const user = yield* sessions
+      .updateMessage({
+        id: MessageID.make(`msg_rel001_${randomUUID().slice(0, 8)}`),
+        sessionID: SessionID.make(forkTarget),
+        role: "user",
+        time: { created: Date.now() },
+        agent: "build",
+        model: { providerID: "deepseek", modelID: "deepseek-v4-flash" } as never,
+      })
+      .pipe(Effect.provideService(InstanceRef, drillInstanceContext), Effect.exit)
+    if (Exit.isFailure(user)) return yield* Effect.die(`new message write failed: ${user.cause}`)
+    evidence("new-message", `${forkTarget} post-recovery message write accepted`)
+
+    return { evidence: evidenceLines }
+  }).pipe(Effect.provide(layersFor(database)))
+}
+
+if (import.meta.main) {
+  const source = arg("--db")
+  if (!source) {
+    console.error("usage: bun script/rel-001-drill.ts --db <production-snapshot-drill-copy.db>")
+    process.exit(2)
+  }
+  const database = await copyForDrill(source)
+  const outcome = await Effect.runPromise(runDrill(database).pipe(Effect.exit))
+  if (Exit.isFailure(outcome)) {
+    console.error(`REL-001 drill FAILED: ${outcome.cause}`)
+    process.exit(1)
+  }
+  console.log("REL-001 summary: PASS")
+}
diff --git a/packages/deepagent-code/script/risk-003-maintenance.ts b/packages/deepagent-code/script/risk-003-maintenance.ts
new file mode 100644
index 00000000..bb2e502e
--- /dev/null
+++ b/packages/deepagent-code/script/risk-003-maintenance.ts
@@ -0,0 +1,204 @@
+#!/usr/bin/env bun
+
+import path from "node:path"
+import { stat } from "node:fs/promises"
+import { Effect, Exit, Layer } from "effect"
+import { sql } from "drizzle-orm"
+import { Database } from "@deepagent-code/core/database/database"
+import { EventV2, Cursor } from "@deepagent-code/core/event"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { BackgroundJob } from "@/background/job"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Session } from "@/session/session"
+import { SessionDiffArtifact } from "@/session/diff-artifact"
+import { SessionID } from "@/session/schema"
+
+// RISK-003 data-maintenance drill (BUG-407-010 §14). Runs only against a drill COPY of the
+// production snapshot (basename must contain "drill"). Gate order is strict:
+//   sync backfill → message diff backfill (②③) → snapshot/floor parity + physical deletion (⑥⑦)
+//   → integrity check → VACUUM (⑪). Every gate reports MiB/count evidence before and after;
+//   any failure stops the run before the next irreversible step.
+
+const arg = (name: string) => {
+  const index = process.argv.indexOf(name)
+  return index === -1 ? undefined : process.argv[index + 1]
+}
+
+const MiB = (bytes: number) => (bytes / 1048576).toFixed(1)
+
+const evidenceLines: { step: string; detail: string }[] = []
+const evidence = (step: string, detail: string) => {
+  evidenceLines.push({ step, detail })
+  console.log(`RISK-003 ${step}: ${detail}`)
+}
+
+const layersFor = (database: string) => {
+  // Same wiring as the REL-001 drill: every consumer must point at the drill path explicitly,
+  // because EventV2.defaultLayer bakes the channel-local Database.defaultLayer.
+  const eventV2 = EventV2.layer.pipe(Layer.provide(Database.layerFromPath(database)))
+  const bridge = EventV2Bridge.layer.pipe(Layer.provide(eventV2))
+  const sessionProjector = SessionProjector.layer.pipe(
+    Layer.provide(eventV2),
+    Layer.provide(Database.layerFromPath(database)),
+  )
+  return Layer.mergeAll(
+    Session.layer.pipe(
+      Layer.provide(BackgroundJob.defaultLayer),
+      Layer.provide(Database.layerFromPath(database)),
+      Layer.provide(bridge),
+      Layer.provide(RuntimeFlags.defaultLayer),
+    ),
+    sessionProjector,
+    eventV2,
+    Database.layerFromPath(database),
+  )
+}
+
+export function runMaintenance(input: {
+  database: string
+  aggregateLimit: number
+  skipDelete: boolean
+  skipVacuum: boolean
+}) {
+  return Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    const events = yield* EventV2.Service
+
+    // Gate 0 — survey.
+    const before = yield* db.get<{ bytes: number; rows: number }>(sql`SELECT SUM(LENGTH(data)) AS bytes, COUNT(*) AS rows FROM event`).pipe(Effect.orDie)
+    evidence("survey", `event rows=${before?.rows ?? 0} bytes=${MiB(before?.bytes ?? 0)} MiB`)
+    const aggregates = yield* db.all<{ aggregate_id: string; bytes: number }>(sql`
+      SELECT aggregate_id, SUM(LENGTH(data)) AS bytes FROM event GROUP BY aggregate_id
+      ORDER BY bytes DESC LIMIT ${input.aggregateLimit}
+    `).pipe(Effect.orDie)
+    for (const row of aggregates) evidence("survey-aggregate", `${row.aggregate_id} ${MiB(row.bytes)} MiB`)
+
+    // Gate 1 — sync index backfill (compact refuses to run before this completes).
+    if (!events.backfillSyncIndex) return yield* Effect.die("event sync backfill is unavailable")
+    let backfill = { processed: 0, complete: false }
+    let backfillLoops = 0
+    do {
+      backfill = yield* events.backfillSyncIndex({ limit: 5000 }).pipe(Effect.exit).pipe(
+        Effect.flatMap((exit) => (Exit.isFailure(exit) ? Effect.die(exit.cause) : Effect.succeed(exit.value))),
+      )
+      backfillLoops++
+    } while (!backfill.complete && backfillLoops < 2000)
+    if (!backfill.complete) return yield* Effect.die("sync index backfill did not complete within 2000 batches")
+    evidence("backfill", `sync index complete after ${backfillLoops} batches`)
+
+    // Gate 2 — ②③ message diff backfill (best effort per session; failures log and continue).
+    const sessionsWithDiffs = yield* db.all<{ session_id: string }>(sql`
+      SELECT DISTINCT session_id FROM message
+      WHERE json_extract(data, '$.role') = 'user' AND json_array_length(json_extract(data, '$.summary.diffs')) > 0
+        AND json_extract(data, '$.summary.diffArtifact') IS NULL
+      LIMIT 20
+    `).pipe(Effect.orDie)
+    let migrated = 0
+    let migrationSkipped = 0
+    for (const row of sessionsWithDiffs) {
+      const result = yield* SessionDiffArtifact.migrate({ sessionID: SessionID.make(row.session_id) }).pipe(Effect.exit)
+      if (Exit.isFailure(result)) migrationSkipped++
+      else migrated++
+    }
+    evidence("diff-backfill", `sessions scanned=${sessionsWithDiffs.length} migrated=${migrated} skipped=${migrationSkipped}`)
+
+    // Gate 3 — ⑥⑦ snapshot/floor parity then physical deletion, per aggregate.
+    let totalDeleted = 0
+    let compactedAggregates = 0
+    for (const row of aggregates) {
+      const sequence = yield* db.get<{ seq: number; floor: number | null }>(sql`
+        SELECT seq, retention_floor_seq AS floor FROM event_sequence WHERE aggregate_id = ${row.aggregate_id}
+      `).pipe(Effect.orDie)
+      if (!sequence) continue
+      const throughSeq = sequence.seq
+      if (sequence.floor !== null && sequence.floor >= throughSeq) continue
+      const checkpoint = yield* events.checkpoint({
+        aggregateID: row.aggregate_id,
+        throughSeq: Cursor.make(throughSeq),
+        codec: "session-projection",
+        schemaVersion: 1,
+        expectedLatest: Cursor.make(throughSeq),
+      }).pipe(Effect.exit)
+      if (Exit.isFailure(checkpoint)) {
+        evidence("checkpoint-skip", `${row.aggregate_id} checkpoint failed: ${checkpoint.cause}`)
+        continue
+      }
+      const imported = yield* events.importSnapshot(checkpoint.value).pipe(Effect.exit)
+      if (Exit.isFailure(imported)) {
+        evidence("import-skip", `${row.aggregate_id} snapshot import failed: ${imported.cause}`)
+        continue
+      }
+      if (input.skipDelete) {
+        evidence("floor-ready", `${row.aggregate_id} snapshot ${checkpoint.value.snapshotID} imported, floor=${throughSeq} (delete skipped)`)
+        continue
+      }
+      let deleted = 0
+      let complete = false
+      let loops = 0
+      do {
+        const step = yield* events.compact({ aggregateID: row.aggregate_id, throughSeq: Cursor.make(throughSeq), limit: 100 }).pipe(Effect.exit)
+        if (Exit.isFailure(step)) {
+          evidence("compact-skip", `${row.aggregate_id} compact failed: ${step.cause}`)
+          break
+        }
+        deleted += step.value.deleted
+        complete = step.value.complete
+        loops++
+      } while (!complete && loops < 2000)
+      totalDeleted += deleted
+      compactedAggregates++
+      evidence("compact", `${row.aggregate_id} deleted=${deleted} events complete=${complete}`)
+    }
+    evidence("delete-summary", `aggregates compacted=${compactedAggregates} total events deleted=${totalDeleted}`)
+
+    const after = yield* db.get<{ bytes: number; rows: number }>(sql`SELECT SUM(LENGTH(data)) AS bytes, COUNT(*) AS rows FROM event`).pipe(Effect.orDie)
+    evidence("after-delete", `event rows=${after?.rows ?? 0} bytes=${MiB(after?.bytes ?? 0)} MiB (was ${MiB(before?.bytes ?? 0)} MiB)`)
+
+    // Gate 4 — integrity.
+    const quickCheck = yield* db.get<{ quick_check: string }>(sql`PRAGMA quick_check`).pipe(Effect.orDie)
+    evidence("integrity", `quick_check=${quickCheck?.quick_check}`)
+    if (quickCheck?.quick_check !== "ok") return yield* Effect.die("integrity check failed before VACUUM")
+
+    // Gate 5 — ⑪ VACUUM + acceptance.
+    if (!input.skipVacuum) {
+      const beforeSize = yield* Effect.promise(() => stat(input.database))
+      yield* db.run(sql`VACUUM`).pipe(Effect.orDie)
+      const afterSize = yield* Effect.promise(() => stat(input.database))
+      evidence("vacuum", `file ${MiB(beforeSize.size)} MiB -> ${MiB(afterSize.size)} MiB`)
+      for (const sessionID of ["ses_00c3f7decfffhjQSy69Q5gSd1S", "ses_0149b8afffffWlu80cVGdzFI9s"]) {
+        const state = yield* db.get<{ state: string }>(sql`SELECT state FROM session_history_state WHERE session_id = ${sessionID}`).pipe(Effect.orDie)
+        evidence("acceptance", `${sessionID} history=${state?.state}`)
+      }
+    }
+
+    return { evidence: evidenceLines }
+  })
+}
+
+if (import.meta.main) {
+  const database = arg("--db")
+  if (!database) {
+    console.error("usage: bun script/risk-003-maintenance.ts --db <drill-copy.db> [--aggregates n] [--skip-delete] [--skip-vacuum]")
+    process.exit(2)
+  }
+  if (!path.basename(database).includes("drill")) {
+    console.error(`refusing to maintain a non-drill database: ${database}`)
+    process.exit(2)
+  }
+  const outcome = await Effect.runPromise(
+    runMaintenance({
+      database,
+      aggregateLimit: Number(arg("--aggregates") ?? 5),
+      skipDelete: process.argv.includes("--skip-delete"),
+      skipVacuum: process.argv.includes("--skip-vacuum"),
+    })
+      .pipe(Effect.provide(layersFor(database)))
+      .pipe(Effect.exit),
+  )
+  if (Exit.isFailure(outcome)) {
+    console.error(`RISK-003 maintenance FAILED: ${outcome.cause}`)
+    process.exit(1)
+  }
+  console.log("RISK-003 summary: PASS")
+}
diff --git a/packages/deepagent-code/src/cli/cmd/github.handler.ts b/packages/deepagent-code/src/cli/cmd/github.handler.ts
index e326f404..c4691c39 100644
--- a/packages/deepagent-code/src/cli/cmd/github.handler.ts
+++ b/packages/deepagent-code/src/cli/cmd/github.handler.ts
@@ -364,7 +364,7 @@ jobs:
           persist-credentials: false
 
       - name: Run deepagent-code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5${envStr}
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7${envStr}
         with:
           model: ${provider}/${model}`,
         )
diff --git a/packages/deepagent-code/src/cli/cmd/goal.ts b/packages/deepagent-code/src/cli/cmd/goal.ts
new file mode 100644
index 00000000..ad83a079
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/goal.ts
@@ -0,0 +1,108 @@
+// PARITY-004 long-tail: goal loop controls (status/pause/resume/stop) — CLI
+// parity with the GUI goal controls (app deepagent.ts goal endpoints). Goes
+// through the instance httpapi via the SDK client; never touches the DB.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { UI } from "../ui"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const GoalCommand = cmd({
+  command: "goal",
+  describe: "inspect and control the goal loop of a session",
+  builder: (yargs: Argv) =>
+    yargs
+      .command(GoalStatusCommand)
+      .command(GoalPauseCommand)
+      .command(GoalResumeCommand)
+      .command(GoalStopCommand)
+      .demandCommand(),
+  async handler() {},
+})
+
+type GoalSessionArgs = QueryFormatArgs & { sessionID: string }
+
+function sessionBuilder(yargs: Argv) {
+  return attachOptions(
+    yargs.positional("sessionID", {
+      describe: "session ID",
+      type: "string",
+      demandOption: true,
+    }),
+  )
+}
+
+export const GoalStatusCommand = effectCmd({
+  command: "status <sessionID>",
+  describe: "show the active goal of a session",
+  builder: sessionBuilder,
+  handler: Effect.fn("Cli.goal.status")(function* (rawArgs) {
+    const args = rawArgs as unknown as GoalSessionArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.deepagent.goalStatus({ sessionID: args.sessionID }).catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const goal = result.data?.goal ?? null
+    if (args.format === "json") {
+      console.log(JSON.stringify({ sessionID: args.sessionID, goal }, null, 2))
+      return
+    }
+    if (!goal) {
+      UI.println(`No active goal for session ${args.sessionID}`)
+      return
+    }
+    console.log(
+      formatTable(
+        ["Goal", "Phase", "Running"],
+        [[goal.goalId, goal.phase, goal.running ? "yes" : "no"]],
+      ),
+    )
+  }),
+})
+
+// pause/resume/stop share one shape: POST with {sessionID} → {ok}. `ok:false`
+// means the goal loop is disabled or there was no goal in the right state.
+function goalControl(action: "pause" | "resume" | "stop", done: string) {
+  return effectCmd({
+    command: `${action} <sessionID>`,
+    describe: `${action} the goal loop of a session`,
+    builder: sessionBuilder,
+    handler: Effect.fn(`Cli.goal.${action}`)(function* (rawArgs) {
+      const args = rawArgs as unknown as GoalSessionArgs
+      const maybeCtx = yield* InstanceRef
+      if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+      const ctx = maybeCtx
+      const result = yield* Effect.promise(async () => {
+        const sdk = await createInstanceSDK(args, ctx.worktree)
+        const call =
+          action === "pause"
+            ? sdk.deepagent.goalPause({ sessionID: args.sessionID })
+            : action === "resume"
+              ? sdk.deepagent.goalResume({ sessionID: args.sessionID })
+              : sdk.deepagent.goalStop({ sessionID: args.sessionID })
+        return call.catch((error) => ({ data: undefined, error }))
+      })
+      if (result.error) return yield* fail(formatSdkError(args, result.error))
+      if (args.format === "json") {
+        console.log(JSON.stringify({ sessionID: args.sessionID, action, ok: result.data?.ok ?? false }, null, 2))
+        return
+      }
+      if (!result.data?.ok) {
+        return yield* fail(
+          `Could not ${action} the goal for session ${args.sessionID} — no active goal in the right state (or the goal loop is disabled)`,
+        )
+      }
+      UI.println(UI.Style.TEXT_SUCCESS_BOLD + `${done} goal for session ${args.sessionID}` + UI.Style.TEXT_NORMAL)
+    }),
+  })
+}
+
+export const GoalPauseCommand = goalControl("pause", "Paused")
+export const GoalResumeCommand = goalControl("resume", "Resumed")
+export const GoalStopCommand = goalControl("stop", "Stopped")
diff --git a/packages/deepagent-code/src/cli/cmd/instance-sdk.ts b/packages/deepagent-code/src/cli/cmd/instance-sdk.ts
new file mode 100644
index 00000000..b295c504
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/instance-sdk.ts
@@ -0,0 +1,86 @@
+// Shared SDK bootstrap + output helpers for the PARITY-004 long-tail query &
+// control commands (goal/worktree/oversight/panel/review/wiki/packs).
+//
+// Same two channels as `run`:
+// - default: in-process Server.Default().app.fetch (no server needed)
+// - `--attach <url>`: a live server, authenticated via ServerAuth headers
+// Commands never touch the DB directly — everything goes through the httpapi.
+import { createOpencodeClient, type OpencodeClient } from "@deepagent-code/sdk/v2"
+import type { Argv } from "yargs"
+import { EOL } from "os"
+
+export type AttachArgs = {
+  attach?: string
+  password?: string
+  username?: string
+}
+
+export type QueryFormatArgs = AttachArgs & { format: "table" | "json" }
+
+// Standard option block for every query/control command in this batch.
+export function attachOptions<T>(yargs: Argv<T>) {
+  return yargs
+    .option("attach", {
+      describe: "attach to a running server (e.g. http://localhost:4096)",
+      type: "string",
+    })
+    .option("password", {
+      describe: "password for the attached server",
+      type: "string",
+    })
+    .option("username", {
+      describe: "username for the attached server",
+      type: "string",
+    })
+    .option("format", {
+      describe: "output format",
+      type: "string",
+      choices: ["table", "json"],
+      default: "table",
+    })
+}
+
+export async function createInstanceSDK(args: AttachArgs, directory: string): Promise<OpencodeClient> {
+  if (args.attach) {
+    const { ServerAuth } = await import("@/server/auth")
+    return createOpencodeClient({
+      baseUrl: args.attach,
+      directory,
+      headers: ServerAuth.headers({ password: args.password, username: args.username }),
+    })
+  }
+  const fetchFn = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const { Server } = await import("@/server/server")
+    const request = new Request(input, init)
+    return Server.Default().app.fetch(request)
+  }) as typeof globalThis.fetch
+  return createOpencodeClient({
+    baseUrl: "http://deepagent-code.internal",
+    fetch: fetchFn,
+    directory,
+  })
+}
+
+// Friendly message for SDK call failures. `--attach` against a stopped server
+// surfaces as a fetch/connection error; tell the user what to do about it.
+export function formatSdkError(args: AttachArgs, error: unknown): string {
+  let message: string
+  if (error instanceof Error) message = error.message
+  else if (typeof error === "object" && error !== null && "message" in error && typeof (error as { message: unknown }).message === "string")
+    message = (error as { message: string }).message
+  else message = String(error)
+  if (args.attach && /fetch failed|ECONNREFUSED|connect|network/i.test(message)) {
+    return `Could not reach the server at ${args.attach} — is it running? Start one with: deepagent-code serve`
+  }
+  return message
+}
+
+// Minimal padded table renderer (no dependencies). Rows are pre-stringified.
+export function formatTable(headers: string[], rows: string[][]): string {
+  if (rows.length === 0) return "(empty)"
+  const widths = headers.map((header, index) =>
+    Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length)),
+  )
+  const render = (cells: string[]) => cells.map((cell, index) => (cell ?? "").padEnd(widths[index]!)).join("  ")
+  return [render(headers), widths.map((width) => "─".repeat(width)).join("  "), ...rows.map(render)].join(EOL)
+}
diff --git a/packages/deepagent-code/src/cli/cmd/mcp.ts b/packages/deepagent-code/src/cli/cmd/mcp.ts
index 9459afbb..94135884 100644
--- a/packages/deepagent-code/src/cli/cmd/mcp.ts
+++ b/packages/deepagent-code/src/cli/cmd/mcp.ts
@@ -1,6 +1,6 @@
 import { cmd } from "./cmd"
 import { ConfigV1 } from "@deepagent-code/core/v1/config/config"
-import { effectCmd } from "../effect-cmd"
+import { effectCmd, fail } from "../effect-cmd"
 import { Cause } from "effect"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
@@ -17,7 +17,7 @@ import { AppRuntime } from "@/effect/app-runtime"
 import { InstallationVersion } from "@deepagent-code/core/installation/version"
 import path from "path"
 import { Global } from "@deepagent-code/core/global"
-import { modify, applyEdits } from "jsonc-parser"
+import { modify, applyEdits, parse } from "jsonc-parser"
 import { Filesystem } from "@/util/filesystem"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { EventV2 } from "@deepagent-code/core/event"
@@ -100,7 +100,10 @@ export const McpCommand = cmd({
   builder: (yargs) =>
     yargs
       .command(McpAddCommand)
+      .command(McpRemoveCommand)
+      .command(McpEditCommand)
       .command(McpListCommand)
+      .command(McpCatalogCommand)
       .command(McpAuthCommand)
       .command(McpLogoutCommand)
       .command(McpDebugCommand)
@@ -440,6 +443,211 @@ async function addMcpToConfig(name: string, mcpConfig: ConfigMCPV1.Info, configP
   return configPath
 }
 
+// PARITY-004 quick-win: `mcp remove` parity with the GUI delete button
+// (dialog-select-mcp.tsx). The server definition lives in a jsonc config file
+// (project or global), so removal is a jsonc edit that preserves comments —
+// same mechanism as addMcpToConfig above.
+function projectMcpConfigCandidates(baseDir: string) {
+  return [
+    path.join(baseDir, "deepagent-code.json"),
+    path.join(baseDir, "deepagent-code.jsonc"),
+    path.join(baseDir, ".deepagent-code", "deepagent-code.json"),
+    path.join(baseDir, ".deepagent-code", "deepagent-code.jsonc"),
+  ]
+}
+
+function globalMcpConfigCandidates() {
+  // Matches the files Config.get merges for the global scope (config/config.ts).
+  return ["config.jsonc", "config.json", "deepagent-code.jsonc", "deepagent-code.json"].map((file) =>
+    path.join(Global.Path.config, file),
+  )
+}
+
+async function removeMcpFromConfig(name: string, configPath: string) {
+  if (!(await Filesystem.exists(configPath))) return false
+  const text = await Filesystem.readText(configPath)
+  const parsed = parse(text) as { mcp?: Record<string, unknown> } | undefined
+  if (!parsed || typeof parsed !== "object" || !parsed.mcp || !(name in parsed.mcp)) return false
+  const edits = modify(text, ["mcp", name], undefined, {
+    formattingOptions: { tabSize: 2, insertSpaces: true },
+  })
+  await Filesystem.write(configPath, applyEdits(text, edits))
+  return true
+}
+
+// PARITY-004 long-tail: `mcp edit` modifies an EXISTING server definition in
+// place (updateMcpConfig semantics — the GUI edit dialog rewrites the same
+// entry). Same jsonc-preserving mechanism as add/remove: field-level edits via
+// jsonc-parser so comments and sibling keys survive.
+type McpEditPatch = {
+  url?: string
+  environment?: Record<string, string>
+  headers?: Record<string, string>
+  command?: string[]
+}
+
+async function editMcpInConfig(
+  name: string,
+  configPath: string,
+  patch: McpEditPatch,
+): Promise<{ edited: boolean; error?: string }> {
+  if (!(await Filesystem.exists(configPath))) return { edited: false }
+  const text = await Filesystem.readText(configPath)
+  const parsed = parse(text) as { mcp?: Record<string, ConfigMCPV1.Info> } | undefined
+  const existing = parsed && typeof parsed === "object" ? parsed.mcp?.[name] : undefined
+  if (!existing || typeof existing !== "object" || !("type" in existing)) return { edited: false }
+  if ((patch.url !== undefined || patch.headers !== undefined) && existing.type !== "remote") {
+    return { edited: false, error: `--url/--header only apply to remote servers ("${name}" is ${existing.type} in ${configPath})` }
+  }
+  if ((patch.environment !== undefined || patch.command?.length) && existing.type !== "local") {
+    return { edited: false, error: `--env/command only apply to local servers ("${name}" is ${existing.type} in ${configPath})` }
+  }
+  let result = text
+  const apply = (jsonPath: (string | number)[], value: unknown) => {
+    result = applyEdits(result, modify(result, jsonPath, value, { formattingOptions: { tabSize: 2, insertSpaces: true } }))
+  }
+  if (patch.url !== undefined) apply(["mcp", name, "url"], patch.url)
+  if (patch.command?.length) apply(["mcp", name, "command"], patch.command)
+  for (const [key, value] of Object.entries(patch.environment ?? {})) apply(["mcp", name, "environment", key], value)
+  for (const [key, value] of Object.entries(patch.headers ?? {})) apply(["mcp", name, "headers", key], value)
+  await Filesystem.write(configPath, result)
+  return { edited: true }
+}
+
+export const McpEditCommand = effectCmd({
+  command: "edit <name>",
+  describe: "edit an existing MCP server's configuration (url/env/header/command)",
+  builder: (yargs) =>
+    yargs
+      .positional("name", {
+        describe: "name of the MCP server",
+        type: "string",
+        demandOption: true,
+      })
+      .option("url", {
+        describe: "new URL for a remote MCP server",
+        type: "string",
+      })
+      .option("env", {
+        describe: "environment variable for a local MCP server (KEY=VALUE, merged)",
+        type: "string",
+        array: true,
+      })
+      .option("header", {
+        describe: "HTTP header for a remote MCP server (KEY=VALUE, merged)",
+        type: "string",
+        array: true,
+      }),
+  handler: Effect.fn("Cli.mcp.edit")(function* (args) {
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const command = (args["--"] ?? []) as string[]
+    if (!args.url && !args.env?.length && !args.header?.length && !command.length) {
+      return yield* fail("No changes provided. Use --url, --env, --header, or a command after --.")
+    }
+    if (args.url && !URL.canParse(args.url)) return yield* fail(`Invalid URL: ${args.url}`)
+    const entries = (values: string[], kind: string) =>
+      Object.fromEntries(
+        values.map((entry) => {
+          const index = entry.indexOf("=")
+          if (index < 1) throw new Error(`Invalid ${kind}: ${entry}. Expected KEY=VALUE`)
+          return [entry.slice(0, index), entry.slice(index + 1)]
+        }),
+      )
+    const patch: McpEditPatch = {
+      ...(args.url ? { url: args.url } : {}),
+      ...(args.env?.length ? { environment: entries(args.env, "environment variable") } : {}),
+      ...(args.header?.length ? { headers: entries(args.header, "HTTP header") } : {}),
+      ...(command.length ? { command } : {}),
+    }
+    const outcome = yield* Effect.promise(async () => {
+      const candidates = [...projectMcpConfigCandidates(ctx.worktree), ...globalMcpConfigCandidates()]
+      const editedFrom: string[] = []
+      let error: string | undefined
+      for (const configPath of candidates) {
+        const result = await editMcpInConfig(args.name, configPath, patch)
+        if (result.error) error ??= result.error
+        else if (result.edited) editedFrom.push(configPath)
+      }
+      return { editedFrom, error }
+    })
+    if (outcome.editedFrom.length === 0) return yield* fail(outcome.error ?? `MCP server not found: ${args.name}`)
+    for (const configPath of outcome.editedFrom) {
+      UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Updated MCP server "${args.name}" in ${configPath}` + UI.Style.TEXT_NORMAL)
+    }
+  }),
+})
+
+export const McpRemoveCommand = effectCmd({
+  command: "remove <name>",
+  aliases: ["rm"],
+  describe: "remove an MCP server from the project or global config",
+  builder: (yargs) =>
+    yargs.positional("name", {
+      describe: "name of the MCP server",
+      type: "string",
+      demandOption: true,
+    }),
+  handler: Effect.fn("Cli.mcp.remove")(function* (args) {
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const removedFrom = yield* Effect.promise(async () => {
+      const candidates = [...projectMcpConfigCandidates(ctx.worktree), ...globalMcpConfigCandidates()]
+      const paths: string[] = []
+      for (const configPath of candidates) {
+        if (await removeMcpFromConfig(args.name, configPath)) paths.push(configPath)
+      }
+      return paths
+    })
+    if (removedFrom.length === 0) return yield* fail(`MCP server not found: ${args.name}`)
+    for (const configPath of removedFrom) {
+      UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Removed MCP server "${args.name}" from ${configPath}` + UI.Style.TEXT_NORMAL)
+    }
+    UI.println(UI.Style.TEXT_DIM + "OAuth credentials (if any) remain; drop them with: deepagent-code mcp logout " + args.name + UI.Style.TEXT_NORMAL)
+  }),
+})
+
+// PARITY-004 quick-win: `mcp catalog` parity with the GUI preset catalog
+// (groups/mcp.ts `catalog` + dialog-add-mcp.tsx). The catalog is static
+// metadata (McpCatalog.list()) — listing connects nothing. `--format json`
+// keeps the output scriptable.
+export const McpCatalogCommand = effectCmd({
+  command: "catalog",
+  describe: "list preset MCP servers from the vetted catalog (metadata only)",
+  builder: (yargs) =>
+    yargs.option("format", {
+      describe: "output format",
+      type: "string",
+      choices: ["table", "json"],
+      default: "table",
+    }),
+  handler: Effect.fn("Cli.mcp.catalog")(function* (args) {
+    const entries = yield* MCP.Service.use((mcp) => mcp.catalog())
+    if (args.format === "json") {
+      console.log(JSON.stringify(entries, null, 2))
+      return
+    }
+    UI.empty()
+    prompts.intro("MCP Preset Catalog")
+    if (entries.length === 0) {
+      prompts.log.warn("No preset MCP servers in the catalog")
+      prompts.outro("Done")
+      return
+    }
+    for (const entry of entries) {
+      const creds = entry.credentials.length
+        ? ` (credentials: ${entry.credentials.map((credential) => credential.key).join(", ")})`
+        : ""
+      prompts.log.info(
+        `${entry.id} — ${entry.title} [${entry.transport}/${entry.riskTier}]${creds}\n    ${UI.Style.TEXT_DIM}${entry.description}${UI.Style.TEXT_NORMAL}`,
+      )
+    }
+    prompts.outro(`${entries.length} preset(s); enable one from the GUI MCP dialog or add it manually with: deepagent-code mcp add`)
+  }),
+})
+
 export const McpAddCommand = effectCmd({
   command: "add [name]",
   describe: "add an MCP server",
diff --git a/packages/deepagent-code/src/cli/cmd/oversight.ts b/packages/deepagent-code/src/cli/cmd/oversight.ts
new file mode 100644
index 00000000..72b4cb92
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/oversight.ts
@@ -0,0 +1,93 @@
+// PARITY-004 long-tail: oversight approval queue read-side for the CLI.
+// Query-only template: SDK client + table/json output, no direct DB access.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const OversightCommand = cmd({
+  command: "oversight",
+  describe: "inspect the agent oversight plane (approvals, metrics)",
+  builder: (yargs: Argv) => yargs.command(OversightListCommand).command(OversightMetricsCommand).demandCommand(),
+  async handler() {},
+})
+
+export const OversightListCommand = effectCmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list pending approval queue items",
+  builder: (yargs) => attachOptions(yargs),
+  handler: Effect.fn("Cli.oversight.list")(function* (rawArgs) {
+    const args = rawArgs as unknown as QueryFormatArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.oversight.approvals({}).catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const items = result.data?.items ?? []
+    if (args.format === "json") {
+      console.log(JSON.stringify(items, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["ID", "Event", "Status", "Decision", "Summary"],
+        items.map((item) => [
+          item.id,
+          item.eventType,
+          item.status,
+          item.decision ?? "-",
+          item.summary.length > 60 ? item.summary.slice(0, 57) + "..." : item.summary,
+        ]),
+      ),
+    )
+  }),
+})
+
+type OversightMetricsArgs = QueryFormatArgs & { from?: string; to?: string }
+
+export const OversightMetricsCommand = effectCmd({
+  command: "metrics",
+  describe: "show oversight metrics (DLQ, success rate, conflict rate)",
+  builder: (yargs) =>
+    attachOptions(yargs)
+      .option("from", { describe: "window start (epoch ms)", type: "string" })
+      .option("to", { describe: "window end (epoch ms)", type: "string" }),
+  handler: Effect.fn("Cli.oversight.metrics")(function* (rawArgs) {
+    const args = rawArgs as unknown as OversightMetricsArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.oversight
+        .metrics({ ...(args.from ? { from: args.from } : {}), ...(args.to ? { to: args.to } : {}) })
+        .catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const metrics = result.data
+    if (!metrics) return yield* fail("Oversight metrics returned no data")
+    if (args.format === "json") {
+      console.log(JSON.stringify(metrics, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["Metric", "Value"],
+        [
+          ["DLQ events total", String(metrics.dlqEventsTotal)],
+          ["Agent task success rate", String(metrics.agentTaskSuccessRate)],
+          ["Agent tasks completed", String(metrics.agentTaskCompleted)],
+          ["Agent tasks failed", String(metrics.agentTaskFailed)],
+          ["Agent conflict rate", String(metrics.agentConflictRate)],
+          ["Agent push rejected total", String(metrics.agentPushRejectedTotal)],
+        ],
+      ),
+    )
+  }),
+})
diff --git a/packages/deepagent-code/src/cli/cmd/packs.ts b/packages/deepagent-code/src/cli/cmd/packs.ts
new file mode 100644
index 00000000..bae060ca
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/packs.ts
@@ -0,0 +1,64 @@
+// PARITY-004 long-tail: domain pack listing for the CLI.
+// Query-only template: SDK client + table/json output, no direct DB access.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const PacksCommand = cmd({
+  command: "packs",
+  describe: "inspect domain packs",
+  builder: (yargs: Argv) => yargs.command(PacksListCommand).demandCommand(),
+  async handler() {},
+})
+
+type PacksListArgs = QueryFormatArgs & { all?: boolean }
+
+export const PacksListCommand = effectCmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list active domain packs (or the full catalog with --all)",
+  builder: (yargs) =>
+    attachOptions(yargs).option("all", {
+      describe: "show the full installed catalog instead of the active set",
+      type: "boolean",
+      default: false,
+    }),
+  handler: Effect.fn("Cli.packs.list")(function* (rawArgs) {
+    const args = rawArgs as unknown as PacksListArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      const call = args.all ? sdk.deepagent.packsAll({}) : sdk.deepagent.packsActive({})
+      return call.catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const data = result.data
+    if (!data) return yield* fail("Packs listing returned no data")
+    const packs = data.packs
+    if (args.format === "json") {
+      console.log(JSON.stringify(data, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["ID", "Name", "Version", "Risk", "Pinned", "Domains"],
+        packs.map((pack) => [
+          pack.id,
+          pack.name,
+          pack.version,
+          pack.risk,
+          pack.pinned ? "yes" : "no",
+          pack.domains.join(", "),
+        ]),
+      ),
+    )
+    if (!args.all && "snapshotId" in data) {
+      console.log(`snapshot: ${data.snapshotId}`)
+    }
+  }),
+})
diff --git a/packages/deepagent-code/src/cli/cmd/panel.ts b/packages/deepagent-code/src/cli/cmd/panel.ts
new file mode 100644
index 00000000..8655d572
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/panel.ts
@@ -0,0 +1,53 @@
+// PARITY-004 long-tail: Expert Panel armed-state query for the CLI.
+// Query-only template: SDK client + table/json output, no direct DB access.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const PanelCommand = cmd({
+  command: "panel",
+  describe: "inspect the Expert Panel state",
+  builder: (yargs: Argv) => yargs.command(PanelStatusCommand).demandCommand(),
+  async handler() {},
+})
+
+type PanelStatusArgs = QueryFormatArgs & { sessionID: string }
+
+export const PanelStatusCommand = effectCmd({
+  command: "status <sessionID>",
+  describe: "show the effective Expert Panel armed state for a session",
+  builder: (yargs) =>
+    attachOptions(
+      yargs.positional("sessionID", {
+        describe: "session ID",
+        type: "string",
+        demandOption: true,
+      }),
+    ),
+  handler: Effect.fn("Cli.panel.status")(function* (rawArgs) {
+    const args = rawArgs as unknown as PanelStatusArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.deepagent.panel.status({ sessionID: args.sessionID }).catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const status = result.data
+    if (!status) return yield* fail("Panel status returned no data")
+    if (args.format === "json") {
+      console.log(JSON.stringify(status, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["Session", "Armed", "Explicit", "Rounds"],
+        [[status.sessionID, status.armed ? "yes" : "no", status.explicit ? "yes" : "no (global default)", status.rounds]],
+      ),
+    )
+  }),
+})
diff --git a/packages/deepagent-code/src/cli/cmd/review.ts b/packages/deepagent-code/src/cli/cmd/review.ts
new file mode 100644
index 00000000..3a1d879f
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/review.ts
@@ -0,0 +1,50 @@
+// PARITY-004 long-tail: DeepAgent run review list for the CLI.
+// Query-only template: SDK client + table/json output, no direct DB access.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const ReviewCommand = cmd({
+  command: "review",
+  describe: "inspect DeepAgent run reviews",
+  builder: (yargs: Argv) => yargs.command(ReviewListCommand).demandCommand(),
+  async handler() {},
+})
+
+export const ReviewListCommand = effectCmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list recent DeepAgent run reviews",
+  builder: (yargs) => attachOptions(yargs),
+  handler: Effect.fn("Cli.review.list")(function* (rawArgs) {
+    const args = rawArgs as unknown as QueryFormatArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.deepagent.reviews({}).catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const reviews = result.data?.reviews ?? []
+    if (args.format === "json") {
+      console.log(JSON.stringify(reviews, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["Run", "Mode", "Status", "Next action", "Diagnosis"],
+        reviews.map((review) => [
+          review.runId,
+          review.agentMode,
+          review.status,
+          review.nextAction,
+          review.diagnosis.status,
+        ]),
+      ),
+    )
+  }),
+})
diff --git a/packages/deepagent-code/src/cli/cmd/run.ts b/packages/deepagent-code/src/cli/cmd/run.ts
index d9f85017..becce1b1 100644
--- a/packages/deepagent-code/src/cli/cmd/run.ts
+++ b/packages/deepagent-code/src/cli/cmd/run.ts
@@ -25,6 +25,7 @@ import { createOpencodeClient, type OpencodeClient, type ToolPart } from "@deepa
 import { FormatError, FormatUnknownError } from "../error"
 import { INTERACTIVE_INPUT_ERROR, resolveInteractiveStdin } from "./run/runtime.stdin"
 import { backgroundTask, createBackgroundSessions, createSessionTree, questionAnswers } from "./run/noninteractive"
+import { PERMISSION_MODES, permissionReplyFor, resolvePermissionMode, type PermissionMode } from "./run/permission-mode"
 import { Identifier } from "@deepagent-code/core/util/identifier"
 
 type ModelInput = Parameters<OpencodeClient["session"]["prompt"]>[0]["model"]
@@ -238,9 +239,18 @@ export const RunCommand = effectCmd({
       })
       .option("dangerously-skip-permissions", {
         type: "boolean",
-        describe: "auto-approve permissions that are not explicitly denied (dangerous!)",
+        describe: "alias for --permission-mode full-access: auto-approve permissions not explicitly denied (dangerous!)",
         default: false,
       })
+      .option("permission-mode", {
+        type: "string",
+        choices: [...PERMISSION_MODES],
+        // No yargs default: resolvePermissionMode() defaults to "request" and
+        // must be able to tell an explicit --permission-mode apart from the
+        // absent flag when validating the --dangerously-skip-permissions alias.
+        describe:
+          "permission auto-response mode: request rejects every prompt, read-only rejects mutating tools (edit/write/patch/bash/task/external_directory) and approves the rest, full-access approves everything (dangerous!)",
+      })
       .option("question-answer", {
         type: "string",
         array: true,
@@ -306,6 +316,13 @@ export const RunCommand = effectCmd({
         die("--demo requires --interactive")
       }
 
+      let permissionMode: PermissionMode = "request"
+      try {
+        permissionMode = resolvePermissionMode(args)
+      } catch (error) {
+        die(error instanceof Error ? error.message : String(error))
+      }
+
       if (args.interactive && args.format === "json") {
         die("--interactive cannot be used with --format json")
       }
@@ -845,24 +862,20 @@ export const RunCommand = effectCmd({
               const permission = event.properties
               if (!(await sessions.contains(permission.sessionID))) continue
 
-              if (args["dangerously-skip-permissions"]) {
-                await client.permission.reply({
-                  requestID: permission.id,
-                  reply: "once",
-                })
-                emit("permission", { request: permission, reply: "once" })
-              } else {
-                await client.permission.reply({
-                  requestID: permission.id,
-                  reply: "reject",
-                })
-                if (!emit("permission", { request: permission, reply: "reject" })) {
-                  UI.println(
-                    UI.Style.TEXT_WARNING_BOLD + "!",
-                    UI.Style.TEXT_NORMAL +
-                      `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting`,
-                  )
-                }
+              // Tri-state auto-responder (PARITY-002): request / read-only /
+              // full-access, mirroring the GUI directory approval modes.
+              const reply = permissionReplyFor(permissionMode, permission.permission)
+              await client.permission.reply({
+                requestID: permission.id,
+                reply,
+              })
+              if (!emit("permission", { request: permission, reply }) && reply === "reject") {
+                UI.println(
+                  UI.Style.TEXT_WARNING_BOLD + "!",
+                  UI.Style.TEXT_NORMAL +
+                    `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting` +
+                    (permissionMode === "read-only" ? " (read-only mode)" : ""),
+                )
               }
             }
 
diff --git a/packages/deepagent-code/src/cli/cmd/run/permission-mode.ts b/packages/deepagent-code/src/cli/cmd/run/permission-mode.ts
new file mode 100644
index 00000000..ceee88f3
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/run/permission-mode.ts
@@ -0,0 +1,50 @@
+// CLI permission tri-state auto-responder (PARITY-002).
+//
+// Mirrors the GUI directory approval modes (packages/app permission.tsx):
+//   request      → every permission prompt is auto-rejected (legacy default)
+//   read-only    → mutating tools (MUTATING_PERMISSIONS from core) are
+//                  rejected, everything else is approved once so the agent
+//                  can still inspect the workspace
+//   full-access  → every prompt is approved once
+//                  (`--dangerously-skip-permissions` is kept as an alias)
+import { isMutatingPermission } from "@deepagent-code/core/permission/mutating"
+
+export const PERMISSION_MODES = ["request", "read-only", "full-access"] as const
+export type PermissionMode = (typeof PERMISSION_MODES)[number]
+
+export type PermissionAutoReply = "once" | "reject"
+
+export function isPermissionMode(value: unknown): value is PermissionMode {
+  return typeof value === "string" && (PERMISSION_MODES as readonly string[]).includes(value)
+}
+
+// Resolves the effective mode from the parsed CLI args. Throws (caller turns
+// into a CLI usage error) on unknown values or contradictory flag combos.
+export function resolvePermissionMode(input: {
+  "permission-mode"?: string
+  "dangerously-skip-permissions"?: boolean
+}): PermissionMode {
+  const raw = input["permission-mode"]
+  if (raw !== undefined && !isPermissionMode(raw)) {
+    throw new Error(`--permission-mode must be one of: ${PERMISSION_MODES.join(", ")}`)
+  }
+  const mode: PermissionMode = raw ?? "request"
+  if (input["dangerously-skip-permissions"]) {
+    // The legacy flag is an alias for full-access; combining it with a
+    // different mode is contradictory.
+    if (raw !== undefined && mode !== "full-access") {
+      throw new Error(
+        "--dangerously-skip-permissions is an alias for --permission-mode full-access and cannot be combined with another mode",
+      )
+    }
+    return "full-access"
+  }
+  return mode
+}
+
+// Decides the auto-reply for one permission prompt under the given mode.
+export function permissionReplyFor(mode: PermissionMode, permission: string): PermissionAutoReply {
+  if (mode === "full-access") return "once"
+  if (mode === "read-only") return isMutatingPermission(permission) ? "reject" : "once"
+  return "reject"
+}
diff --git a/packages/deepagent-code/src/cli/cmd/serve.ts b/packages/deepagent-code/src/cli/cmd/serve.ts
index 100874ca..64b70709 100644
--- a/packages/deepagent-code/src/cli/cmd/serve.ts
+++ b/packages/deepagent-code/src/cli/cmd/serve.ts
@@ -2,10 +2,68 @@ import { Effect } from "effect"
 import { effectCmd } from "../effect-cmd"
 import { withNetworkOptions, resolveNetworkOptions } from "../network"
 import { Flag } from "@deepagent-code/core/flag/flag"
+import { Global } from "@deepagent-code/core/global"
+import { InstallationVersion } from "@deepagent-code/core/installation/version"
+import { randomUUID } from "node:crypto"
+import fsSync from "node:fs"
+import path from "node:path"
+
+// PARITY-003 (Wave 0): lets the new CLI daemon mount this legacy server. Mirrors Daemon.register
+// (packages/cli/src/services/daemon.ts) — atomic state/server.json write, 10s heartbeat that
+// self-terminates when superseded, and file removal on shutdown while we still own it. Plain Node
+// on purpose: the legacy CLI must not depend on the new cli package.
+function registerWithDaemon(url: string, stop: () => Promise<void>) {
+  const file = path.join(Global.Path.state, "server.json")
+  const id = randomUUID()
+  const read = (): { id?: string } | undefined => {
+    try {
+      return JSON.parse(fsSync.readFileSync(file, "utf8"))
+    } catch {
+      return undefined
+    }
+  }
+  const owned = () => read()?.id === id
+  fsSync.mkdirSync(path.dirname(file), { recursive: true })
+  const temp = `${file}.${id}.tmp`
+  fsSync.writeFileSync(temp, JSON.stringify({ id, version: InstallationVersion, url, pid: process.pid }), {
+    mode: 0o600,
+  })
+  fsSync.renameSync(temp, file)
+
+  const heartbeat = setInterval(() => {
+    // Another server took over the registration — the daemon moved on, step down.
+    if (!owned()) process.kill(process.pid, "SIGTERM")
+  }, 10_000)
+  heartbeat.unref()
+
+  let exiting = false
+  const shutdown = () => {
+    if (exiting) return
+    exiting = true
+    clearInterval(heartbeat)
+    if (owned()) {
+      try {
+        fsSync.unlinkSync(file)
+      } catch {
+        // A concurrent takeover may have already replaced the file.
+      }
+    }
+    void stop().finally(() => process.exit(0))
+    // Hard ceiling so a stuck graceful stop cannot outlive the daemon's SIGKILL budget.
+    setTimeout(() => process.exit(0), 2_000).unref()
+  }
+  process.on("SIGTERM", shutdown)
+  process.on("SIGINT", shutdown)
+}
 
 export const ServeCommand = effectCmd({
   command: "serve",
-  builder: (yargs) => withNetworkOptions(yargs),
+  builder: (yargs) =>
+    withNetworkOptions(yargs).option("register", {
+      type: "boolean" as const,
+      default: false,
+      describe: "register this server with the local CLI daemon (writes state/server.json)",
+    }),
   describe: "starts a headless deepagent-code server",
   // Server loads instances per-request via x-deepagent-code-directory header — no
   // need for an ambient project InstanceContext at startup.
@@ -19,6 +77,10 @@ export const ServeCommand = effectCmd({
     const server = yield* Effect.promise(() => Server.listen(opts))
     console.log(`deepagent-code server listening on http://${server.hostname}:${server.port}`)
 
+    if (args.register) {
+      registerWithDaemon(`http://${server.hostname}:${server.port}`, () => server.stop(true))
+    }
+
     yield* Effect.never
   }),
 })
diff --git a/packages/deepagent-code/src/cli/cmd/session.ts b/packages/deepagent-code/src/cli/cmd/session.ts
index 185b6698..7bb08e42 100644
--- a/packages/deepagent-code/src/cli/cmd/session.ts
+++ b/packages/deepagent-code/src/cli/cmd/session.ts
@@ -44,10 +44,79 @@ function pagerCmd(): string[] {
 export const SessionCommand = cmd({
   command: "session",
   describe: "manage sessions",
-  builder: (yargs: Argv) => yargs.command(SessionListCommand).command(SessionDeleteCommand).demandCommand(),
+  builder: (yargs: Argv) =>
+    yargs
+      .command(SessionListCommand)
+      .command(SessionDeleteCommand)
+      .command(SessionRenameCommand)
+      .command(SessionArchiveCommand)
+      .demandCommand(),
   async handler() {},
 })
 
+// PARITY-004 long-tail: `session rename` / `session archive` parity with the
+// GUI session context menu. Same service calls as the httpapi session update
+// handler (setTitle / setArchived) — the CLI owns the local instance, so it
+// drives Session.Service directly like `session list` / `session delete`.
+export const SessionRenameCommand = effectCmd({
+  command: "rename <sessionID> <title>",
+  describe: "rename a session",
+  builder: (yargs) =>
+    yargs
+      .positional("sessionID", {
+        describe: "session ID to rename",
+        type: "string",
+        demandOption: true,
+      })
+      .positional("title", {
+        describe: "new title for the session",
+        type: "string",
+        demandOption: true,
+      }),
+  handler: Effect.fn("Cli.session.rename")(function* (args) {
+    const svc = yield* Session.Service
+    const sessionID = SessionID.make(args.sessionID)
+    yield* svc
+      .get(sessionID)
+      .pipe(Effect.catchIf(NotFoundError.isInstance, () => fail(`Session not found: ${args.sessionID}`)))
+    yield* svc.setTitle({ sessionID, title: args.title })
+    UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Session ${args.sessionID} renamed to "${args.title}"` + UI.Style.TEXT_NORMAL)
+  }),
+})
+
+export const SessionArchiveCommand = effectCmd({
+  command: "archive <sessionID>",
+  describe: "archive a session (or restore it with --undo)",
+  builder: (yargs) =>
+    yargs
+      .positional("sessionID", {
+        describe: "session ID to archive",
+        type: "string",
+        demandOption: true,
+      })
+      .option("undo", {
+        describe: "restore an archived session",
+        type: "boolean",
+        default: false,
+      }),
+  handler: Effect.fn("Cli.session.archive")(function* (args) {
+    const svc = yield* Session.Service
+    const sessionID = SessionID.make(args.sessionID)
+    const session = yield* svc
+      .get(sessionID)
+      .pipe(Effect.catchIf(NotFoundError.isInstance, () => fail(`Session not found: ${args.sessionID}`)))
+    if (args.undo && !session.time.archived) {
+      return yield* fail(`Session ${args.sessionID} is not archived`)
+    }
+    yield* svc.setArchived({ sessionID, time: args.undo ? null : Date.now() })
+    UI.println(
+      UI.Style.TEXT_SUCCESS_BOLD +
+        (args.undo ? `Session ${args.sessionID} restored` : `Session ${args.sessionID} archived`) +
+        UI.Style.TEXT_NORMAL,
+    )
+  }),
+})
+
 export const SessionDeleteCommand = effectCmd({
   command: "delete <sessionID>",
   describe: "delete a session",
@@ -140,6 +209,7 @@ function formatSessionJSON(sessions: Session.Info[]): string {
     title: session.title,
     updated: session.time.updated,
     created: session.time.created,
+    archived: session.time.archived ?? null,
     projectId: session.projectID,
     directory: session.directory,
   }))
diff --git a/packages/deepagent-code/src/cli/cmd/wiki.ts b/packages/deepagent-code/src/cli/cmd/wiki.ts
new file mode 100644
index 00000000..001f167a
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/wiki.ts
@@ -0,0 +1,107 @@
+// PARITY-004 long-tail: Wiki read-side for the CLI (list + search).
+// Query-only template: SDK client + table/json output, no direct DB access.
+// Endpoints are gated by the wiki flag — a disabled wiki surfaces as a
+// friendly server error.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const WikiCommand = cmd({
+  command: "wiki",
+  describe: "browse and search the project Wiki",
+  builder: (yargs: Argv) => yargs.command(WikiListCommand).command(WikiSearchCommand).demandCommand(),
+  async handler() {},
+})
+
+type WikiListArgs = QueryFormatArgs & { type?: string }
+
+export const WikiListCommand = effectCmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list Wiki pages",
+  builder: (yargs) =>
+    attachOptions(yargs).option("type", {
+      describe: "filter by page type",
+      type: "string",
+    }),
+  handler: Effect.fn("Cli.wiki.list")(function* (rawArgs) {
+    const args = rawArgs as unknown as WikiListArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.deepagent.wiki
+        .pages({ ...(args.type ? { type: args.type } : {}) })
+        .catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const pages = result.data?.pages ?? []
+    if (args.format === "json") {
+      console.log(JSON.stringify(pages, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["Doc", "Type", "Scope", "Version", "Editable", "Title"],
+        pages.map((page) => [
+          page.docId,
+          page.type,
+          page.scope,
+          String(page.version),
+          page.editable ? "yes" : "no",
+          page.title,
+        ]),
+      ),
+    )
+  }),
+})
+
+type WikiSearchArgs = QueryFormatArgs & { text: string; type?: string; scope?: string }
+
+export const WikiSearchCommand = effectCmd({
+  command: "search <text>",
+  describe: "full-text search over the Wiki",
+  builder: (yargs) =>
+    attachOptions(
+      yargs
+        .positional("text", {
+          describe: "search text",
+          type: "string",
+          demandOption: true,
+        })
+        .option("type", { describe: "filter by page type", type: "string" })
+        .option("scope", { describe: "filter by scope", type: "string" }),
+    ),
+  handler: Effect.fn("Cli.wiki.search")(function* (rawArgs) {
+    const args = rawArgs as unknown as WikiSearchArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.deepagent
+        .wikiSearch({
+          text: args.text,
+          ...(args.type ? { type: args.type } : {}),
+          ...(args.scope ? { scope: args.scope } : {}),
+        })
+        .catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const hits = result.data?.hits ?? []
+    if (args.format === "json") {
+      console.log(JSON.stringify(hits, null, 2))
+      return
+    }
+    console.log(
+      formatTable(
+        ["Doc", "Type", "Scope", "Score", "Title"],
+        hits.map((hit) => [hit.docId, hit.type, hit.scope, String(hit.score), hit.title]),
+      ),
+    )
+  }),
+})
diff --git a/packages/deepagent-code/src/cli/cmd/worktree.ts b/packages/deepagent-code/src/cli/cmd/worktree.ts
new file mode 100644
index 00000000..6c719777
--- /dev/null
+++ b/packages/deepagent-code/src/cli/cmd/worktree.ts
@@ -0,0 +1,136 @@
+// PARITY-004 long-tail: basic worktree commands (list/create/remove) — CLI
+// parity with the GUI worktree panel. Wraps the experimental worktree
+// endpoints through the SDK client; removal is fail-closed (safe-remove)
+// unless --force is passed.
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd, fail } from "../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import { UI } from "../ui"
+import { attachOptions, createInstanceSDK, formatSdkError, formatTable, type QueryFormatArgs } from "./instance-sdk"
+
+export const WorktreeCommand = cmd({
+  command: "worktree",
+  describe: "manage git worktrees for the current project",
+  builder: (yargs: Argv) =>
+    yargs
+      .command(WorktreeListCommand)
+      .command(WorktreeCreateCommand)
+      .command(WorktreeRemoveCommand)
+      .demandCommand(),
+  async handler() {},
+})
+
+export const WorktreeListCommand = effectCmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list worktrees of the current project",
+  builder: (yargs) => attachOptions(yargs),
+  handler: Effect.fn("Cli.worktree.list")(function* (rawArgs) {
+    const args = rawArgs as unknown as QueryFormatArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.worktree.list({}).catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const worktrees = result.data ?? []
+    if (args.format === "json") {
+      console.log(JSON.stringify(worktrees, null, 2))
+      return
+    }
+    console.log(formatTable(["Worktree"], worktrees.map((directory) => [directory])))
+  }),
+})
+
+type WorktreeCreateArgs = QueryFormatArgs & { name?: string; startCommand?: string }
+
+export const WorktreeCreateCommand = effectCmd({
+  command: "create",
+  describe: "create a new worktree",
+  builder: (yargs) =>
+    attachOptions(yargs)
+      .option("name", {
+        describe: "worktree/branch name (default: auto-generated)",
+        type: "string",
+      })
+      .option("start-command", {
+        describe: "additional startup script to run after the project's start command",
+        type: "string",
+      }),
+  handler: Effect.fn("Cli.worktree.create")(function* (rawArgs) {
+    const args = rawArgs as unknown as WorktreeCreateArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.worktree
+        .create({
+          worktreeCreateInput: {
+            ...(args.name ? { name: args.name } : {}),
+            ...(args.startCommand ? { startCommand: args.startCommand } : {}),
+          },
+        })
+        .catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    const worktree = result.data
+    if (!worktree) return yield* fail("Worktree creation returned no data")
+    if (args.format === "json") {
+      console.log(JSON.stringify(worktree, null, 2))
+      return
+    }
+    UI.println(
+      UI.Style.TEXT_SUCCESS_BOLD +
+        `Created worktree "${worktree.name}"${worktree.branch ? ` (branch ${worktree.branch})` : ""} at ${worktree.directory}` +
+        UI.Style.TEXT_NORMAL,
+    )
+  }),
+})
+
+type WorktreeRemoveArgs = QueryFormatArgs & { directory: string; force?: boolean }
+
+export const WorktreeRemoveCommand = effectCmd({
+  command: "remove <directory>",
+  aliases: ["rm"],
+  describe: "remove a worktree (fail-closed unless --force)",
+  builder: (yargs) =>
+    attachOptions(
+      yargs
+        .positional("directory", {
+          describe: "worktree directory to remove",
+          type: "string",
+          demandOption: true,
+        })
+        .option("force", {
+          describe: "remove even if the worktree has uncommitted changes",
+          type: "boolean",
+          default: false,
+        }),
+    ),
+  handler: Effect.fn("Cli.worktree.remove")(function* (rawArgs) {
+    const args = rawArgs as unknown as WorktreeRemoveArgs
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const result = yield* Effect.promise(async () => {
+      const sdk = await createInstanceSDK(args, ctx.worktree)
+      return sdk.worktree
+        .safeRemove({ worktreeSafeRemoveInput: { directory: args.directory, ...(args.force ? { force: true } : {}) } })
+        .catch((error) => ({ data: undefined, error }))
+    })
+    if (result.error) return yield* fail(formatSdkError(args, result.error))
+    if (args.format === "json") {
+      console.log(JSON.stringify({ directory: args.directory, removed: result.data ?? false }, null, 2))
+      return
+    }
+    if (!result.data) {
+      return yield* fail(`Worktree ${args.directory} was not removed (uncommitted changes? retry with --force)`)
+    }
+    UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Removed worktree ${args.directory}` + UI.Style.TEXT_NORMAL)
+  }),
+})
diff --git a/packages/deepagent-code/src/context-federation/diagnostics.ts b/packages/deepagent-code/src/context-federation/diagnostics.ts
index f090b090..17313a67 100644
--- a/packages/deepagent-code/src/context-federation/diagnostics.ts
+++ b/packages/deepagent-code/src/context-federation/diagnostics.ts
@@ -17,7 +17,8 @@ import { SessionSchema } from "@deepagent-code/core/session/schema"
 import { SessionV1 } from "@deepagent-code/core/v1/session"
 import { SessionToolRequestResolutionTable } from "@deepagent-code/core/session/sql"
 import { SessionToolRequestReceiptTable } from "../session/tool-request-receipt.sql"
-import { and, desc, eq, inArray, isNull } from "drizzle-orm"
+import { TurnStageEvidence } from "../session/turn-stage-evidence"
+import { and, desc, eq, gte, inArray, isNull, lte } from "drizzle-orm"
 import { Cause, Context, Effect, Layer, Ref, Schema } from "effect"
 import { randomUUID } from "node:crypto"
 import { Session } from "../session/session"
@@ -44,6 +45,22 @@ const StoredSelectedRef = Schema.Struct({
 
 export type ResolutionDecision = "abandoned" | "settled" | "replayed"
 
+// FEAT-005: cohort-level readiness buckets. A selection's per-graph status states fold into one of
+// four buckets so a rollout dashboard can tell cold-start (building) apart from genuine degradation
+// or an authorization block — the in-memory observability snapshot can't (process-scoped, no window).
+export type ReadinessBucket = "ready" | "building" | "degraded" | "blocked"
+
+export type CohortSummary = {
+  readonly window: { readonly sinceMs: number; readonly untilMs: number }
+  readonly selections: number
+  readonly sessions: number
+  readonly tokens: number
+  readonly readiness: Readonly<Record<ReadinessBucket, number>>
+  readonly graphs: Readonly<
+    Record<GraphKind, { readonly statuses: number; readonly ready: number; readonly notReady: number }>
+  >
+}
+
 export class DiagnosticsError extends Schema.TaggedErrorClass<DiagnosticsError>()(
   "ContextFederationDiagnostics.DiagnosticsError",
   { reason: Schema.String },
@@ -63,6 +80,23 @@ export interface Interface {
     readonly actorId: string
     readonly now?: number
   }) => Effect.Effect<ReturnType<typeof attemptView>, DiagnosticsError>
+  /**
+   * FEAT-005: cohort-level durable aggregation. Aggregates federated context selections across all
+   * sessions within [sinceMs, untilMs] from the durable selection table (NOT the in-memory
+   * observability snapshot), bucketed by readiness so rollout decisions aren't skewed by cold-start
+   * indexing noise.
+   */
+  readonly cohort: (input: { readonly sinceMs: number; readonly untilMs?: number }) => Effect.Effect<CohortSummary, DiagnosticsError>
+  /**
+   * BUG-407-012 gap C: recent durable provider-turn stage evidence for a session (optionally
+   * narrowed to one activity), newest first. Exposes where a turn got stuck between the legacy
+   * activity claim and the provider receipt so incidents can be attributed post-hoc.
+   */
+  readonly turnStageEvidence: (input: {
+    readonly sessionId: SessionSchema.ID
+    readonly activityId?: string
+    readonly limit?: number
+  }) => Effect.Effect<readonly TurnStageEvidence.Row[], DiagnosticsError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@deepagent-code/ContextFederationDiagnostics") {}
@@ -75,15 +109,33 @@ export const layer = Layer.effect(
     const attempts = yield* SessionProviderAttempt.Service
     const federation = yield* SessionFederatedContext.Service
     const owners = yield* SessionProviderOwner.Service
-    const recoveryOwnerToken = `${process.pid}:diagnostics:${randomUUID()}`
-    yield* owners.register({ ownerToken: recoveryOwnerToken, leaseMs: SessionProviderOwner.LeaseMs }).pipe(Effect.orDie)
+    // BUG-407-012 root cause A: same rotation contract as the prompt owner — a fenced lease
+    // rotates to a successor generation; consumers read the current token at use time.
+    const recoveryOwnerBase = `${process.pid}:diagnostics:${randomUUID()}`
+    const recoveryOwnerInitialToken = ContextFederationProviderOwnerRuntime.nextOwnerToken({
+      ownerBase: recoveryOwnerBase,
+      generation: 0,
+    })
+    yield* owners
+      .register({ ownerToken: recoveryOwnerInitialToken, leaseMs: SessionProviderOwner.LeaseMs })
+      .pipe(Effect.orDie)
+    const recoveryOwnerState = yield* Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({
+      ownerToken: recoveryOwnerInitialToken,
+      generation: 0,
+    })
     const ownerHealthy = yield* Ref.make(true)
-    yield* Effect.addFinalizer(() => owners.release({ ownerToken: recoveryOwnerToken }).pipe(Effect.ignore))
+    yield* Effect.addFinalizer(() =>
+      Ref.get(recoveryOwnerState).pipe(
+        Effect.flatMap((state) => owners.release({ ownerToken: state.ownerToken })),
+        Effect.ignore,
+      ),
+    )
     yield* Effect.gen(function* () {
       while (yield* Ref.get(ownerHealthy)) {
         const continued = yield* ContextFederationProviderOwnerRuntime.tick({
           owners,
-          ownerToken: recoveryOwnerToken,
+          owner: recoveryOwnerState,
+          ownerBase: recoveryOwnerBase,
           leaseMs: SessionProviderOwner.LeaseMs,
           healthy: ownerHealthy,
           label: "provider diagnostics",
@@ -209,13 +261,14 @@ export const layer = Layer.effect(
             reason: "legacy_provider_recovery_required",
           })
         if (input.decision === "replayed") {
+          const recoveryOwnerCurrent = yield* Ref.get(recoveryOwnerState)
           const resolved = yield* federation.replayIndeterminate({
             session: input.session,
             attemptId: input.attemptId,
             actorId: input.actorId,
             reason: input.reason,
             riskAcknowledged: input.riskAcknowledged,
-            recoveryOwnerToken,
+            recoveryOwnerToken: recoveryOwnerCurrent.ownerToken,
             now: input.now,
           })
           return attemptView(resolved.replay, undefined, false, input.now ?? Date.now())
@@ -229,9 +282,10 @@ export const layer = Layer.effect(
         if (input.decision === "settled" && !terminal) {
           return yield* new DiagnosticsError({ reason: "persisted_terminal_event_required" })
         }
+        const recoveryOwnerCurrent = yield* Ref.get(recoveryOwnerState)
         const resolved = yield* attempts.resolve({
           attemptId: input.attemptId,
-          recoveryOwnerToken,
+          recoveryOwnerToken: recoveryOwnerCurrent.ownerToken,
           actor: {
             type: "user",
             id: input.actorId,
@@ -256,7 +310,58 @@ export const layer = Layer.effect(
         return attemptView(resolved.attempt, undefined, false, input.now ?? Date.now())
       }).pipe(Effect.mapError(diagnosticsError))
 
-    return Service.of({ get, resolveAttempt })
+    const cohort: Interface["cohort"] = (input) =>
+      Effect.gen(function* () {
+        const untilMs = input.untilMs ?? Date.now()
+        const rows = yield* database.db
+          .select({
+            sessionId: SessionContextSelectionTable.session_id,
+            graphStatuses: SessionContextSelectionTable.graph_statuses,
+            tokenCount: SessionContextSelectionTable.token_count,
+          })
+          .from(SessionContextSelectionTable)
+          .where(and(gte(SessionContextSelectionTable.created_at, input.sinceMs), lte(SessionContextSelectionTable.created_at, untilMs)))
+          .all()
+          .pipe(Effect.orDie)
+        const readiness: Record<ReadinessBucket, number> = { ready: 0, building: 0, degraded: 0, blocked: 0 }
+        const graphs = Object.fromEntries(
+          GraphKind.literals.map((graph) => [graph, { statuses: 0, ready: 0, notReady: 0 }]),
+        ) as Record<GraphKind, { statuses: number; ready: number; notReady: number }>
+        const sessions = new Set<string>()
+        let tokens = 0
+        for (const row of rows) {
+          sessions.add(row.sessionId)
+          tokens += row.tokenCount
+          const statuses = parse(Schema.Array(GraphQueryStatus), row.graphStatuses, "graph_statuses")
+          // Selection-level bucket = the WORST graph state (blocked > degraded > building > ready),
+          // so a single cold/blocked graph keeps the whole selection out of the "ready" cohort.
+          let worst: ReadinessBucket = "ready"
+          for (const status of statuses) {
+            const bucket = readinessBucket(status)
+            graphs[status.graph].statuses += 1
+            if (bucket === "ready") graphs[status.graph].ready += 1
+            else graphs[status.graph].notReady += 1
+            if (bucketRank(bucket) > bucketRank(worst)) worst = bucket
+          }
+          readiness[worst] += 1
+        }
+        return {
+          window: { sinceMs: input.sinceMs, untilMs },
+          selections: rows.length,
+          sessions: sessions.size,
+          tokens,
+          readiness,
+          graphs,
+        } satisfies CohortSummary
+      }).pipe(Effect.mapError(diagnosticsError))
+
+    const turnStageEvidence: Interface["turnStageEvidence"] = (input) =>
+      TurnStageEvidence.recent(database.db, {
+        sessionID: input.sessionId,
+        ...(input.activityId ? { activityID: input.activityId } : {}),
+        ...(input.limit ? { limit: input.limit } : {}),
+      }).pipe(Effect.mapError(diagnosticsError))
+    return Service.of({ get, resolveAttempt, cohort, turnStageEvidence })
   }),
 )
 
@@ -442,6 +547,30 @@ function parse<A>(schema: Schema.Decoder<A>, value: string, field: string) {
   }
 }
 
+// FEAT-005: fold a per-graph query status into a rollout-readiness bucket. complete→ready; a
+// partial with a degraded source is genuine degradation, cold/indexing/stale are cold-start
+// "building" (expected to self-resolve); a blocked graph is an authorization/source block (denied)
+// or an unavailable source (degraded); not_queried (source disabled) counts as not-ready building.
+function readinessBucket(status: GraphQueryStatus): ReadinessBucket {
+  if (status.kind === "complete") return "ready"
+  if (status.kind === "blocked") return status.state === "denied" ? "blocked" : "degraded"
+  if (status.kind === "not_queried") return "building"
+  return status.state === "degraded" ? "degraded" : "building" // partial: cold | indexing | stale
+}
+
+function bucketRank(bucket: ReadinessBucket): number {
+  switch (bucket) {
+    case "ready":
+      return 0
+    case "building":
+      return 1
+    case "degraded":
+      return 2
+    case "blocked":
+      return 3
+  }
+}
+
 function parseInlineAudit(value: string) {
   try {
     const parsed: unknown = JSON.parse(value)
diff --git a/packages/deepagent-code/src/context-federation/provider-owner-runtime.ts b/packages/deepagent-code/src/context-federation/provider-owner-runtime.ts
index b91c7bb6..86dfc0e2 100644
--- a/packages/deepagent-code/src/context-federation/provider-owner-runtime.ts
+++ b/packages/deepagent-code/src/context-federation/provider-owner-runtime.ts
@@ -1,27 +1,47 @@
 export * as ContextFederationProviderOwnerRuntime from "./provider-owner-runtime"
 
+import { randomUUID } from "node:crypto"
 import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
 import { Cause, Effect, Exit, Option, Ref } from "effect"
 
-export function tick<R = never>(input: {
-  readonly owners: Pick<SessionProviderOwner.Interface, "heartbeat">
+/**
+ * Mutable process-level owner identity: the current lease token plus its generation counter.
+ * Consumers must read this at use time — a startup-captured token constant can be fenced away
+ * by lease expiry (e.g. macOS sleep) while the process keeps running.
+ */
+export type OwnerGeneration = {
   readonly ownerToken: string
+  readonly generation: number
+}
+
+export function nextOwnerToken(input: { readonly ownerBase: string; readonly generation: number }) {
+  return `${input.ownerBase}:gen-${input.generation}:${randomUUID()}`
+}
+
+type TickInput<R> = {
+  readonly owners: Pick<SessionProviderOwner.Interface, "heartbeat" | "register">
+  readonly owner: Ref.Ref<OwnerGeneration>
+  readonly ownerBase: string
   readonly leaseMs: number
   readonly healthy: Ref.Ref<boolean>
   readonly label: string
   readonly recover?: Effect.Effect<unknown, unknown, R>
-}) {
+}
+
+export function tick<R = never>(input: TickInput<R>) {
   return Effect.gen(function* () {
+    const current = yield* Ref.get(input.owner)
     const heartbeat = yield* input.owners
-      .heartbeat({ ownerToken: input.ownerToken, leaseMs: input.leaseMs })
+      .heartbeat({ ownerToken: current.ownerToken, leaseMs: input.leaseMs })
       .pipe(Effect.exit)
     if (Exit.isFailure(heartbeat)) {
       const error = Option.getOrUndefined(Cause.findErrorOption(heartbeat.cause))
-      if (error instanceof SessionProviderOwner.ConflictError && error.reason === "provider_owner_lease_not_live") {
-        yield* Ref.set(input.healthy, false)
-        yield* Effect.logError(`${input.label} owner lease expired; stopping provider mutations`)
-        return false
-      }
+      // BUG-407-012 root cause A: an expired lease is correct fencing of the OLD token, not a
+      // terminal fault. The fenced token is never revived or released; rotate to a successor
+      // generation and keep the loop running so dispatch reopens before the next prompt.
+      // `healthy` stays true throughout — only unrecoverable errors may latch it false.
+      if (error instanceof SessionProviderOwner.ConflictError && error.reason === "provider_owner_lease_not_live")
+        return yield* rotate(input)
       yield* Effect.logError(`${input.label} owner heartbeat failed; retrying: ${Cause.pretty(heartbeat.cause)}`)
       return true
     }
@@ -32,3 +52,24 @@ export function tick<R = never>(input: {
     return true
   })
 }
+
+function rotate<R>(input: TickInput<R>) {
+  return Effect.gen(function* () {
+    // Re-read under the Ref so concurrent rotators never double-increment the generation.
+    const current = yield* Ref.get(input.owner)
+    const generation = current.generation + 1
+    const ownerToken = nextOwnerToken({ ownerBase: input.ownerBase, generation })
+    const registered = yield* input.owners
+      .register({ ownerToken, leaseMs: input.leaseMs, successor: true })
+      .pipe(Effect.exit)
+    if (Exit.isFailure(registered)) {
+      yield* Effect.logError(
+        `${input.label} owner generation rotation failed; retrying next tick: ${Cause.pretty(registered.cause)}`,
+      )
+      return true
+    }
+    yield* Ref.set(input.owner, { ownerToken, generation })
+    yield* Effect.logInfo(`${input.label} owner generation rotated: generation=${generation}`)
+    return true
+  })
+}
diff --git a/packages/deepagent-code/src/context-federation/session-context-runtime.ts b/packages/deepagent-code/src/context-federation/session-context-runtime.ts
index cbe5d1da..ba6a5d03 100644
--- a/packages/deepagent-code/src/context-federation/session-context-runtime.ts
+++ b/packages/deepagent-code/src/context-federation/session-context-runtime.ts
@@ -80,6 +80,8 @@ export interface Interface {
     selection: SessionContext.Selection,
     state: "settled" | "failed" | "interrupted",
   ) => Effect.Effect<void, RuntimeError>
+  /** Restart recovery (BUG-003): settle every federation activity still marked `active`. */
+  readonly settleOrphanedActivities: () => Effect.Effect<number, RuntimeError>
   readonly replayIndeterminate: (input: {
     readonly session: Session.Info
     readonly attemptId: string
@@ -174,8 +176,12 @@ export const layer = Layer.effect(
           Effect.mapError(runtimeError),
         )
 
-    const resolve: Interface["resolve"] = (input) =>
-      Effect.gen(function* () {
+    const resolve: Interface["resolve"] = (input) => {
+      // BUG-003: when this call opens a fresh activity, any later failure before commit would
+      // otherwise leave a permanent `active` row (the partial unique index then blocks every new
+      // activity for the session). Track the opened id and roll it back to `interrupted` on error.
+      let openedActivityId: string | undefined
+      return Effect.gen(function* () {
         const handle = yield* runtime.current()
         if (!handle) return yield* new RuntimeError({ reason: "location_unavailable" })
         const now = input.now ?? Date.now()
@@ -286,11 +292,13 @@ export const layer = Layer.effect(
         if (inputIds.length === 0) return yield* new RuntimeError({ reason: "activity_input_missing" })
         const activity = current
           ? { activityId: current.activityId, triggerInputId: current.triggerInputId }
-          : yield* contexts.openActivity({
-              sessionId: SessionSchema.ID.make(input.session.id),
-              triggerInputId: inputIds[0]!,
-              now,
-            })
+          : yield* contexts
+              .openActivity({
+                sessionId: SessionSchema.ID.make(input.session.id),
+                triggerInputId: inputIds[0]!,
+                now,
+              })
+              .pipe(Effect.tap((opened) => Effect.sync(() => (openedActivityId = opened.activityId))))
         yield* contexts.attachInputs({ activityId: activity.activityId, inputIds, now })
         const resolved = yield* query.query({
           intent: "search",
@@ -334,7 +342,15 @@ export const layer = Layer.effect(
           envelope,
           observedLocationMutationEpoch: mutationEpoch,
         }
-      }).pipe(Effect.mapError((error) => (error instanceof RuntimeError ? error : runtimeError(error))))
+      }).pipe(
+        Effect.tapError(() =>
+          openedActivityId === undefined
+            ? Effect.void
+            : contexts.settleActivity({ activityId: openedActivityId, state: "interrupted" }).pipe(Effect.ignore),
+        ),
+        Effect.mapError((error) => (error instanceof RuntimeError ? error : runtimeError(error))),
+      )
+    }
 
     const commit = (input: {
       readonly sessionId: string
@@ -509,6 +525,28 @@ export const layer = Layer.effect(
         Effect.mapError((error) => runtimeError(error)),
       )
 
+    const settleOrphanedActivities: Interface["settleOrphanedActivities"] = () =>
+      Effect.gen(function* () {
+        // Restart recovery (BUG-003), mirroring the global semantics of the legacy
+        // SessionPromptIntent.recoverActiveActivities: an activity still `active` at startup
+        // belongs to a dead run loop (the previous process died or was killed mid-turn) and would
+        // otherwise lock the session's partial unique index forever. Best-effort per row; real DB
+        // failures surface through the error channel.
+        const active = yield* database.db
+          .select({ activityId: SessionActivityTable.activity_id, sessionId: SessionActivityTable.session_id })
+          .from(SessionActivityTable)
+          .where(eq(SessionActivityTable.state, "active"))
+          .all()
+          .pipe(Effect.mapError(runtimeError))
+        yield* Effect.forEach(active, (row) =>
+          Effect.gen(function* () {
+            yield* contexts.settleActivity({ activityId: row.activityId, state: "interrupted" }).pipe(Effect.ignore)
+            yield* authorization.remove(row.sessionId).pipe(Effect.ignore)
+          }),
+        )
+        return active.length
+      })
+
     const replayIndeterminate: Interface["replayIndeterminate"] = (input) =>
       Effect.gen(function* () {
         const attempt = yield* attempts.get(input.attemptId)
@@ -687,6 +725,7 @@ export const layer = Layer.effect(
       resolve,
       prepareProviderTurn,
       settleActivity,
+      settleOrphanedActivities,
       replayIndeterminate,
       releasedKnowledgeForActiveSession,
     })
diff --git a/packages/deepagent-code/src/deepagent/profile-detector.ts b/packages/deepagent-code/src/deepagent/profile-detector.ts
index b45e707d..66e1fb53 100644
--- a/packages/deepagent-code/src/deepagent/profile-detector.ts
+++ b/packages/deepagent-code/src/deepagent/profile-detector.ts
@@ -1,168 +1,8 @@
-import { existsSync, readFileSync } from "node:fs"
-import path from "node:path"
-import type { AgentGateway } from "@deepagent-code/core/agent-gateway"
-
-type ExtendedProblemProfile = Parameters<typeof AgentGateway.DeepAgentDomainPackRegistry.score>[0]
-
-// docs/34 §4.1/§5 — ProfileDetector: build a multi-dimensional ExtendedProblemProfile from real
-// workspace signals so domain pack activation is driven by facts, not guesses. Production callers
-// pass the workspace-context output (languages/frameworks already detected) plus the current round
-// signals and any user overrides. Does NOT do its own fs scanning — delegates to what workspace-
-// context already computed and is handed in as input.
-
-export type WorkspaceSignals = {
-  readonly cwd: string
-  readonly agentMode: "general" | "high" | "xhigh" | "max" | "ultra"
-  readonly scenarioMode: "direct" | "intelligence"
-  readonly userRequest: string
-  readonly languages?: readonly string[]
-  readonly frameworks?: readonly string[]
-  readonly packageScripts?: Readonly<Record<string, string>>
-  // Optional round signals from prior diagnosis / validation
-  readonly roundSignals?: readonly string[]
-  // User-pinned packs (from settings / HTTP API override)
-  readonly userOverrides?: readonly string[]
-}
-
-const CODE_RISK_KEYWORDS = /security|auth|payment|billing|crypto|encrypt|secret|vuln|cve|pentest/i
-const FINANCE_KEYWORDS = /finance|payment|billing|ledger|accounting|invoice|transaction|audit/i
-const HEALTHCARE_KEYWORDS = /health|medical|patient|ehr|phi|hipaa|dicom|clinical/i
-const PRIVACY_KEYWORDS = /gdpr|pii|personal.?data|privacy|consent|anonymi/i
-const PHI_KEYWORDS = /phi|protected.health|patient.record/i
-const READ_ONLY_QUERY_KEYWORDS =
-  /\b(query|count|list|show|read|inspect|status|diff|log|config|select|explain|grep|rg|find)\b|查一下|查询|统计|列出|显示|读取|看一下|多少个|有哪些|当前状态|日志里|配置里|数据库里/i
-const MUTATION_KEYWORDS =
-  /\b(fix|implement|edit|modify|write|delete|deploy|migrate|migration|backfill|transaction|constraint|insert|update|alter|drop|restart|apply|remove)\b|修复|实现|修改|写入|删除|部署|迁移|更新|重启/i
-
-// Detect languages from the workspace (package.json / pyproject / go.mod / Cargo.toml etc.).
-const detectLanguages = (cwd: string): string[] => {
-  const langs: string[] = []
-  if (existsSync(path.join(cwd, "package.json"))) {
-    langs.push("javascript")
-    try {
-      const pkg = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf8"))
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies }
-      if (deps["typescript"] || deps["@types/node"] || existsSync(path.join(cwd, "tsconfig.json"))) {
-        langs.push("typescript")
-      }
-    } catch {
-      langs.push("typescript")
-    } // assume TS on parse failure
-  }
-  if (existsSync(path.join(cwd, "pyproject.toml")) || existsSync(path.join(cwd, "setup.py"))) langs.push("python")
-  if (existsSync(path.join(cwd, "go.mod"))) langs.push("go")
-  if (existsSync(path.join(cwd, "Cargo.toml"))) langs.push("rust")
-  if (existsSync(path.join(cwd, "CMakeLists.txt"))) langs.push("cpp")
-  return [...new Set(langs)]
-}
-
-// Detect frameworks from package.json deps.
-const detectFrameworks = (cwd: string): string[] => {
-  const fw: string[] = []
-  const pkgFile = path.join(cwd, "package.json")
-  if (!existsSync(pkgFile)) return fw
-  try {
-    const pkg = JSON.parse(readFileSync(pkgFile, "utf8"))
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies }
-    if (deps["react"] || deps["react-dom"]) fw.push("react")
-    if (deps["solid-js"]) fw.push("solidjs")
-    if (deps["vue"]) fw.push("vue")
-    if (deps["svelte"]) fw.push("svelte")
-    if (deps["next"]) fw.push("next.js")
-    if (deps["express"] || deps["fastify"] || deps["hono"] || deps["@hono/core"]) fw.push("backend-framework")
-    if (deps["drizzle-orm"] || deps["prisma"] || deps["typeorm"]) fw.push("orm")
-    if (deps["bun"]) fw.push("bun")
-    if (deps["effect"]) fw.push("effect")
-  } catch {
-    /* skip */
-  }
-  return [...new Set(fw)]
-}
-
-// Derive code_domains from languages, frameworks, and user request.
-const deriveCodeDomains = (langs: string[], frameworks: string[], request: string): string[] => {
-  const d: string[] = ["code"]
-  if (frameworks.some((f) => ["react", "solidjs", "vue", "svelte"].includes(f))) d.push("frontend")
-  if (frameworks.some((f) => f === "backend-framework")) d.push("backend")
-  if (langs.includes("cuda") || langs.includes("cpp") || /\b(kernel|gemm|cuda|gpu|sgemm|rocm)\b/i.test(request)) {
-    d.push("gpu_kernel")
-    if (!langs.includes("cpp")) langs.push("cpp")
-  }
-  if (langs.includes("python")) d.push("data")
-  if (READ_ONLY_QUERY_KEYWORDS.test(request) && !MUTATION_KEYWORDS.test(request)) {
-    d.push("query", "deterministic", "read_only")
-  }
-  return [...new Set(d)]
-}
-
-// Extract risk markers from the user request + repo signals.
-const extractRiskMarkers = (request: string, repoSignals: string[]): string[] => {
-  const m: string[] = []
-  const hay = `${request} ${repoSignals.join(" ")}`.toLowerCase()
-  if (CODE_RISK_KEYWORDS.test(hay)) m.push("security")
-  if (FINANCE_KEYWORDS.test(hay)) m.push("finance")
-  if (HEALTHCARE_KEYWORDS.test(hay)) m.push("healthcare")
-  if (PRIVACY_KEYWORDS.test(hay)) m.push("pii", "privacy")
-  if (PHI_KEYWORDS.test(hay)) m.push("phi")
-  return [...new Set(m)]
-}
-
-// Extract business_domains from request + risk markers.
-const deriveBusinessDomains = (request: string, riskMarkers: string[]): string[] => {
-  const d: string[] = []
-  if (FINANCE_KEYWORDS.test(request) || riskMarkers.includes("finance")) d.push("finance")
-  if (HEALTHCARE_KEYWORDS.test(request) || riskMarkers.includes("healthcare")) d.push("healthcare")
-  return d
-}
-
-// Infer a rough task_kind from the user request (heuristic; good enough for pack scoring).
-const inferTaskKind = (request: string): ExtendedProblemProfile["task_kind"] => {
-  const r = request.toLowerCase()
-  if (/\b(fix|bug|error|fail|broken|crash|traceback)\b/.test(r)) return "debug"
-  if (/\b(review|audit|check|inspect|scan)\b/.test(r)) return "review"
-  if (/\b(test|spec|coverage|unit|e2e|integration)\b/.test(r)) return "test"
-  if (/\b(migrat|upgrade|refactor|rename|move|convert)\b/.test(r)) return "migrate"
-  if (/\b(optim|improv|speed|perf|latency|memory|throughput)\b/.test(r)) return "optimize"
-  if (/\b(explain|document|describe|what|how|why)\b/.test(r)) return "explain"
-  if (/\b(deploy|release|ship|produc|operation)\b/.test(r)) return "operate"
-  return "implement"
-}
-
-// Collect signals from the repo (directory names, config files, README snippet).
-const collectRepoSignals = (cwd: string, userRequest: string): string[] => {
-  const signals: string[] = [userRequest.slice(0, 200)]
-  try {
-    const readmePath = ["README.md", "README.txt", "readme.md"].map((f) => path.join(cwd, f)).find(existsSync)
-    if (readmePath) signals.push(readFileSync(readmePath, "utf8").slice(0, 500))
-  } catch {
-    /* skip */
-  }
-  return signals
-}
-
-// Build a full ExtendedProblemProfile from workspace signals. This is the production entry point
-// called by the gateway/orchestrator before pack activation (docs/34 §5/§9 S5).
-export const buildProfile = (signals: WorkspaceSignals): ExtendedProblemProfile => {
-  const langs = signals.languages?.length ? [...signals.languages] : detectLanguages(signals.cwd)
-  const frameworks = signals.frameworks?.length ? [...signals.frameworks] : detectFrameworks(signals.cwd)
-  const repoSignals = collectRepoSignals(signals.cwd, signals.userRequest)
-  const codeDomains = deriveCodeDomains(langs, frameworks, signals.userRequest)
-  const riskMarkers = extractRiskMarkers(signals.userRequest, repoSignals)
-  const businessDomains = deriveBusinessDomains(signals.userRequest, riskMarkers)
-
-  return {
-    scenario_mode: signals.scenarioMode,
-    agent_strength: signals.agentMode,
-    task_kind: inferTaskKind(signals.userRequest),
-    code_domains: codeDomains,
-    business_domains: businessDomains,
-    platforms: [],
-    languages: langs,
-    frameworks,
-    data_classes: riskMarkers.filter((r) => ["pii", "phi"].includes(r)),
-    risk_markers: riskMarkers,
-    repo_signals: repoSignals.slice(0, 3),
-    round_signals: signals.roundSignals ?? [],
-    user_overrides: signals.userOverrides ?? [],
-  }
-}
+// FEAT-002: profile construction was lowered into core (packages/core/src/deepagent/profile-
+// builder.ts) so the agent gateway (core) can build the SAME ExtendedProblemProfile it hands to
+// knowledge retrieval and pack-snapshot recording — one activation authority per run. core cannot
+// import deepagent-code, so this module is now a thin re-export: existing deepagent-code callers
+// (HTTP handlers, tests) keep their import path and behavior unchanged.
+
+export { buildProfile } from "@deepagent-code/core/deepagent/profile-builder"
+export type { WorkspaceSignals } from "@deepagent-code/core/deepagent/profile-builder"
diff --git a/packages/deepagent-code/src/effect/app-runtime.ts b/packages/deepagent-code/src/effect/app-runtime.ts
index 75eb49bf..3c3f24b9 100644
--- a/packages/deepagent-code/src/effect/app-runtime.ts
+++ b/packages/deepagent-code/src/effect/app-runtime.ts
@@ -56,6 +56,7 @@ import { BackgroundJob } from "@/background/job"
 import { RuntimeFlags } from "@/effect/runtime-flags"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { DurableLearningRuntime } from "@/deepagent/learning-runtime"
+import { LegacyEventCanonicalizerRuntime } from "@/legacy-event-canonicalizer-runtime"
 
 export const AppLayer = Layer.mergeAll(
   Npm.defaultLayer,
@@ -86,6 +87,8 @@ export const AppLayer = Layer.mergeAll(
   EventV2Bridge.defaultLayer,
   SessionProjection.defaultLayer,
   DurableLearningRuntime.defaultLayer,
+  // RISK-003 ④: durable schedule for the legacy event canonicalizer (flag-gated, default OFF).
+  LegacyEventCanonicalizerRuntime.defaultLayer,
   SessionRunState.defaultLayer,
   SessionProcessor.defaultLayer,
   SessionCompaction.defaultLayer,
diff --git a/packages/deepagent-code/src/effect/runtime-flags.ts b/packages/deepagent-code/src/effect/runtime-flags.ts
index f0df8f27..8cbf9e50 100644
--- a/packages/deepagent-code/src/effect/runtime-flags.ts
+++ b/packages/deepagent-code/src/effect/runtime-flags.ts
@@ -311,19 +311,41 @@ export class Service extends ConfigService.Service<Service>()("@deepagent-code/R
   // ONLY the runLoop steer drain — it does NOT activate the dormant experimentalEventSystem V2 runner.
   // Disable with DEEPAGENT_CODE_V4_STEERING=false.
   v4Steering: stableOn("DEEPAGENT_CODE_V4_STEERING"),
+  // BUG-004: maximum consecutive steer-absorption rounds within ONE activity run. When reached, the
+  // run loop stops absorbing and ends the activity; any still-pending steers are consumed by the
+  // NEXT drain cycle as a fresh activity instead of silently extending the old work without bound.
+  steerAbsorbLimit: positiveIntegerWithDefault("DEEPAGENT_CODE_STEER_ABSORB_LIMIT", 5),
+  // BUG-407-012 gap C: pre-dispatch deadline watchdog. DEFAULT OFF. When enabled, a maintenance
+  // sweep fails any legacy activity that stayed active past the deadline WITHOUT durable receipt /
+  // dispatch evidence, through the existing terminalization path with a typed terminal reason (so an
+  // exact retry remains possible). Activities that already have a receipt are never touched — the
+  // existing outcome-unknown recovery stays authoritative for those.
+  providerPreDispatchWatchdog: bool("DEEPAGENT_CODE_PROVIDER_PRE_DISPATCH_WATCHDOG"),
+  providerPreDispatchDeadlineMs: positiveIntegerWithDefault(
+    "DEEPAGENT_CODE_PROVIDER_PRE_DISPATCH_DEADLINE_MS",
+    10 * 60_000,
+  ),
   // BUG-407-007 staged authority cutover. `legacy` preserves the existing in-process permission and
   // no-progress owner. `durable` routes production legacy activities through the SQLite-backed
-  // objective/progress/permission authority. This deliberately ships legacy-owned until the live and
-  // packaged recovery gates are complete.
-  activityAuthority: Config.string("DEEPAGENT_CODE_ACTIVITY_AUTHORITY").pipe(
-    Config.withDefault("legacy"),
-    Config.map((value): "legacy" | "durable" => {
-      if (value === "legacy" || value === "durable") return value
-      throw new Error(
-        `Invalid DEEPAGENT_CODE_ACTIVITY_AUTHORITY="${value}". Must be one of: legacy, durable. Refusing to select an unknown activity authority.`,
-      )
-    }),
-  ),
+  // objective/progress/permission authority.
+  // FEAT-011 T3/T4/T6: the unified activity FACADE tools (activity_start/status/result/control).
+  // Staged OFF: the facade never duplicates lifecycle state — it delegates to the existing Task
+  // durable queue / GoalManager / PanelConsult runners and records session_facade_activity rows
+  // (fail-closed partial unique index per (parent_session, subkind) active). Default false until
+  // the release gate qualifies the delegation paths; enable with DEEPAGENT_CODE_ACTIVITY_FACADE=true.
+  activityFacade: bool("DEEPAGENT_CODE_ACTIVITY_FACADE"),
+  // RISK-003 ④ (BUG-407-010 legacy data governance): durable automated schedule for the legacy
+  // event canonicalizer. The canonicalizer itself is already wired (core event.ts
+  // canonicalizeLegacyArtifacts + the sync maintenance endpoint); this flag starts a bounded
+  // background loop that walks the backlog in small batches. DEFAULT OFF (conservative rollout —
+  // the governance runbook advances per-step on production copies). Failures only log; the loop
+  // never deletes events or VACUUMs. Enable with DEEPAGENT_CODE_LEGACY_EVENT_CANONICALIZER=true.
+  legacyEventCanonicalizer: bool("DEEPAGENT_CODE_LEGACY_EVENT_CANONICALIZER"),
+  // RISK-003 ① staged rollout: converge inline summary diffs onto the session_diff_artifact
+  // authority at write time (rewrites the message row to a compact descriptor). Staged OFF until
+  // the diff read path serves artifact descriptors and the §14 evidence chain (floor parity) is
+  // in place; until then the bug-407-010 hotfix contract holds (bound at read, storage untouched).
+  sessionDiffArtifactCapture: bool("DEEPAGENT_CODE_SESSION_DIFF_ARTIFACT_CAPTURE"),
   // PR-2: Streaming degeneration detector mode for reasoning outputs.
   // "off"    — detector is disabled; all output passes through unmodified.
   // "shadow" — detector runs and logs hits, but never triggers a circuit break.
diff --git a/packages/deepagent-code/src/index.ts b/packages/deepagent-code/src/index.ts
index 32cd7be5..022d41fe 100644
--- a/packages/deepagent-code/src/index.ts
+++ b/packages/deepagent-code/src/index.ts
@@ -31,6 +31,13 @@ import { WebCommand } from "./cli/cmd/web"
 import { PrCommand } from "./cli/cmd/pr"
 import { SessionCommand } from "./cli/cmd/session"
 import { DbCommand } from "./cli/cmd/db"
+import { GoalCommand } from "./cli/cmd/goal"
+import { WorktreeCommand } from "./cli/cmd/worktree"
+import { OversightCommand } from "./cli/cmd/oversight"
+import { PanelCommand } from "./cli/cmd/panel"
+import { ReviewCommand } from "./cli/cmd/review"
+import { WikiCommand } from "./cli/cmd/wiki"
+import { PacksCommand } from "./cli/cmd/packs"
 import { errorMessage } from "./util/error"
 import { PluginCommand } from "./cli/cmd/plug"
 import { Heap } from "./cli/heap"
@@ -145,6 +152,13 @@ const cli = yargs(args)
   .command(SessionCommand)
   .command(PluginCommand)
   .command(DbCommand)
+  .command(GoalCommand)
+  .command(WorktreeCommand)
+  .command(OversightCommand)
+  .command(PanelCommand)
+  .command(ReviewCommand)
+  .command(WikiCommand)
+  .command(PacksCommand)
   .fail((msg, err) => {
     if (
       msg?.startsWith("Unknown argument") ||
diff --git a/packages/deepagent-code/src/legacy-event-canonicalizer-runtime.ts b/packages/deepagent-code/src/legacy-event-canonicalizer-runtime.ts
new file mode 100644
index 00000000..158d30da
--- /dev/null
+++ b/packages/deepagent-code/src/legacy-event-canonicalizer-runtime.ts
@@ -0,0 +1,71 @@
+export * as LegacyEventCanonicalizerRuntime from "./legacy-event-canonicalizer-runtime"
+
+import { EventV2 } from "@deepagent-code/core/event"
+import { Cause, Duration, Effect, Layer, Schedule } from "effect"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+
+// RISK-003 ④ (BUG-407-010 legacy data governance): durable automated schedule for the legacy
+// event canonicalizer. The canonicalizer itself is already implemented and wired
+// (core event.ts `canonicalizeLegacyArtifacts` + the sync `artifacts` maintenance endpoint);
+// what was missing is an automated schedule, so backlog convergence depended on a client manually
+// driving the maintenance endpoint. This daemon closes that gap with a conservative loop:
+//   - flag-gated (RuntimeFlags.legacyEventCanonicalizer), DEFAULT OFF
+//   - bounded batches (a few events per tick) on a spaced interval
+//   - failures only log a warning; the loop never blocks a turn
+//   - evidence-only: it canonicalizes oversized legacy payloads into event_artifact rows and
+//     NEVER deletes events or VACUUMs (those remain gated human-runbook steps, bug-407-010 §14).
+const defaultPollInterval = Duration.minutes(5)
+const defaultMaxEventsPerTick = 16
+
+export const makeLayer = (options?: {
+  readonly pollInterval?: Duration.Duration
+  readonly maxEventsPerTick?: number
+}) =>
+  Layer.effectDiscard(
+    Effect.gen(function* () {
+      const flags = yield* RuntimeFlags.Service
+      if (!flags.legacyEventCanonicalizer) return
+      const events = yield* EventV2.Service
+      const pollInterval = options?.pollInterval ?? defaultPollInterval
+      const maxEventsPerTick = Math.max(1, options?.maxEventsPerTick ?? defaultMaxEventsPerTick)
+      // The stateless scan resumes from the first not-yet-canonicalized event, but rows that are
+      // skipped as invalid never acquire an artifact row, so the loop keeps an in-memory cursor
+      // that walks past them; the cursor resets when the scan exhausts, re-scanning (and cheaply
+      // re-skipping) those rows on the next cycle. Durable progress lives in the event_artifact
+      // rows themselves, so a restart resumes from the database without any extra bookkeeping.
+      let afterID: EventV2.ID | undefined
+      const tick = Effect.suspend(() =>
+        Effect.gen(function* () {
+          let processed = 0
+          for (let step = 0; step < maxEventsPerTick; step++) {
+            const result = yield* events.canonicalizeLegacyArtifacts({
+              ...(afterID ? { afterID } : {}),
+              limit: EventV2.LEGACY_ARTIFACT_BATCH_EVENTS,
+            })
+            processed += result.processed
+            if (!result.next) {
+              afterID = undefined
+              break
+            }
+            afterID = result.next
+          }
+          return processed
+        }),
+      ).pipe(
+        Effect.catchCause((cause) =>
+          Effect.logWarning("legacy event canonicalizer tick failed", { cause: Cause.pretty(cause) }).pipe(
+            Effect.as(0),
+          ),
+        ),
+      )
+      yield* tick
+      yield* tick.pipe(Effect.repeat(Schedule.spaced(pollInterval)), Effect.forkScoped)
+    }),
+  )
+
+export const layer = makeLayer()
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(EventV2.defaultLayer),
+  Layer.provide(RuntimeFlags.defaultLayer),
+)
diff --git a/packages/deepagent-code/src/location-index/runtime.ts b/packages/deepagent-code/src/location-index/runtime.ts
index 3bdfb075..7cf1dfca 100644
--- a/packages/deepagent-code/src/location-index/runtime.ts
+++ b/packages/deepagent-code/src/location-index/runtime.ts
@@ -10,6 +10,7 @@ import { FSUtil } from "@deepagent-code/core/fs-util"
 import { Global } from "@deepagent-code/core/global"
 import { LocationChangeJournal } from "@deepagent-code/core/location-index/change-journal"
 import { LocationCommitLock } from "@deepagent-code/core/location-index/commit-lock"
+import { projectIdForWorkspace } from "@deepagent-code/core/deepagent/durable-knowledge-store"
 import { AbsolutePath } from "@deepagent-code/core/schema"
 import { Context, Effect, Layer } from "effect"
 import { randomUUID } from "node:crypto"
@@ -40,12 +41,16 @@ export const layer = Layer.effect(
     const state = yield* InstanceState.make(
       Effect.fn("LocationIndexRuntime.instance")(function* (instance) {
         if (!flags.locationIndexesV2Shadow) return undefined
+        // Non-git instances resolve to the "global" sentinel project id, which is NOT a valid
+        // observed project for durable authorities: the released-knowledge scope guard pins
+        // context_project_scope_identity.observed_project_id to the canonical durable knowledge
+        // project id. Record that canonical id here so whichever resolver arrives first writes it.
         const identity = yield* identities.resolve({
           boundary: { kind: "implicit_local" },
           directory: AbsolutePath.make(instance.directory),
           project: instance.project.vcs === "git"
             ? { kind: "git", observedProjectId: instance.project.id }
-            : { kind: "registered_root", observedProjectId: instance.project.id },
+            : { kind: "registered_root", observedProjectId: projectIdForWorkspace(instance.directory) },
         })
         const built = yield* Layer.build(
           LocationIndexCoordinator.layer({
diff --git a/packages/deepagent-code/src/permission/index.ts b/packages/deepagent-code/src/permission/index.ts
index e170a358..b57840c7 100644
--- a/packages/deepagent-code/src/permission/index.ts
+++ b/packages/deepagent-code/src/permission/index.ts
@@ -149,13 +149,9 @@ export const layerWith = (options: LayerOptions = {}) =>
         return rotated
       })
       const rotateOwner = Effect.fn("Permission.rotateOwner")(function* () {
-        if (flags.activityAuthority !== "durable")
-          return yield* Effect.die(new Error("durable permission authority is unavailable"))
         return yield* withPermissionOwner(permissionOwnerID().pipe(Effect.flatMap(rotatePermissionOwner)))
       })
       const rotateOwnerIfCurrent = Effect.fn("Permission.rotateOwnerIfCurrent")(function* (expectedOwnerID: string) {
-        if (flags.activityAuthority !== "durable")
-          return yield* Effect.die(new Error("durable permission authority is unavailable"))
         return yield* withPermissionOwner(
           permissionOwnerID().pipe(
             Effect.flatMap((ownerID) =>
@@ -164,20 +160,18 @@ export const layerWith = (options: LayerOptions = {}) =>
           ),
         )
       })
-      if (flags.activityAuthority === "durable") {
-        yield* DeepAgentActivityAuthority.heartbeatPermissionOwner({
-          ownerID: yield* permissionOwnerID(),
-          leaseMs: ownerLeaseMs,
-        }).pipe(Effect.provideService(Database.Service, database), Effect.orDie)
-        yield* Effect.addFinalizer(() =>
-          permissionOwnerID().pipe(
-            Effect.flatMap((ownerID) => DeepAgentActivityAuthority.releasePermissionOwner(ownerID)),
-            withPermissionOwner,
-            Effect.provideService(Database.Service, database),
-            Effect.orDie,
-          ),
-        )
-      }
+      yield* DeepAgentActivityAuthority.heartbeatPermissionOwner({
+        ownerID: yield* permissionOwnerID(),
+        leaseMs: ownerLeaseMs,
+      }).pipe(Effect.provideService(Database.Service, database), Effect.orDie)
+      yield* Effect.addFinalizer(() =>
+        permissionOwnerID().pipe(
+          Effect.flatMap((ownerID) => DeepAgentActivityAuthority.releasePermissionOwner(ownerID)),
+          withPermissionOwner,
+          Effect.provideService(Database.Service, database),
+          Effect.orDie,
+        ),
+      )
       const allPending = new Map<PermissionV1.ID, PendingEntry>()
       const claimPending = (id: PermissionV1.ID, entry: PendingEntry) => {
         if (allPending.get(id) !== entry || entry.settling) return false
@@ -227,40 +221,37 @@ export const layerWith = (options: LayerOptions = {}) =>
         }),
       )
 
-      if (flags.activityAuthority === "durable") {
-        const heartbeat = withPermissionOwner(
-          Effect.gen(function* () {
-            const ownerID = yield* permissionOwnerID()
-            yield* DeepAgentActivityAuthority.heartbeatPermissionOwner({
-              ownerID,
-              leaseMs: ownerLeaseMs,
-            }).pipe(
-              Effect.provideService(Database.Service, database),
-              Effect.catchTag("ActivityAuthority.ConflictError", () =>
-                rotatePermissionOwner(ownerID).pipe(Effect.asVoid),
-              ),
-            )
-            const recoveryOwnerID = yield* permissionOwnerID()
-            yield* DeepAgentActivityAuthority.recoverPendingPermissions(recoveryOwnerID).pipe(
-              Effect.provideService(Database.Service, database),
-            )
-            yield* DeepAgentActivityAuthority.recoverPermissionEffects(recoveryOwnerID).pipe(
-              Effect.provideService(Database.Service, database),
-            )
-          }),
-        )
-        yield* heartbeat.pipe(Effect.orDie)
-        yield* heartbeat.pipe(
-          Effect.catchCause((cause) => Effect.logError("permission owner heartbeat failed", { cause })),
-          Effect.repeat(Schedule.fixed(Duration.millis(ownerHeartbeatMs))),
-          Effect.forkScoped,
-        )
-      }
+      const heartbeat = withPermissionOwner(
+        Effect.gen(function* () {
+          const ownerID = yield* permissionOwnerID()
+          yield* DeepAgentActivityAuthority.heartbeatPermissionOwner({
+            ownerID,
+            leaseMs: ownerLeaseMs,
+          }).pipe(
+            Effect.provideService(Database.Service, database),
+            Effect.catchTag("ActivityAuthority.ConflictError", () =>
+              rotatePermissionOwner(ownerID).pipe(Effect.asVoid),
+            ),
+          )
+          const recoveryOwnerID = yield* permissionOwnerID()
+          yield* DeepAgentActivityAuthority.recoverPendingPermissions(recoveryOwnerID).pipe(
+            Effect.provideService(Database.Service, database),
+          )
+          yield* DeepAgentActivityAuthority.recoverPermissionEffects(recoveryOwnerID).pipe(
+            Effect.provideService(Database.Service, database),
+          )
+        }),
+      )
+      yield* heartbeat.pipe(Effect.orDie)
+      yield* heartbeat.pipe(
+        Effect.catchCause((cause) => Effect.logError("permission owner heartbeat failed", { cause })),
+        Effect.repeat(Schedule.fixed(Duration.millis(ownerHeartbeatMs))),
+        Effect.forkScoped,
+      )
 
       const durableRules = Effect.fn("Permission.durableRules")(function* (
         sessionID: PermissionV1.Request["sessionID"],
       ) {
-        if (flags.activityAuthority !== "durable") return [] as PermissionV1.Rule[]
         const owner = yield* database.db
           .select({ projectID: SessionTable.project_id })
           .from(SessionTable)
@@ -393,37 +384,35 @@ export const layerWith = (options: LayerOptions = {}) =>
         return outcome.value.decision
       })
 
-      if (flags.activityAuthority === "durable") {
-        const reconcileLocalDecisions = Effect.suspend(() =>
-          Effect.forEach(
-            Array.from(allPending.values()),
-            (entry) =>
-              Effect.gen(function* () {
-                if (entry.settling) return
-                const decision = yield* DeepAgentActivityAuthority.permissionDecisionForRequest(entry.info.id).pipe(
-                  Effect.provideService(Database.Service, database),
-                )
-                if (!decision && entry.pendingSettlement && claimPending(entry.info.id, entry)) {
-                  yield* settleClaimed(entry, entry.pendingSettlement.reply, entry.pendingSettlement.message)
-                  return
-                }
-                if (!decision || !claimPending(entry.info.id, entry)) return
-                const adopted = yield* adoptDurableDecision(entry, decision.decision).pipe(Effect.exit)
-                if (Exit.isFailure(adopted)) {
-                  entry.settling = false
-                  return yield* Effect.failCause(adopted.cause)
-                }
-                yield* completeClaimed(entry, adopted.value, decision.feedback)
-              }),
-            { discard: true },
-          ),
-        )
-        yield* reconcileLocalDecisions.pipe(
-          Effect.catchCause((cause) => Effect.logError("permission decision reconciliation failed", { cause })),
-          Effect.repeat(Schedule.fixed(Duration.millis(permissionDecisionPollMs))),
-          Effect.forkScoped,
-        )
-      }
+      const reconcileLocalDecisions = Effect.suspend(() =>
+        Effect.forEach(
+          Array.from(allPending.values()),
+          (entry) =>
+            Effect.gen(function* () {
+              if (entry.settling) return
+              const decision = yield* DeepAgentActivityAuthority.permissionDecisionForRequest(entry.info.id).pipe(
+                Effect.provideService(Database.Service, database),
+              )
+              if (!decision && entry.pendingSettlement && claimPending(entry.info.id, entry)) {
+                yield* settleClaimed(entry, entry.pendingSettlement.reply, entry.pendingSettlement.message)
+                return
+              }
+              if (!decision || !claimPending(entry.info.id, entry)) return
+              const adopted = yield* adoptDurableDecision(entry, decision.decision).pipe(Effect.exit)
+              if (Exit.isFailure(adopted)) {
+                entry.settling = false
+                return yield* Effect.failCause(adopted.cause)
+              }
+              yield* completeClaimed(entry, adopted.value, decision.feedback)
+            }),
+          { discard: true },
+        ),
+      )
+      yield* reconcileLocalDecisions.pipe(
+        Effect.catchCause((cause) => Effect.logError("permission decision reconciliation failed", { cause })),
+        Effect.repeat(Schedule.fixed(Duration.millis(permissionDecisionPollMs))),
+        Effect.forkScoped,
+      )
 
       const askEffect = Effect.fn("Permission.askEffect")(function* (input: AskInput) {
         const owner = yield* InstanceState.get(state)
@@ -444,10 +433,7 @@ export const layerWith = (options: LayerOptions = {}) =>
         let needsAsk = false
 
         for (const pattern of request.patterns) {
-          const rule =
-            flags.activityAuthority === "durable"
-              ? evaluateDurable(request.permission, pattern, ruleset, owner.approved, savedRules)
-              : evaluate(request.permission, pattern, ruleset, owner.approved)
+          const rule = evaluateDurable(request.permission, pattern, ruleset, owner.approved, savedRules)
           log.info("evaluated", { permission: request.permission, pattern, action: rule })
           if (rule.action === "deny") {
             return yield* new PermissionV1.DeniedError({
@@ -458,19 +444,17 @@ export const layerWith = (options: LayerOptions = {}) =>
           needsAsk = true
         }
 
-        if (!needsAsk && flags.activityAuthority !== "durable") return
-
-        const activity =
-          flags.activityAuthority === "durable"
-            ? yield* SessionPromptIntent.activeActivityForSession(request.sessionID).pipe(
-                Effect.provideService(Database.Service, database),
-              )
-            : undefined
-        if (flags.activityAuthority === "durable" && !activity)
-          return yield* new PermissionV1.DeniedError({
-            ruleset: [{ permission: "activity_authority", pattern: request.sessionID, action: "deny" }],
-          })
-        if (flags.activityAuthority === "durable" && requestKind === "tool" && !request.tool)
+        const activity = yield* SessionPromptIntent.activeActivityForSession(request.sessionID).pipe(
+          Effect.provideService(Database.Service, database),
+        )
+        if (!activity) {
+          // The durable authority records requests/decisions against an ADMITTED legacy activity.
+          // A turn driven without one (direct legacy loop entry, recovery edge windows) must not be
+          // hard-denied: fall back to policy-only semantics — allowed requests proceed unrecorded,
+          // interactive requests settle through the in-memory pending path exactly like legacy mode.
+          if (!needsAsk) return
+        }
+        if (activity && requestKind === "tool" && !request.tool)
           return yield* new PermissionV1.DeniedError({
             ruleset: [{ permission: "activity_tool_identity", pattern: request.permission, action: "deny" }],
           })
@@ -623,7 +607,7 @@ export const layerWith = (options: LayerOptions = {}) =>
             const current = yield* InstanceState.context
             const workspaceID = yield* InstanceState.workspaceID
             const existing = allPending.get(input.requestID)
-            if (!existing && flags.activityAuthority === "durable") {
+            if (!existing) {
               const request = yield* DeepAgentActivityAuthority.permissionRequestForRequest(input.requestID).pipe(
                 Effect.provideService(Database.Service, database),
               )
@@ -685,25 +669,20 @@ export const layerWith = (options: LayerOptions = {}) =>
             }
 
             const winnerReply = permissionReplyForDecision(durable)
-            if (flags.activityAuthority === "durable") {
-              if (winnerReply === "reject" && input.reply !== "reject")
-                return yield* new PermissionV1.NotFoundError({ requestID: input.requestID })
-              return
-            }
+            // Durable-backed siblings fan out through the DB (decidePermissionWithFanout + the
+            // reconciliation poller); memory-only entries of the same session (turns without an
+            // admitted activity) still need the in-memory fan-out or they never settle.
             if (winnerReply === "reject") {
-              if (input.reply === "reject") {
-                for (const [id, item] of allPending) {
-                  if (item.info.sessionID !== existing.info.sessionID || !claimPending(id, item)) continue
-                  yield* settleClaimed(item, "reject")
-                }
-              }
               if (input.reply !== "reject") return yield* new PermissionV1.NotFoundError({ requestID: input.requestID })
+              for (const [id, item] of allPending) {
+                if (item.durable || item.info.sessionID !== existing.info.sessionID || !claimPending(id, item)) continue
+                yield* settleClaimed(item, "reject")
+              }
               return
             }
             if (winnerReply === "once") return
-
             for (const [id, item] of allPending) {
-              if (item.info.sessionID !== existing.info.sessionID) continue
+              if (item.durable || item.info.sessionID !== existing.info.sessionID) continue
               const ok = item.info.patterns.every(
                 (pattern) => evaluate(item.info.permission, pattern, item.owner.approved).action === "allow",
               )
@@ -728,7 +707,6 @@ export const layerWith = (options: LayerOptions = {}) =>
         readonly toolCallID: string
         readonly toolName: string
       }) {
-        if (flags.activityAuthority !== "durable") return []
         return yield* DeepAgentActivityAuthority.permissionEffectsForToolCall(input).pipe(
           Effect.provideService(Database.Service, database),
         )
@@ -760,7 +738,6 @@ export const layerWith = (options: LayerOptions = {}) =>
         readonly expectedVersion: number
         readonly terminalReason: string
       }) {
-        if (flags.activityAuthority !== "durable") return false
         return yield* permissionOwnerID().pipe(
           Effect.flatMap((recoveryOwnerID) =>
             DeepAgentActivityAuthority.recoverActivity({
@@ -784,7 +761,9 @@ export const layerWith = (options: LayerOptions = {}) =>
         askEffect,
         effectsForToolCall,
         settleEffect,
-        ...(flags.activityAuthority === "durable" ? { rotateOwner, rotateOwnerIfCurrent, recoverActivity } : {}),
+        rotateOwner,
+        rotateOwnerIfCurrent,
+        recoverActivity,
         reply,
         list,
       })
diff --git a/packages/deepagent-code/src/provider/transform.ts b/packages/deepagent-code/src/provider/transform.ts
index b0266a2a..ee52e808 100644
--- a/packages/deepagent-code/src/provider/transform.ts
+++ b/packages/deepagent-code/src/provider/transform.ts
@@ -4,10 +4,14 @@ import type { JSONSchema7 } from "@ai-sdk/provider"
 import type * as Provider from "./provider"
 import type * as ModelsDev from "@deepagent-code/core/models-dev"
 import { deepagentUpstreamProviderID } from "./compatibility"
+import { ToolPairing } from "@/session/llm/tool-pairing"
 import { iife } from "@/util/iife"
+import { Log } from "@deepagent-code/core/util/log"
 
 type Modality = NonNullable<ModelsDev.Model["modalities"]>["input"][number]
 
+const log = Log.create({ service: "provider-transform" })
+
 function mimeToModality(mime: string): Modality | undefined {
   if (mime.startsWith("image/")) return "image"
   if (mime.startsWith("audio/")) return "audio"
@@ -410,9 +414,47 @@ function unsupportedParts(msgs: ModelMessage[], model: Provider.Model): ModelMes
   })
 }
 
+// Same condition as the mistral scrub inside normalizeMessages; hoisted so
+// message() can tell the tool-pairing repairer to re-bridge tool→user gaps
+// its synthetic tool messages may introduce after the scrub has already run.
+function isMistralModel(model: Provider.Model) {
+  return (
+    model.providerID === "mistral" ||
+    model.api.id.toLowerCase().includes("mistral") ||
+    model.api.id.toLocaleLowerCase().includes("devstral")
+  )
+}
+
 export function message(msgs: ModelMessage[], model: Provider.Model, options: Record<string, unknown>) {
   msgs = unsupportedParts(msgs, model)
   msgs = normalizeMessages(msgs, model, options)
+  // UPD-001: repair tool_use/tool_result pairing (missing results, orphan
+  // results, duplicate callIDs). MUST stay after normalizeMessages: the
+  // mistral toolCallId scrub truncates IDs and can collide distinct IDs into
+  // duplicates that only exist post-scrub, so dedup has to run last. Existing
+  // scrub behavior is untouched.
+  //
+  // UPD-001 telemetry: collect WHAT the repairer changed and emit a structured
+  // record when it changed anything. The receipt's `call_ids` captures the
+  // PRE-repair projection, so a repaired wire body diverges from it; this log
+  // is the correlation that makes that divergence explainable (which call_ids
+  // were synthesized / stripped / deduped before the wire_request_hash was
+  // taken).
+  const pairingReport = ToolPairing.emptyRepairReport()
+  msgs = ToolPairing.repairToolPairing(msgs, {
+    bridgeToolUserGap: isMistralModel(model),
+    report: pairingReport,
+  })
+  if (!ToolPairing.repairReportIsEmpty(pairingReport)) {
+    log.info("tool pairing repaired the wire body (receipt call_ids record the pre-repair projection)", {
+      providerID: model.providerID,
+      modelID: model.id,
+      synthesizedResults: pairingReport.synthesizedResults,
+      strippedOrphanResults: pairingReport.strippedOrphanResults,
+      droppedDuplicates: pairingReport.droppedDuplicates,
+      bridgedToolUserGaps: pairingReport.bridgedToolUserGaps,
+    })
+  }
   if (
     (model.providerID === "anthropic" ||
       model.providerID === "google-vertex-anthropic" ||
diff --git a/packages/deepagent-code/src/server/routes/instance/httpapi/groups/session.ts b/packages/deepagent-code/src/server/routes/instance/httpapi/groups/session.ts
index 8f43cf77..5f94b511 100644
--- a/packages/deepagent-code/src/server/routes/instance/httpapi/groups/session.ts
+++ b/packages/deepagent-code/src/server/routes/instance/httpapi/groups/session.ts
@@ -317,10 +317,49 @@ export const ContextAttemptResolvePayload = Schema.Struct({
   reason: Schema.String,
   riskAcknowledged: Schema.optional(Schema.Boolean),
 })
+// FEAT-005: cohort-level durable aggregation query/result. The window is [sinceMs, untilMs]; untilMs
+// defaults to now when omitted. Result buckets selections by readiness (see diagnostics.cohort).
+export const ContextCohortQuery = Schema.Struct({
+  ...WorkspaceRoutingQueryFields,
+  sinceMs: Schema.NumberFromString,
+  untilMs: Schema.optional(Schema.NumberFromString),
+})
+const ContextCohortGraphStat = Schema.Struct({
+  statuses: Schema.Int,
+  ready: Schema.Int,
+  notReady: Schema.Int,
+})
+export const ContextCohortResult = Schema.Struct({
+  window: Schema.Struct({ sinceMs: Schema.Int, untilMs: Schema.Int }),
+  selections: Schema.Int,
+  sessions: Schema.Int,
+  tokens: Schema.Int,
+  readiness: Schema.Struct({
+    ready: Schema.Int,
+    building: Schema.Int,
+    degraded: Schema.Int,
+    blocked: Schema.Int,
+  }),
+  graphs: Schema.Struct({
+    code: ContextCohortGraphStat,
+    knowledge: ContextCohortGraphStat,
+    memory: ContextCohortGraphStat,
+    documents: ContextCohortGraphStat,
+  }),
+})
 export const ProviderResolutionPayload = Schema.Struct(
   Struct.omit(SessionLegacyProviderResolution.ResolveInput.fields, ["sessionID"]),
 )
 
+export const ImportSnapshotPayload = Schema.Struct({
+  bundle: Schema.String,
+})
+export const ImportSnapshotResult = Schema.Struct({
+  sessionID: Schema.String,
+  messages: Schema.Number,
+  parts: Schema.Number,
+})
+
 export const SessionPaths = {
   list: root,
   status: `${root}/status`,
@@ -357,7 +396,10 @@ export const SessionPaths = {
   updatePart: `${root}/:sessionID/message/:messageID/part/:partID`,
   contextDiagnostics: `${root}/:sessionID/context`,
   contextAttemptResolve: `${root}/:sessionID/context/attempt/:attemptID/resolve`,
+  contextCohort: `${root}/context/cohort`,
   providerResolution: `${root}/:sessionID/provider-resolution`,
+  exportSnapshot: `${root}/:sessionID/export`,
+  importSnapshot: `${root}/import-snapshot`,
 } as const
 
 export const SessionApi = HttpApi.make("session")
@@ -824,6 +866,19 @@ export const SessionApi = HttpApi.make("session")
             description: "Apply an audited abandon, verified-settle, or risk-acknowledged replay decision.",
           }),
         ),
+        HttpApiEndpoint.get("contextCohort", SessionPaths.contextCohort, {
+          query: ContextCohortQuery,
+          success: described(ContextCohortResult, "Cohort-level federated context aggregation"),
+          error: [HttpApiError.BadRequest],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "session.contextCohort",
+            summary: "Aggregate federated context selections across sessions",
+            description:
+              "FEAT-005: durable cohort aggregation over [sinceMs, untilMs], bucketed by readiness " +
+              "(ready/building/degraded/blocked) so rollout decisions are not skewed by cold-start noise.",
+          }),
+        ),
         HttpApiEndpoint.get("providerResolutionList", SessionPaths.providerResolution, {
           params: { sessionID: SessionID },
           query: WorkspaceRoutingQuery,
@@ -852,6 +907,32 @@ export const SessionApi = HttpApi.make("session")
             description: "Append an audited abandoned resolution and activate a safe successor history epoch.",
           }),
         ),
+        HttpApiEndpoint.get("exportSnapshot", SessionPaths.exportSnapshot, {
+          params: { sessionID: SessionID },
+          success: described(Schema.String, "Session snapshot bundle as a JSON string"),
+          error: [HttpApiError.BadRequest, ApiNotFoundError],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "session.exportSnapshot",
+            summary: "Export a session snapshot",
+            description:
+              "Export the session's conversation (session + messages + parts) as a self-describing " +
+              "snapshot bundle (JSON). The bundle re-imports on another device as a fresh, continuable session.",
+          }),
+        ),
+        HttpApiEndpoint.post("importSnapshot", SessionPaths.importSnapshot, {
+          payload: ImportSnapshotPayload,
+          success: described(ImportSnapshotResult, "Imported session summary"),
+          error: [HttpApiError.BadRequest],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "session.importSnapshot",
+            summary: "Import a session snapshot",
+            description:
+              "Import a previously exported session bundle into the current instance as a fresh, " +
+              "continuable session (new IDs, re-rooted to the current project/directory).",
+          }),
+        ),
       )
       .annotateMerge(
         OpenApi.annotations({
diff --git a/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/deepagent.ts b/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/deepagent.ts
index 63712f10..32e93550 100644
--- a/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/deepagent.ts
+++ b/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/deepagent.ts
@@ -1,8 +1,12 @@
 import path from "node:path"
-import * as nodeFs from "node:fs"
+import { createHash } from "node:crypto"
+import { sql } from "drizzle-orm"
 import * as Log from "@deepagent-code/core/util/log"
 import { Config } from "@/config/config"
 import { configureGateway, reviewRunsDir } from "@/deepagent/config"
+import { readPinnedPacks, writePinnedPacks } from "@deepagent-code/core/deepagent/pinned-packs"
+import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
+import { LMNEvents } from "@deepagent-code/core/deepagent/lmn-events"
 import { buildProfile } from "@/deepagent/profile-detector"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { Effect } from "effect"
@@ -106,6 +110,70 @@ const projectPlanReceipt = (receipt: PlanEditReceipt) => ({
 
 const dbgLog = Log.create({ service: "deepagent.packs.debug" })
 
+// FEAT-003 — pack pin/unpin eventing: after the pinned-set file is durably written, the handler
+// publishes `pack.changed` so downstream surfaces are NOT left waiting for their next natural
+// recomputation. BENEFIT BOUNDARY (must not be widened without review — mirrors the
+// LMNEvents.PACK_CHANGED contract):
+//   - the federation four graphs do NOT read pack scope (the knowledge adapter only ever consumes
+//     released snapshots) — no federation-side reaction is expected from this event;
+//   - intended consumers are legacy retrieval-surface audit + UI notification, subscribing on demand.
+//     This producer only guarantees the event is emitted and subscribable; no consumer is added here.
+//
+// IDEMPOTENCY KEY = hash of the AFTER-WRITE pinned set (workspace-scoped): repeated pin/unpin clicks
+// that leave the SAME set never re-publish (the bus dedupes on idempotency_key). `action` is folded in
+// so a pin/unpin pair passing through the same set is not swallowed, and the workspace path is hashed
+// in so identical sets in different workspaces never collide on the shared bus DB.
+export const packChangedIdempotencyKey = (input: {
+  readonly workspacePath: string
+  readonly action: "pin" | "unpin"
+  readonly pinnedIds: readonly string[]
+}): string => {
+  const sha = (value: string) => createHash("sha256").update(value).digest("hex")
+  const setHash = sha([...new Set(input.pinnedIds)].sort().join(","))
+  return `pack.changed:${sha(input.workspacePath)}:${input.action}:${setHash}`
+}
+
+// Publish pack.changed for a committed pin/unpin. BEST-EFFORT: the pinned-set file write already
+// succeeded and stays authoritative — a bus failure must never fail the route (log, never throw).
+export const publishPackChanged = (
+  bus: DeepAgentEventBus.Interface,
+  input: {
+    readonly workspacePath: string
+    readonly packId: string
+    readonly action: "pin" | "unpin"
+    readonly pinnedIds: readonly string[]
+  },
+): Effect.Effect<void> =>
+  bus
+    .publish({
+      type: LMNEvents.PACK_CHANGED,
+      source: "system",
+      workspaceID: input.workspacePath,
+      actorID: SERVER_USER_ID,
+      idempotencyKey: packChangedIdempotencyKey(input),
+      priority: "normal",
+      payload: {
+        workspacePath: input.workspacePath,
+        packId: input.packId,
+        action: input.action,
+        pinnedIds: [...new Set(input.pinnedIds)].sort(),
+      },
+    })
+    .pipe(
+      Effect.asVoid,
+      Effect.catchCause((cause) =>
+        Effect.logError("pack.changed publish failed (pin/unpin file write already committed)").pipe(
+          Effect.annotateLogs({
+            reason: "publish_error",
+            workspacePath: input.workspacePath,
+            packId: input.packId,
+            action: input.action,
+            cause: String(cause),
+          }),
+        ),
+      ),
+    )
+
 // §C.4 — the server-side ceiling on Expert-Panel debate rounds a single consult may request. Round 1
 // plus up to 2 debate rounds: enough for opinions to converge (the orchestrator also early-stops on a
 // stable verdict distribution) while bounding the fan-out (one subagent turn per lens per round).
@@ -152,6 +220,9 @@ export const deepagentHandlers = HttpApiBuilder.group(InstanceHttpApi, "deepagen
     const goals = yield* GoalManager.Service
     const database = yield* Database.Service
     const locationIdentity = yield* LocationIdentity.Service
+    // FEAT-003 — the §A2 bus packsPin/packsUnpin publish pack.changed onto. Available at this layer
+    // (the route runtime provides DeepAgentEventBus.defaultLayer — same seam the IM handlers use).
+    const eventBus = yield* DeepAgentEventBus.Service
 
     // Build a reviewer-subagent turn runner scoped to a session — the panelist seam consultPanel needs.
     // Reuses makeTaskSubagentRunner (the same child-session + permission-derivation path the goal loop
@@ -454,18 +525,31 @@ export const deepagentHandlers = HttpApiBuilder.group(InstanceHttpApi, "deepagen
     })
 
     const releasedScope = Effect.fn("DeepAgentHttpApi.releasedScope")(function* (dir: string) {
+      const legacyProjectId = AgentGateway.DeepAgentDurableKnowledgeStore.projectIdForWorkspace(dir)
       const identity = yield* locationIdentity.resolve({
         boundary: { kind: "implicit_local" },
         directory: AbsolutePath.make(dir),
         project: {
           kind: "registered_root",
-          observedProjectId: AgentGateway.DeepAgentDurableKnowledgeStore.projectIdForWorkspace(dir),
+          observedProjectId: legacyProjectId,
         },
       })
+      // Self-heal scope identities recorded before the canonical observed-project convention (e.g.
+      // the location-index shadow once wrote the "global" sentinel project id): the released-scope
+      // guard pins observed_project_id to the canonical durable knowledge project id.
+      if (identity.observedProjectId !== legacyProjectId) {
+        yield* database.db.run(
+          sql`UPDATE context_project_scope_identity SET observed_project_id = ${legacyProjectId}
+              WHERE security_namespace_id = ${identity.securityNamespaceId}
+                AND project_scope_key = ${identity.projectScopeKey}
+                AND project_kind = 'registered_root'
+                AND retired_at IS NULL`,
+        )
+      }
       return {
         securityNamespaceId: identity.securityNamespaceId,
         projectScopeKey: identity.projectScopeKey,
-        legacyProjectId: AgentGateway.DeepAgentDurableKnowledgeStore.projectIdForWorkspace(dir),
+        legacyProjectId,
       }
     })
 
@@ -605,20 +689,10 @@ export const deepagentHandlers = HttpApiBuilder.group(InstanceHttpApi, "deepagen
     })
 
     // docs/34 §9 S10: pinned packs persist per-workspace as a small JSON file under the memory dir.
-    const pinnedPacksFile = (memoryDir: string) => path.join(memoryDir, "pinned-packs.json")
-    const readPinned = (memoryDir: string): string[] => {
-      try {
-        const raw = nodeFs.readFileSync(pinnedPacksFile(memoryDir), "utf8")
-        const arr = JSON.parse(raw)
-        return Array.isArray(arr) ? arr.filter((x): x is string => typeof x === "string") : []
-      } catch {
-        return []
-      }
-    }
-    const writePinned = (memoryDir: string, ids: readonly string[]): void => {
-      nodeFs.mkdirSync(memoryDir, { recursive: true })
-      nodeFs.writeFileSync(pinnedPacksFile(memoryDir), JSON.stringify([...new Set(ids)].sort(), null, 2), "utf8")
-    }
+    // FEAT-001: read/write live in the shared core module so the gateway runtime reads the exact
+    // same file the control plane writes (readPinnedPacks is fault-tolerant: missing/corrupt => []).
+    const readPinned = (memoryDir: string): string[] => readPinnedPacks(memoryDir)
+    const writePinned = (memoryDir: string, ids: readonly string[]): void => writePinnedPacks(memoryDir, ids)
 
     const packsActive = Effect.fn("DeepAgentHttpApi.packsActive")(function* () {
       const dir = yield* workspaceDir()
@@ -704,29 +778,49 @@ export const deepagentHandlers = HttpApiBuilder.group(InstanceHttpApi, "deepagen
 
     const packsPin = Effect.fn("DeepAgentHttpApi.packsPin")(function* (ctx) {
       const memoryDir = yield* workspaceMemoryDir()
-      return yield* Effect.try({
+      const workspacePath = yield* workspaceDir()
+      // FEAT-003: write first (file stays authoritative), then publish pack.changed with the
+      // AFTER-WRITE set — the idempotency key is that set's hash, so re-clicks dedupe on the bus.
+      const pinnedIds = yield* Effect.try({
         try: () => {
           writePinned(memoryDir, [...readPinned(memoryDir), ctx.payload.packId])
-          return { ok: true, packId: ctx.payload.packId }
+          return readPinned(memoryDir)
         },
         catch: (error) =>
           new DeepAgentPromotionError({ message: error instanceof Error ? error.message : String(error) }),
       })
+      yield* publishPackChanged(eventBus, {
+        workspacePath,
+        packId: ctx.payload.packId,
+        action: "pin",
+        pinnedIds,
+      })
+      return { ok: true, packId: ctx.payload.packId }
     })
 
     const packsUnpin = Effect.fn("DeepAgentHttpApi.packsUnpin")(function* (ctx) {
       const memoryDir = yield* workspaceMemoryDir()
-      return yield* Effect.try({
+      const workspacePath = yield* workspaceDir()
+      // FEAT-003: same contract as packsPin — the event fires even when unpinning the LAST pack
+      // (the after-write set is empty; its hash is still a valid, publishable key).
+      const pinnedIds = yield* Effect.try({
         try: () => {
           writePinned(
             memoryDir,
             readPinned(memoryDir).filter((id) => id !== ctx.payload.packId),
           )
-          return { ok: true, packId: ctx.payload.packId }
+          return readPinned(memoryDir)
         },
         catch: (error) =>
           new DeepAgentPromotionError({ message: error instanceof Error ? error.message : String(error) }),
       })
+      yield* publishPackChanged(eventBus, {
+        workspacePath,
+        packId: ctx.payload.packId,
+        action: "unpin",
+        pinnedIds,
+      })
+      return { ok: true, packId: ctx.payload.packId }
     })
 
     // V3.8.1 §G environment-fact use-gate handlers. The adoption service roots at the same gateway
diff --git a/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/session.ts b/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/session.ts
index 9292cdcd..690fdde1 100644
--- a/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/session.ts
+++ b/packages/deepagent-code/src/server/routes/instance/httpapi/handlers/session.ts
@@ -31,12 +31,14 @@ import { InstanceHttpApi } from "../api"
 import {
   CommandPayload,
   ContextAttemptResolvePayload,
+  ContextCohortQuery,
   DiffArtifactFileQuery,
   DiffArtifactMaintenancePayload,
   DiffArtifactManifestQuery,
   DiffQuery,
   ForkPayload,
   InitPayload,
+  ImportSnapshotPayload,
   LegacyForkPayload,
   ListQuery,
   MessagesQuery,
@@ -49,11 +51,13 @@ import {
   SummarizePayload,
   UpdatePayload,
 } from "../groups/session"
-import { ConflictError, PermissionNotFoundError, ServiceUnavailableError, notFound } from "../errors"
+import { ApiNotFoundError, ConflictError, PermissionNotFoundError, ServiceUnavailableError, notFound } from "../errors"
 import * as SessionError from "./session-errors"
 import { randomUUID } from "node:crypto"
 import { getWorkspaceContext } from "../utils/workspace-context"
 import { SessionDiffArtifact } from "@/session/diff-artifact"
+import { exportSessionSnapshot, importSessionSnapshot, type SessionSnapshot } from "@/session/snapshot"
+import { InstanceState } from "@/effect/instance-state"
 
 const tryParseJson = (text: string) =>
   Effect.try({
@@ -719,6 +723,14 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       return resolved
     })
 
+    const contextCohort = Effect.fn("SessionHttpApi.contextCohort")(function* (ctx: {
+      query: typeof ContextCohortQuery.Type
+    }) {
+      return yield* contextDiagnosticsSvc
+        .cohort({ sinceMs: ctx.query.sinceMs, ...(ctx.query.untilMs != null ? { untilMs: ctx.query.untilMs } : {}) })
+        .pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
+    })
+
     const providerResolutionList = Effect.fn("SessionHttpApi.providerResolutionList")(function* (ctx: {
       params: { sessionID: SessionID }
     }) {
@@ -745,6 +757,35 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
         )
     })
 
+    const exportSnapshot = Effect.fn("SessionHttpApi.exportSnapshot")(function* (ctx: {
+      params: { sessionID: SessionID }
+    }) {
+      yield* requireSession(ctx.params.sessionID)
+      const bundle = yield* exportSessionSnapshot(ctx.params.sessionID).pipe(
+        Effect.mapError(() => notFound(`session not found: ${ctx.params.sessionID}`)),
+      )
+      return JSON.stringify(bundle)
+    })
+
+    const importSnapshot = Effect.fn("SessionHttpApi.importSnapshot")(function* (ctx: {
+      payload: typeof ImportSnapshotPayload.Type
+    }) {
+      const snapshot = yield* tryParseJson(ctx.payload.bundle).pipe(
+        Effect.flatMap((raw) =>
+          Effect.try({
+            try: () => raw as SessionSnapshot,
+            catch: () => new HttpApiError.BadRequest({}),
+          }),
+        ),
+      )
+      const instanceCtx = yield* InstanceState.context
+      return yield* importSessionSnapshot({
+        snapshot,
+        projectID: instanceCtx.project.id,
+        directory: instanceCtx.directory,
+      }).pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
+    })
+
     return handlers
       .handle("list", list)
       .handle("status", status)
@@ -782,7 +823,10 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       .handle("updatePart", updatePart)
       .handle("contextDiagnostics", contextDiagnostics)
       .handle("contextAttemptResolve", contextAttemptResolve)
+      .handle("contextCohort", contextCohort)
       .handle("providerResolutionList", providerResolutionList)
       .handle("providerResolutionResolve", providerResolutionResolve)
+      .handle("exportSnapshot", exportSnapshot)
+      .handle("importSnapshot", importSnapshot)
   }),
 )
diff --git a/packages/deepagent-code/src/server/routes/instance/httpapi/public.ts b/packages/deepagent-code/src/server/routes/instance/httpapi/public.ts
index c3a41f1c..98fd737f 100644
--- a/packages/deepagent-code/src/server/routes/instance/httpapi/public.ts
+++ b/packages/deepagent-code/src/server/routes/instance/httpapi/public.ts
@@ -286,6 +286,11 @@ function applyLegacySchemaOverrides(spec: OpenApiSpec) {
   const model = schemas.ProviderConfig?.properties?.models?.additionalProperties
   const variants = typeof model === "object" ? model.properties?.variants?.additionalProperties : undefined
   if (variants && typeof variants === "object") variants.additionalProperties = {}
+  // PARITY-004 模型启停服务端真相源:服务端 ConfigV2.Model 已支持 per-model `disabled`
+  // (plugin/provider.ts 映射 model.enabled=!disabled),但 OpenAPI 生成源未暴露该字段;
+  // 在此补齐,使 SDK Config 类型可读写 per-model disabled(与运行时行为一致)。
+  if (model && typeof model === "object" && model.properties && !model.properties.disabled)
+    model.properties.disabled = { type: "boolean" }
   const syncInfo = schemas.SyncEventSessionUpdated?.properties?.data?.properties?.info
   if (syncInfo?.properties) makePropertiesNullable(syncInfo.properties)
 }
diff --git a/packages/deepagent-code/src/session/__tests__/snapshot.test.ts b/packages/deepagent-code/src/session/__tests__/snapshot.test.ts
new file mode 100644
index 00000000..299c984a
--- /dev/null
+++ b/packages/deepagent-code/src/session/__tests__/snapshot.test.ts
@@ -0,0 +1,367 @@
+import { describe, expect, it } from "bun:test"
+import { Effect, Layer } from "effect"
+import { asc, eq, sql } from "drizzle-orm"
+import { randomBytes } from "node:crypto"
+import { Database } from "@deepagent-code/core/database/database"
+import { MessageTable, PartTable, SessionTable } from "@deepagent-code/core/session/sql"
+import {
+  ProjectScopeIdentityTable,
+  SecurityNamespaceTable,
+} from "@deepagent-code/core/context-federation/sql"
+import { SessionProviderOwnerLeaseTable } from "@deepagent-code/core/context-federation/session-sql"
+import { SessionActivityProgressTable, SessionLegacyActivityTable } from "../activity-sql"
+import { SessionToolRequestReceiptTable } from "../tool-request-receipt.sql"
+import { ProjectTable } from "@deepagent-code/core/project/sql"
+import { exportSessionSnapshot, importSessionSnapshot, SNAPSHOT_FORMAT, type SessionSnapshot } from "../snapshot"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+const EMPTY_REFS_FINGERPRINT = "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"
+const randomHex = (n: number) => randomBytes(n).toString("hex")
+
+function withDb(dbPath: string, program: Effect.Effect<any, any, any>): Promise<any> {
+  const database = Database.layerFromPath(dbPath)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return Effect.runPromise(program.pipe(Effect.provide(database as any)) as any)
+}
+
+const PROJECT_ID = "proj_snap"
+const DIRECTORY = "/tmp/snap-proj"
+const NS_ID = "ns_seed"
+const SCOPE_KEY = "scope_seed"
+const OWNER_TOKEN = "owner_seed_token"
+
+/** Seed authority rows (owner lease + security namespace + scope identity) for receipt triggers. */
+function seedAuthority(db: any) {
+  return Effect.gen(function* () {
+    const now = Date.now()
+    yield* db
+      .insert(SecurityNamespaceTable)
+      .values([{ id: NS_ID, kind: "implicit_local", binding_hash: randomHex(32), created_at: now, retired_at: null }] as never)
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(ProjectScopeIdentityTable)
+      .values(
+        [
+          {
+            security_namespace_id: NS_ID,
+            project_scope_key: SCOPE_KEY,
+            project_kind: "registered_root",
+            project_identity_hash: randomHex(32),
+            created_at: now,
+            retired_at: null,
+          },
+        ] as never,
+      )
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionProviderOwnerLeaseTable)
+      .values(
+        [
+          {
+            owner_token: OWNER_TOKEN,
+            registered_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`,
+            heartbeat_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`,
+            lease_expires_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER) + 3600000`,
+            released_at: null,
+          },
+        ] as never,
+      )
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+  })
+}
+
+/** Seed session row + 2 messages + 4 parts. */
+function seedConversation(db: any, sessionID: string) {
+  return Effect.gen(function* () {
+    yield* db
+      .insert(ProjectTable)
+      .values([{ id: PROJECT_ID, worktree: DIRECTORY, sandboxes: [] }] as never)
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionTable)
+      .values(
+        [
+          {
+            id: sessionID,
+            project_id: PROJECT_ID,
+            slug: "snap",
+            directory: DIRECTORY,
+            title: "快照测试会话",
+            version: "test",
+            model: { id: "deepseek-chat", providerID: "deepseek" },
+            time_created: 1_782_870_400_000,
+            time_updated: 1_782_870_410_000,
+          },
+        ] as never,
+      )
+      .run()
+      .pipe(Effect.orDie)
+    const userMsg = `${sessionID}_msg_user`
+    const asstMsg = `${sessionID}_msg_asst`
+    yield* db
+      .insert(MessageTable)
+      .values([
+        { id: userMsg, session_id: sessionID, time_created: 1_782_870_401_000, time_updated: 1_782_870_401_000, data: { role: "user" } },
+        {
+          id: asstMsg,
+          session_id: sessionID,
+          time_created: 1_782_870_402_000,
+          time_updated: 1_782_870_405_000,
+          data: { role: "assistant", model: { providerID: "deepseek", modelID: "deepseek-chat" } },
+        },
+      ] as never)
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(PartTable)
+      .values([
+        { id: `${sessionID}_p_u`, message_id: userMsg, session_id: sessionID, time_created: 1_782_870_401_000, time_updated: 1_782_870_401_000, data: { type: "text", text: "hello world" } },
+        { id: `${sessionID}_p_r`, message_id: asstMsg, session_id: sessionID, time_created: 1_782_870_402_000, time_updated: 1_782_870_402_000, data: { type: "reasoning", text: "thinking" } },
+        { id: `${sessionID}_p_t`, message_id: asstMsg, session_id: sessionID, time_created: 1_782_870_403_000, time_updated: 1_782_870_403_000, data: { type: "text", text: "print('hi')" } },
+        { id: `${sessionID}_p_tool`, message_id: asstMsg, session_id: sessionID, time_created: 1_782_870_404_000, time_updated: 1_782_870_404_000, data: { type: "tool", callID: "c1", tool: "bash", state: { status: "completed", input: { command: "echo hi" }, output: "hi" } } },
+      ] as never)
+      .run()
+      .pipe(Effect.orDie)
+    return { userMsg, asstMsg }
+  })
+}
+
+/**
+ * Seed one activity + one progress revision honoring the state-machine triggers:
+ * insert activity(active) -> synthetic receipt (satisfying receipt triggers) -> progress ->
+ * (optionally) terminalize. FK off only for the placeholder trigger_admission_id.
+ */
+function seedActivity(db: any, sessionID: string, asstMsg: string, userMsg: string, opts: { leaveActive?: boolean } = {}) {
+  const activityID = `${sessionID}_act`
+  const receiptID = `${sessionID}_rcpt`
+  return Effect.acquireUseRelease(
+    db.run("PRAGMA foreign_keys = OFF").pipe(Effect.orDie),
+    () =>
+      Effect.gen(function* () {
+        yield* db
+          .insert(SessionLegacyActivityTable)
+          .values(
+            [
+              {
+                activity_id: activityID,
+                session_id: sessionID,
+                ordinal: 0,
+                trigger_admission_id: `${sessionID}_adm`,
+                owner_token: OWNER_TOKEN,
+                state: "active",
+                terminal_reason: null,
+                created_at: 1_782_870_401_000,
+                settled_at: null,
+              },
+            ] as never,
+          )
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .insert(SessionToolRequestReceiptTable)
+          .values(
+            [
+              {
+                receipt_id: receiptID,
+                request_ordinal: 1,
+                session_id: sessionID,
+                user_message_id: userMsg,
+                assistant_message_id: asstMsg,
+                provider_id: "deepseek",
+                model_id: "deepseek-chat",
+                registry_tool_ids: [],
+                permission_filtered_tool_ids: [],
+                final_offered_tool_ids: [],
+                call_ids: [],
+                provider_state: "preparing",
+                request_state: "prepared",
+                owner_token: OWNER_TOKEN,
+                released_knowledge_security_namespace_id: NS_ID,
+                released_knowledge_project_scope_key: SCOPE_KEY,
+                released_knowledge_binding_state: "unavailable",
+                released_knowledge_exact_refs: [],
+                released_knowledge_exact_refs_fingerprint: EMPTY_REFS_FINGERPRINT,
+                created_at: 1_782_870_402_000,
+              },
+            ] as never,
+          )
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .insert(SessionActivityProgressTable)
+          .values(
+            [
+              {
+                activity_id: activityID,
+                revision: 0,
+                assistant_message_id: asstMsg,
+                text_part_id: null,
+                provider_receipt_id: receiptID,
+                input_membership_ordinal: 0,
+                state: "final",
+                created_at: 1_782_870_402_000,
+                settled_at: 1_782_870_405_000,
+              },
+            ] as never,
+          )
+          .run()
+          .pipe(Effect.orDie)
+        if (!opts.leaveActive) {
+          yield* db
+            .update(SessionLegacyActivityTable)
+            .set({ state: "settled", settled_at: 1_782_870_405_000, terminal_reason: "stop" } as never)
+            .where(eq(SessionLegacyActivityTable.activity_id, activityID as never))
+            .run()
+            .pipe(Effect.orDie)
+        }
+        return activityID
+      }),
+    () => db.run("PRAGMA foreign_keys = ON").pipe(Effect.orDie),
+  )
+}
+
+const messagesOf = (db: any, sessionID: string) =>
+  db
+    .select()
+    .from(MessageTable)
+    .where(eq(MessageTable.session_id, sessionID as never))
+    .orderBy(asc(MessageTable.time_created))
+    .all()
+    .pipe(Effect.orDie)
+const partsOf = (db: any, sessionID: string) =>
+  db.select().from(PartTable).where(eq(PartTable.session_id, sessionID as never)).all().pipe(Effect.orDie)
+const sessionRow = (db: any, sessionID: string) =>
+  db.select().from(SessionTable).where(eq(SessionTable.id, sessionID as never)).get().pipe(Effect.orDie)
+const activitiesOf = (db: any, sessionID: string) =>
+  db
+    .select()
+    .from(SessionLegacyActivityTable)
+    .where(eq(SessionLegacyActivityTable.session_id, sessionID as never))
+    .all()
+    .pipe(Effect.orDie)
+const progressOf = (db: any, activityID: string) =>
+  db
+    .select()
+    .from(SessionActivityProgressTable)
+    .where(eq(SessionActivityProgressTable.activity_id, activityID as never))
+    .all()
+    .pipe(Effect.orDie)
+
+describe("session snapshot export/import (complete scene + continue)", () => {
+  it("round-trips conversation + activity markers with fresh IDs and consistent ownership", async () => {
+    const dbPath = join(tmpdir(), `snap-rt-${Date.now()}.sqlite`)
+    await withDb(
+      dbPath,
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        const srcID = "ses_src_rt"
+        yield* seedAuthority(db)
+        const { userMsg, asstMsg } = yield* seedConversation(db, srcID)
+        const srcActivityID = yield* seedActivity(db, srcID, asstMsg, userMsg)
+
+        const snapshot = yield* exportSessionSnapshot(srcID)
+        expect(snapshot.format).toBe(SNAPSHOT_FORMAT)
+        expect(snapshot.messages.length).toBe(2)
+        expect(snapshot.parts.length).toBe(4)
+        expect(snapshot.activities.length).toBe(1)
+        expect(snapshot.progress.length).toBe(1)
+
+        const parsed = JSON.parse(JSON.stringify(snapshot))
+        const imported = yield* importSessionSnapshot({ snapshot: parsed, projectID: PROJECT_ID, directory: DIRECTORY })
+        const newID = imported.sessionID
+        expect(newID).not.toBe(srcID)
+
+        // conversation reconstructed with fresh IDs
+        const msgs = yield* messagesOf(db, newID)
+        expect(msgs.length).toBe(2)
+        expect(msgs[0].data.role).toBe("user")
+        expect(msgs[1].data.role).toBe("assistant")
+        expect(msgs[1].id).not.toBe(asstMsg)
+        const parts = yield* partsOf(db, newID)
+        expect(parts.length).toBe(4)
+
+        // activity + progress reconstructed with a fresh activity_id, terminal state preserved
+        const acts = yield* activitiesOf(db, newID)
+        expect(acts.length).toBe(1)
+        expect(acts[0].activity_id).not.toBe(srcActivityID)
+        expect(acts[0].state).toBe("settled")
+        const prog = yield* progressOf(db, acts[0].activity_id)
+        expect(prog.length).toBe(1)
+        // progress.assistant_message_id remapped to the NEW assistant message
+        expect(prog[0].assistant_message_id).toBe(msgs[1].id)
+        // ownership consistency required by message-v2.ts:419
+        expect(acts[0].session_id).toBe(msgs[1].session_id)
+        // no active activity remains -> continuable
+        expect(acts.some((a: any) => a.state === "active")).toBe(false)
+      }),
+    )
+  })
+
+  it("guarantees continue: a mid-run (active) source is terminalized, no active activity remains", async () => {
+    const dbPath = join(tmpdir(), `snap-cont-${Date.now()}.sqlite`)
+    await withDb(
+      dbPath,
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        const srcID = "ses_src_midrun"
+        yield* seedAuthority(db)
+        const { userMsg, asstMsg } = yield* seedConversation(db, srcID)
+        yield* seedActivity(db, srcID, asstMsg, userMsg, { leaveActive: true })
+        const srcActs = yield* activitiesOf(db, srcID)
+        expect(srcActs.some((a: any) => a.state === "active")).toBe(true)
+
+        const snapshot = yield* exportSessionSnapshot(srcID)
+        const imported = yield* importSessionSnapshot({ snapshot, projectID: PROJECT_ID, directory: DIRECTORY })
+        const newID = imported.sessionID
+
+        const session = yield* sessionRow(db, newID)
+        expect(session).toBeTruthy()
+        const acts = yield* activitiesOf(db, newID)
+        expect(acts.length).toBe(1)
+        // the active source activity is terminalized -> no active activity -> continuable
+        expect(acts.some((a: any) => a.state === "active")).toBe(false)
+        expect(acts[0].state).toBe("interrupted")
+        expect(acts[0].terminal_reason).toBe("imported_snapshot")
+        const msgs = yield* messagesOf(db, newID)
+        expect(msgs.length).toBe(2)
+      }),
+    )
+  })
+
+  it("rejects an invalid format/version", async () => {
+    const dbPath = join(tmpdir(), `snap-bad-${Date.now()}.sqlite`)
+    const snapshot = (await withDb(
+      dbPath,
+      Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        const srcID = "ses_src_bad"
+        yield* seedAuthority(db)
+        const { userMsg, asstMsg } = yield* seedConversation(db, srcID)
+        yield* seedActivity(db, srcID, asstMsg, userMsg)
+        return yield* exportSessionSnapshot(srcID)
+      }),
+    )) as SessionSnapshot
+
+    const badFormat = importSessionSnapshot({
+      snapshot: { ...snapshot, format: "other" as never },
+      projectID: PROJECT_ID,
+      directory: DIRECTORY,
+    })
+    await expect(withDb(dbPath, badFormat)).rejects.toBeTruthy()
+    const badVersion = importSessionSnapshot({
+      snapshot: { ...snapshot, format_version: 99 },
+      projectID: PROJECT_ID,
+      directory: DIRECTORY,
+    })
+    await expect(withDb(dbPath, badVersion)).rejects.toBeTruthy()
+  })
+})
diff --git a/packages/deepagent-code/src/session/activity-crash-test.ts b/packages/deepagent-code/src/session/activity-crash-test.ts
index 4602d9ef..e7a98dfb 100644
--- a/packages/deepagent-code/src/session/activity-crash-test.ts
+++ b/packages/deepagent-code/src/session/activity-crash-test.ts
@@ -11,6 +11,10 @@ export type Point =
   | "inside_revision_terminal_transaction"
   | "after_terminal_commit_before_publish"
   | "while_finalizing_before_follow_up_drain"
+  // BUG-407-008 §6.2 crash points (P1/P2/P6).
+  | "after_begin_progress_commit_before_provisional_event"
+  | "after_provisional_event_before_provider_dispatch"
+  | "after_progress_settle_before_next_admission"
 
 export function pause(point: Point) {
   if (process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_POINT !== point) return Effect.void
diff --git a/packages/deepagent-code/src/session/agent-handoff-consumer.ts b/packages/deepagent-code/src/session/agent-handoff-consumer.ts
index 1c70030b..6b64e25e 100644
--- a/packages/deepagent-code/src/session/agent-handoff-consumer.ts
+++ b/packages/deepagent-code/src/session/agent-handoff-consumer.ts
@@ -4,6 +4,7 @@ import { Cause, Context, Deferred, Duration, Effect, Layer, Option, Schedule, Sc
 import { AgentExecution } from "@deepagent-code/core/deepagent/agent-execution"
 import { DeepAgentEvent } from "@deepagent-code/core/deepagent/deepagent-event"
 import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
+import { HandoffAdmission } from "@deepagent-code/core/deepagent/handoff-admission"
 import { LMNEvents } from "@deepagent-code/core/deepagent/lmn-events"
 import { SecurityGate } from "@deepagent-code/core/deepagent/security-gate"
 import { SecurityResolvers } from "@deepagent-code/core/deepagent/security-resolvers"
@@ -19,6 +20,11 @@ export const DEFAULT_RETRY_PUMP_INTERVAL_MS = 30_000
 
 type Outcome = "accepted" | "rejected" | "ignored" | "retrying"
 type Handoff = Extract<DeepAgentEvent.AgentCoordinationEvent, { readonly type: "agent.handoff.requested" }>
+// FEAT-008: when the retry pump drives a redelivery it carries its claim identity — the claimant id
+// is stamped on the admission receipt, and the delivery is settled via the TOKEN-conditioned
+// ackClaim/nackClaim so a stale pump (lease lapsed, row re-claimed) can no longer settle a delivery
+// its successor already owns. The live-subscription path has no claim and keeps plain ack/nack.
+type Claim = { readonly claimantId: string; readonly claimToken: string }
 
 export interface Interface {
   readonly handle: (event: DeepAgentEvent.Event) => Effect.Effect<Outcome>
@@ -45,15 +51,35 @@ export const layerWith = (options?: LayerOptions) =>
     Effect.gen(function* () {
       const bus = yield* DeepAgentEventBus.Service
       const execution = yield* AgentExecution.Service
+      const admission = yield* HandoffAdmission.Service
       const agents = yield* AgentListProviderService
       const security = yield* SecurityResolvers.Service
       const flags = yield* RuntimeFlags.Service
       const runLoop = options?.runLoop ?? true
       const retryPumpIntervalMs = options?.retryPumpIntervalMs ?? DEFAULT_RETRY_PUMP_INTERVAL_MS
 
-      const ack = (event: DeepAgentEvent.Event) => bus.ack(HANDOFF_GROUP, event.id)
+      // Settle the (event, group) delivery. Under a claim the settle is TOKEN-conditioned: a false
+      // ackClaim means the lease lapsed and a successor claimant now owns the row — log and move on;
+      // the business side effects (accept/reject + receipt) are idempotent by construction.
+      const settleDelivery = (event: DeepAgentEvent.Event, claim?: Claim) =>
+        claim
+          ? bus
+              .ackClaim({ subscriptionGroup: HANDOFF_GROUP, eventID: event.id, claimToken: claim.claimToken })
+              .pipe(
+                Effect.tap((applied) =>
+                  applied
+                    ? Effect.void
+                    : Effect.sync(() =>
+                        log.warn("handoff delivery claim stale at ack; successor owns the row", {
+                          eventID: event.id,
+                        }),
+                      ),
+                ),
+                Effect.asVoid,
+              )
+          : bus.ack(HANDOFF_GROUP, event.id)
 
-      const reject = (event: DeepAgentEvent.Event, handoff: Handoff, reason: string) =>
+      const reject = (event: DeepAgentEvent.Event, handoff: Handoff, reason: string, claim?: Claim) =>
         execution
           .rejectHandoff({
             workspaceID: event.workspaceID,
@@ -65,27 +91,51 @@ export const layerWith = (options?: LayerOptions) =>
             toAgentID: handoff.toAgentID,
             reason,
           })
-          .pipe(Effect.andThen(ack(event)), Effect.as("rejected" as const))
+          .pipe(
+            // FEAT-008: terminal receipt — conditioned on state='processing', so a stale claimant can
+            // never flip a receipt its successor already settled.
+            Effect.andThen(admission.settle({ handoffID: handoff.handoffID, state: "rejected", reason })),
+            Effect.andThen(settleDelivery(event, claim)),
+            Effect.as("rejected" as const),
+          )
 
-      const process = (event: DeepAgentEvent.Event) =>
+      const process = (event: DeepAgentEvent.Event, claim?: Claim) =>
         Effect.gen(function* () {
           const handoff = decodeHandoff(event)
           if (!handoff || event.source !== "system") {
-            yield* ack(event)
+            yield* settleDelivery(event, claim)
             return "ignored" as const
           }
+          // FEAT-008 durable admission receipt: stamped `processing` BEFORE any side-effecting
+          // decision, so a crash mid-handling leaves a durable "not finished" marker instead of
+          // "事件即状态". A terminal receipt returned here means this handoff already settled —
+          // short-circuit (ack only, never re-run accept/reject).
+          const receipt = yield* admission.begin({
+            handoffID: handoff.handoffID,
+            eventID: event.id,
+            workspaceID: event.workspaceID,
+            claimantID: claim?.claimantId ?? "agent-handoff-consumer:live",
+          })
+          if (receipt.state === "accepted") {
+            yield* settleDelivery(event, claim)
+            return "accepted" as const
+          }
+          if (receipt.state === "rejected") {
+            yield* settleDelivery(event, claim)
+            return "rejected" as const
+          }
           if (!flags.v4MultiAgentRuntime) {
-            return yield* reject(event, handoff, "handoff_flag_disabled")
+            return yield* reject(event, handoff, "handoff_flag_disabled", claim)
           }
 
           const original = yield* bus.getByID(handoff.eventID)
           if (!original || original.workspaceID !== event.workspaceID) {
-            return yield* reject(event, handoff, "handoff_original_event_missing")
+            return yield* reject(event, handoff, "handoff_original_event_missing", claim)
           }
           const subtask = TaskPartitioner.partition(original, { stableIDPrefix: original.id }).subtasks.find(
             (candidate) => candidate.id === handoff.taskID,
           )
-          if (!subtask) return yield* reject(event, handoff, "handoff_task_missing")
+          if (!subtask) return yield* reject(event, handoff, "handoff_task_missing", claim)
 
           const registry = yield* agents.listAgents({
             workspaceID: original.workspaceID,
@@ -94,7 +144,7 @@ export const layerWith = (options?: LayerOptions) =>
           const target = TaskPartitioner.capableAgents(subtask, registry).find(
             (candidate) => candidate.id === handoff.toAgentID,
           )
-          if (!target) return yield* reject(event, handoff, "handoff_target_not_capable")
+          if (!target) return yield* reject(event, handoff, "handoff_target_not_capable", claim)
 
           const trusted = yield* security.resolveTrustedSources(original.workspaceID)
           const actorAllowed = yield* security.actorHasWorkspacePermission({
@@ -114,7 +164,7 @@ export const layerWith = (options?: LayerOptions) =>
             requiredCapability: subtask.capability,
             runtimeAllowed,
           })
-          if (!gate.allowed) return yield* reject(event, handoff, `handoff_security_${gate.failedLayer}`)
+          if (!gate.allowed) return yield* reject(event, handoff, `handoff_security_${gate.failedLayer}`, claim)
 
           const accepted = yield* execution.acceptHandoff({
             workspaceID: event.workspaceID,
@@ -135,9 +185,10 @@ export const layerWith = (options?: LayerOptions) =>
               current?.handoffID === handoff.handoffID &&
               (current.status === "available" || current.status === "running" || current.status === "completed") &&
               (current.assignedAgentID === handoff.toAgentID || current.agentID === handoff.toAgentID)
-            if (!alreadyAccepted) return yield* reject(event, handoff, "handoff_state_mismatch")
+            if (!alreadyAccepted) return yield* reject(event, handoff, "handoff_state_mismatch", claim)
           }
-          yield* ack(event)
+          yield* admission.settle({ handoffID: handoff.handoffID, state: "accepted" })
+          yield* settleDelivery(event, claim)
           return "accepted" as const
         })
 
@@ -156,15 +207,42 @@ export const layerWith = (options?: LayerOptions) =>
 
       const pumpRetries: Interface["pumpRetries"] = (now) =>
         Effect.gen(function* () {
-          const due = yield* bus.dueRetries(now)
-          const owned = due.filter((delivery) => delivery.subscriptionGroup === HANDOFF_GROUP)
+          // RISK-001 / FEAT-008: claim due rows before executing so two processes (Desktop + CLI
+          // daemon, or an upgrade overlap) can never re-drive the same handoff retry concurrently.
+          // Success settles via the token-conditioned ackClaim (inside process); failure settles via
+          // the token-conditioned nackClaim below — a stale token is a no-op, so a claimant whose
+          // lease lapsed can never settle a delivery its successor already owns.
+          // `process` is shadowed by the local handler in this module — mint a unique claimant id.
+          const claimantId = `agent-handoff-consumer:${crypto.randomUUID()}`
+          const claim = yield* bus.claimDue({
+            subscriptionGroup: HANDOFF_GROUP,
+            claimantId,
+            now,
+          })
           yield* Effect.forEach(
-            owned,
+            claim.deliveries,
             (delivery) =>
-              bus.getByID(delivery.eventID).pipe(Effect.flatMap((event) => (event ? handle(event) : Effect.void))),
+              bus.getByID(delivery.eventID).pipe(
+                Effect.flatMap((event) =>
+                  event
+                    ? process(event, { claimantId, claimToken: claim.claimToken }).pipe(
+                        Effect.catchCause((cause) =>
+                          bus
+                            .nackClaim({
+                              subscriptionGroup: HANDOFF_GROUP,
+                              eventID: event.id,
+                              claimToken: claim.claimToken,
+                              reason: `handoff consumer failure: ${Cause.pretty(cause)}`,
+                            })
+                            .pipe(Effect.as("retrying" as const)),
+                        ),
+                      )
+                    : Effect.void,
+                ),
+              ),
             { discard: true },
           )
-          return owned.length
+          return claim.deliveries.length
         })
 
       if (runLoop) {
diff --git a/packages/deepagent-code/src/session/compaction-sql.ts b/packages/deepagent-code/src/session/compaction-sql.ts
index a98d5a24..2316a9d3 100644
--- a/packages/deepagent-code/src/session/compaction-sql.ts
+++ b/packages/deepagent-code/src/session/compaction-sql.ts
@@ -1,7 +1,12 @@
 // BUG-005: drizzle-orm type bindings for compaction_run and compaction_summary_attempt.
 import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
+import { SessionTable } from "@deepagent-code/core/session/sql"
 
 export type CompactionRunState = "requested" | "summarizing" | "committed" | "failed" | "indeterminate"
+// UPD-005 Gap 2: how a run compacted. 'local_summary' is the default/historical
+// path (TEXT summary committed); 'remote_compact' commits an opaque server-held
+// encrypted context instead (summary_text stays NULL — information-hole exempt).
+export type CompactionMode = "local_summary" | "remote_compact"
 export type CompactionContinuationState =
   | "pending"
   | "admitted"
@@ -52,6 +57,28 @@ export const CompactionRunTable = sqliteTable("compaction_run", {
   continuation_dispatching_at: integer(),
   continuation_terminal_at: integer(),
   continuation_error_code: text(),
+  // UPD-005 Gap 2 (migration 20260820000000_remote_compact_persistence).
+  compaction_mode: text().$type<CompactionMode>().notNull().default("local_summary"),
+  // Remote mode only: points at session_compaction_encrypted_content.session_id.
+  encrypted_content_session: text(),
+})
+
+// UPD-005 Gap 1: the ONE currently-valid `/responses/compact` encrypted context per
+// session (1:1; the write path upserts so only the latest blob survives). The blob
+// is cross-run / session-scoped — replayed on the next compaction — hence its own
+// table instead of a compaction_run column. provider_id is the same-provenance
+// guard checked before replay; session deletion cascades.
+export const SessionCompactionEncryptedContentTable = sqliteTable("session_compaction_encrypted_content", {
+  session_id: text()
+    .primaryKey()
+    .notNull()
+    .references(() => SessionTable.id, { onDelete: "cascade" }),
+  encrypted_content: text().notNull(),
+  provider_id: text().notNull(),
+  model_id: text(),
+  source_run_id: text(),
+  created_at: integer().notNull(),
+  updated_at: integer().notNull(),
 })
 
 export const CompactionSummaryAttemptTable = sqliteTable("compaction_summary_attempt", {
diff --git a/packages/deepagent-code/src/session/compaction.ts b/packages/deepagent-code/src/session/compaction.ts
index 2f385dae..899d0f61 100644
--- a/packages/deepagent-code/src/session/compaction.ts
+++ b/packages/deepagent-code/src/session/compaction.ts
@@ -24,8 +24,11 @@ import {
   CompactionArtifactTable,
   CompactionRunTable,
   CompactionSummaryAttemptTable,
+  type CompactionMode,
   type SummaryAttemptState,
 } from "./compaction-sql"
+import { attemptRemoteCompaction, EncryptedContentStore, supportsRemoteCompaction } from "./remote-compact"
+import { RequestExecutor } from "@deepagent-code/llm/route"
 import { eq, and, inArray, isNull } from "drizzle-orm"
 
 import { Cause, Effect, Exit, Layer, Context, Option } from "effect"
@@ -40,7 +43,7 @@ import { SessionMessage } from "@deepagent-code/core/session/message"
 import { ProviderV2 } from "@deepagent-code/core/provider"
 import { ModelV2 } from "@deepagent-code/core/model"
 import { EventV2 } from "@deepagent-code/core/event"
-import { buildPrompt } from "@deepagent-code/core/session/compaction"
+import { buildPrompt, TOOL_OUTPUT_MAX_CHARS } from "@deepagent-code/core/session/compaction"
 import {
   updateLedgerFromSummaryRequired,
   carryOverToBridgeRequired,
@@ -68,11 +71,172 @@ export const Event = {
 
 export const PRUNE_MINIMUM = 20_000
 export const PRUNE_PROTECT = 40_000
-const TOOL_OUTPUT_MAX_CHARS = 2_000
+// UPD-005 (micro-compact, safe subset): the protect window used when the soft-landing fallback
+// phase triggers an early prune. Smaller than PRUNE_PROTECT so the fallback phase truncates MORE
+// of the older (white-list-excluded) tool results in place, buying headroom before the hard line.
+// Never wired into the hard phase — hard keeps PRUNE_PROTECT semantics unchanged.
+export const MICRO_COMPACT_PROTECT = 10_000
+// UPD-005: TOOL_OUTPUT_MAX_CHARS is defined once in core (packages/core/src/session/compaction.ts)
+// and imported above — do NOT re-introduce a local copy here.
 const PRUNE_PROTECTED_TOOLS = ["skill"]
 const DEFAULT_TAIL_TURNS = 2
 const MIN_PRESERVE_RECENT_TOKENS = 2_000
 const MAX_PRESERVE_RECENT_TOKENS = 8_000
+
+// =============================================================================
+// UPD-005 (structured compaction summary, claude-code parity, safe subset).
+// =============================================================================
+// DETERMINISM CONTRACT: the template constants and the pure helpers below
+// (stripSummaryAnalysis / selectPostCompactFileCandidates) are pure functions —
+// same input, same output. The durable summary-attempt requestHash covers the
+// rendered prompt, so the template MUST stay a module-level constant.
+//
+// Scope: the structured nine-section template replaces the legacy anchored
+// summary ONLY on the worldStateReinjection=false compatibility path. With
+// worldStateReinjection=true the V4.0.1 four-bucket NARROW template stays
+// byte-for-byte unchanged — its responsibility separation (files / env /
+// diagnostics are World State re-injected at their LATEST value, never
+// summarized) is an information-hole invariant (§3.4/§3.5).
+//
+// The model drafts inside an <analysis> scratchpad first; stripSummaryAnalysis
+// removes that scratchpad and unwraps the <summary> envelope BEFORE the text
+// reaches any durable or projected surface. The text-only / no-tools protocol
+// (toolChoice:"none" + SummaryProtocolViolation enforcement) is unchanged.
+export const STRUCTURED_SUMMARY_TEMPLATE = `Your task is to create a detailed, structured summary of the conversation history above, paying close attention to the user's explicit requests and your previous actions. This summary must capture enough technical detail — decisions, code patterns, file context, and error history — for the work to continue without losing context.
+
+Respond with TEXT ONLY. Do not call any tools. Your entire response must be an <analysis> block followed by a <summary> block.
+
+Before writing the final summary, wrap your drafting analysis in <analysis> tags to organize your thoughts and verify coverage. In the analysis:
+1. Walk the conversation chronologically and identify the user's explicit requests, your approach, key decisions, technical concepts, file names, code snippets, errors and their fixes, and any user feedback — especially feedback that changed your direction.
+2. Note every security-relevant instruction or constraint the user stated (sensitive files or data to avoid, forbidden operations, credential/secret handling rules). These MUST be preserved VERBATIM in the final summary so they keep applying after compaction.
+3. Double-check technical accuracy and completeness. The <analysis> block is discarded after compaction — only the <summary> block survives.
+
+Inside <summary>, output exactly these nine numbered sections in this order:
+
+1. Primary Request and Intent: all of the user's explicit requests and intents, in detail.
+2. Key Technical Concepts: important concepts, technologies, and frameworks discussed.
+3. Files and Code Sections: files examined, modified, or created — why each matters, what changed, and important code snippets verbatim.
+4. Errors and Fixes: every error encountered and how it was fixed, including corrective user feedback.
+5. Problem Solving: problems solved and ongoing troubleshooting.
+6. All User Messages: every genuine user message (user-role turns only, never tool results or quoted assistant text), with security-relevant instructions preserved verbatim.
+7. Pending Tasks: tasks explicitly requested but not yet complete.
+8. Current Work: precisely what was in progress immediately before this summary request, with file names and code snippets where applicable.
+9. Next Steps: the next action, only when directly in line with the user's most recent explicit request; include a verbatim quote showing where the work left off. Write "(none)" if the last task concluded.
+
+Rules:
+- Keep every section, using "(none)" when a section is empty.
+- Preserve exact file paths, commands, error strings, identifiers, and user-designated durable facts verbatim.
+- Never attribute assistant-generated text to the user.
+- Do not mention the summary process or that context was compacted.
+
+<example>
+<analysis>
+[Drafting scratchpad: chronological coverage check]
+</analysis>
+
+<summary>
+1. Primary Request and Intent:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+
+3. Files and Code Sections:
+   - [File path]
+     - Why it matters / changes made
+     - [Important code snippet]
+
+4. Errors and Fixes:
+   - [Error and the fix applied]
+
+5. Problem Solving:
+   - [Solved problems and ongoing troubleshooting]
+
+6. All User Messages:
+   - [User message content]
+
+7. Pending Tasks:
+   - [Task]
+
+8. Current Work:
+   - [Precise description]
+
+9. Next Steps:
+   - [Next step or "(none)"]
+</summary>
+</example>`
+
+// Mirrors the core buildPrompt composition (packages/core/src/session/compaction.ts)
+// with the structured template swapped in. Keep the preamble wording in sync with
+// the core builder — the anchored-summary update contract depends on it.
+export const buildStructuredSummaryPrompt = (input: {
+  readonly previousSummary?: string
+  readonly context: readonly string[]
+}) =>
+  [
+    input.previousSummary
+      ? `Update the anchored summary below using the conversation history above.\nPreserve still-true details, remove stale details, and merge in the new facts.\n<previous-summary>\n${input.previousSummary}\n</previous-summary>`
+      : "Create a new anchored summary from the conversation history.",
+    STRUCTURED_SUMMARY_TEMPLATE,
+    ...input.context,
+  ].join("\n\n")
+
+// Post-processing: strip the <analysis> drafting scratchpad and unwrap the
+// <summary> envelope. Pure and conservative — text without any <analysis> /
+// <summary> marker is returned byte-for-byte unchanged (legacy summaries and
+// NARROW outputs are untouched).
+export const stripSummaryAnalysis = (text: string): string => {
+  if (!/<\/?(?:analysis|summary)>/.test(text)) return text
+  let out = text.replace(/<analysis>[\s\S]*?<\/analysis>/g, "")
+  out = out.replace(/<summary>([\s\S]*?)<\/summary>/g, (_match, content: string) => `Summary:\n${content.trim()}`)
+  out = out.replace(/\n{3,}/g, "\n\n")
+  return out.trim()
+}
+
+// UPD-005 (post-compact re-injection hook, conservative version): claude-code
+// re-injects the most recently read files after compaction
+// (POST_COMPACT_MAX_FILES_TO_RESTORE = 5). The committed-history chain here has
+// NO injection point yet, so this module only SELECTS candidates — a pure
+// function of the compacted messages (same input ⇒ same output) — recorded for
+// future wiring. Never adds an injection path.
+export const POST_COMPACT_MAX_FILES_TO_RESTORE = 5
+export const POST_COMPACT_MAX_CHARS_PER_FILE = 20_000
+const POST_COMPACT_READ_TOOLS = new Set(["read"])
+
+export type PostCompactFileCandidate = {
+  readonly filePath: string
+  readonly tool: string
+  readonly messageID: MessageID
+}
+
+// Scans backwards (most recent read wins), deduplicates by path, caps at
+// POST_COMPACT_MAX_FILES_TO_RESTORE. Only completed reads count; a pending /
+// errored read does not prove the file content ever entered context.
+export const selectPostCompactFileCandidates = (
+  messages: readonly SessionV1.WithParts[],
+): readonly PostCompactFileCandidate[] => {
+  const seen = new Set<string>()
+  const candidates: PostCompactFileCandidate[] = []
+  for (let index = messages.length - 1; index >= 0 && candidates.length < POST_COMPACT_MAX_FILES_TO_RESTORE; index--) {
+    const message = messages[index]
+    for (let partIndex = message.parts.length - 1; partIndex >= 0; partIndex--) {
+      if (candidates.length >= POST_COMPACT_MAX_FILES_TO_RESTORE) break
+      const part = message.parts[partIndex]
+      if (part.type !== "tool" || part.state.status !== "completed") continue
+      if (!POST_COMPACT_READ_TOOLS.has(part.tool)) continue
+      const input: unknown = part.state.input
+      let filePath: string | undefined
+      if (typeof input === "object" && input !== null) {
+        const value = (input as Record<string, unknown>).filePath
+        if (typeof value === "string" && value.length > 0) filePath = value
+      }
+      if (!filePath || seen.has(filePath)) continue
+      seen.add(filePath)
+      candidates.push({ filePath, tool: part.tool, messageID: message.info.id })
+    }
+  }
+  return candidates
+}
 type Turn = {
   start: number
   end: number
@@ -148,7 +312,7 @@ export interface Interface {
     tokens: SessionV1.Assistant["tokens"]
     model: Provider.Model
   }) => Effect.Effect<boolean>
-  readonly prune: (input: { sessionID: SessionID }) => Effect.Effect<void>
+  readonly prune: (input: { sessionID: SessionID; protect?: number }) => Effect.Effect<void>
   readonly process: (input: {
     parentID: MessageID
     messages: SessionV1.WithParts[]
@@ -165,6 +329,11 @@ export interface Interface {
     activityID?: string
   }) => Effect.Effect<void>
   readonly recover: (sessionID: SessionID) => Effect.Effect<void>
+  // BUG-407-009 §10.1 fail-closed contract: when a committed compaction continuation cannot be
+  // recovered (the recovery capability itself is a Maintenance-milestone deliverable), the run must
+  // stop advertising itself as recoverable — otherwise instance initialization re-wakes it forever
+  // and floods the log. CAS pending/admitted/dispatching → failed; real recovery can revisit later.
+  readonly failContinuationClosed: (input: { runID: string }) => Effect.Effect<void>
   readonly recoverableContinuations: (projectID: Project.ID) => Effect.Effect<
     readonly {
       runID: string
@@ -231,6 +400,18 @@ export const validateReplacementTargetInTransaction = Effect.fn(
 
 export class Service extends Context.Service<Service, Interface>()("@deepagent-code/SessionCompaction") {}
 
+// UPD-005 Gap 2 (§4.2, information-hole exemption): a committed run that compacted
+// remotely carries no TEXT summary by design — "no information is lost" is guaranteed
+// by the provider's server-held encrypted context, not by text. Any check that treats
+// a missing summary_text as an information hole MUST exempt runs in this shape.
+export const remoteCompactionInformationHoleExempt = (run: {
+  readonly compaction_mode: CompactionMode | null
+  readonly encrypted_content_session: string | null
+}): boolean =>
+  run.compaction_mode === "remote_compact" &&
+  run.encrypted_content_session !== null &&
+  run.encrypted_content_session.length > 0
+
 export const use = serviceUse(Service)
 
 export const layer = Layer.effect(
@@ -245,6 +426,13 @@ export const layer = Layer.effect(
     const events = yield* EventV2Bridge.Service
     const flags = yield* RuntimeFlags.Service
     const { db } = yield* Database.Service
+    // UPD-005 Gap 2: the remote branch dispatches through the route executor.
+    const executor = yield* RequestExecutor.Service
+    // UPD-005 Gap 1: bind the encrypted_content store to this database so the
+    // opaque blob survives restarts (see remote-compact.ts). Revert to memory-only
+    // mode when this layer goes away so no closed handle stays reachable.
+    EncryptedContentStore.bind(db)
+    yield* Effect.addFinalizer(() => Effect.sync(() => EncryptedContentStore.bind(undefined)))
     const promptEpoch = yield* PromptEpoch.Service
     const activeCompactions = new Set<SessionID>()
 
@@ -981,6 +1169,60 @@ export const layer = Layer.effect(
         .pipe(Effect.orDie)
     })
 
+    // UPD-005 Gap 2 (§4.2): commit for the remote mode. There is no TEXT summary
+    // and no marker text part to commit — the run records the mode, the pointer to
+    // the durably stored encrypted_content, and transitions to 'committed'.
+    // summary_text stays NULL by design (information-hole exempt, see
+    // remoteCompactionInformationHoleExempt).
+    const commitRemoteRun = Effect.fn("SessionCompaction.commitRemoteRun")(function* (input: {
+      runID: string
+      sessionID: SessionID
+      reason: "auto" | "manual"
+    }) {
+      return yield* db
+        .transaction(
+          (tx) =>
+            Effect.gen(function* () {
+              // The authority trigger only admits requested → summarizing →
+              // committed, so advance the run through the same sequence the local
+              // path uses.
+              yield* tx
+                .update(CompactionRunTable)
+                .set({ state: "summarizing" })
+                .where(and(eq(CompactionRunTable.run_id, input.runID), eq(CompactionRunTable.state, "requested")))
+                .run()
+              const committed = yield* tx
+                .update(CompactionRunTable)
+                .set({
+                  state: "committed",
+                  compaction_mode: "remote_compact",
+                  encrypted_content_session: input.sessionID,
+                  completion_reason: input.reason,
+                  committed_at: Date.now(),
+                })
+                .where(and(eq(CompactionRunTable.run_id, input.runID), eq(CompactionRunTable.state, "summarizing")))
+                .returning({ run_id: CompactionRunTable.run_id })
+                .get()
+              if (!committed) return false
+              // A remote run has nothing publishable: orphan any pending run
+              // bookkeeping artifacts (mirrors failRun) so recovery never replays them.
+              yield* tx
+                .update(CompactionArtifactTable)
+                .set({ state: "orphaned" })
+                .where(
+                  and(
+                    eq(CompactionArtifactTable.run_id, input.runID),
+                    eq(CompactionArtifactTable.state, "pending"),
+                  ),
+                )
+                .run()
+              return true
+            }),
+          { behavior: "immediate" },
+        )
+        .pipe(Effect.orDie)
+    })
+
     const isOverflow = Effect.fn("SessionCompaction.isOverflow")(function* (input: {
       tokens: SessionV1.Assistant["tokens"]
       model: Provider.Model
@@ -1043,12 +1285,24 @@ export const layer = Layer.effect(
       }
     })
 
-    // goes backwards through parts until there are PRUNE_PROTECT tokens worth of tool
-    // calls, then erases output of older tool calls to free context space
-    const prune = Effect.fn("SessionCompaction.prune")(function* (input: { sessionID: SessionID }) {
+    // goes backwards through parts until there are `protect` tokens worth of tool
+    // calls, then erases output of older tool calls to free context space.
+    // UPD-005: `protect` is parameterized (default PRUNE_PROTECT = pre-existing behavior) so the
+    // soft-landing fallback phase can run a micro-compact with a smaller window. DETERMINISM
+    // CONTRACT: the truncated set is a pure function of (messages, protect, PRUNE_MINIMUM) — the
+    // scan is strictly backwards, Token.estimate is pure, and only `Date.now()` (the persisted
+    // time.compacted stamp) varies between runs without ever changing WHICH parts get truncated.
+    // The durable summary-attempt requestHash is computed over the compacted projection, so any
+    // non-determinism here would desync compaction replays. Idempotency: parts already stamped
+    // with time.compacted break the scan, so a repeated prune never double-truncates.
+    const prune = Effect.fn("SessionCompaction.prune")(function* (input: {
+      sessionID: SessionID
+      protect?: number
+    }) {
       const cfg = yield* config.get()
       if (!cfg.compaction?.prune) return
-      log.info("pruning")
+      const protect = input.protect ?? PRUNE_PROTECT
+      log.info("pruning", { protect })
 
       const msgs = yield* session
         .messages({ sessionID: input.sessionID })
@@ -1073,7 +1327,7 @@ export const layer = Layer.effect(
           if (part.state.time.compacted) break loop
           const estimate = Token.estimate(part.state.output)
           total += estimate
-          if (total <= PRUNE_PROTECT) continue
+          if (total <= protect) continue
           pruned += estimate
           toPrune.push(part)
         }
@@ -1150,6 +1404,59 @@ export const layer = Layer.effect(
         sourceProjectionVersion: projection.projectionVersion,
       })
       if (!run) return "stop"
+
+      const agent = yield* agents.get("compaction")
+      const model = agent.model
+        ? yield* provider.getModel(agent.model.providerID, agent.model.modelID).pipe(Effect.orDie)
+        : yield* provider.getModel(userMessage.model.providerID, userMessage.model.modelID).pipe(Effect.orDie)
+
+      // UPD-005 Gap 2 (§4.2/§5): server-side compaction branch — remote only. The
+      // capability probe runs BEFORE any marker part is written: a remote commit
+      // produces no TEXT summary and no marker text part. {used:"local"} falls
+      // through to the local summary path below, which stays byte-for-byte unchanged.
+      if (!supportsRemoteCompaction(model)) {
+        // §4.3: capability lost (e.g. model switch) — the stale blob must never be replayed.
+        EncryptedContentStore.clear(input.sessionID)
+      }
+      if (supportsRemoteCompaction(model)) {
+        const providerInfo = yield* provider.getProvider(model.providerID).pipe(Effect.orDie)
+        const remoteMessages = yield* MessageV2.toModelMessagesEffect([...input.messages], model, {
+          stripMedia: true,
+          toolOutputMaxChars: TOOL_OUTPUT_MAX_CHARS,
+        })
+        const outcome = yield* attemptRemoteCompaction({
+          sessionID: input.sessionID,
+          model,
+          provider: providerInfo,
+          auth: undefined,
+          messages: remoteMessages,
+        }).pipe(Effect.provideService(RequestExecutor.Service, executor))
+        if (outcome.used === "remote") {
+          EncryptedContentStore.set(input.sessionID, outcome.encryptedContent, {
+            providerID: model.providerID,
+            modelID: model.id,
+            sourceRunID: run.run_id,
+          })
+          const committed = yield* commitRemoteRun({
+            runID: run.run_id,
+            sessionID: input.sessionID,
+            reason: input.auto ? "auto" : "manual",
+          })
+          if (!committed) {
+            yield* failRun(run.run_id, "compaction_commit_conflict")
+            return "stop"
+          }
+          log.info("remote compaction committed", { runID: run.run_id, sessionID: input.sessionID })
+          return "stop"
+        }
+        // {used:"local"}: record why the server-side path was unavailable (§4.2),
+        // then the existing local summary path below takes over.
+        log.info("remote compaction unavailable, using local summary", {
+          runID: run.run_id,
+          reason: outcome.reason,
+        })
+      }
+
       if (existingCompactionPart) {
         yield* registerArtifact({
           runID: run.run_id,
@@ -1182,10 +1489,6 @@ export const layer = Layer.effect(
       // messages, which are indistinguishable from a real repeated prompt in the UI and history.
       const messages = input.messages
 
-      const agent = yield* agents.get("compaction")
-      const model = agent.model
-        ? yield* provider.getModel(agent.model.providerID, agent.model.modelID).pipe(Effect.orDie)
-        : yield* provider.getModel(userMessage.model.providerID, userMessage.model.modelID).pipe(Effect.orDie)
       const cfg = yield* config.get()
       const history = compactionPart && messages.at(-1)?.info.id === input.parentID ? messages.slice(0, -1) : messages
       const prior = completedCompactions(history)
@@ -1204,10 +1507,14 @@ export const layer = Layer.effect(
       )
       // V4.0.1 P1 (§3.4/§3.5): narrow the summary to four buckets ONLY when worldStateReinjection is on —
       // it MUST be the same flag that gates re-injection, else "summary drops files, nothing re-injects"
-      // opens an information hole. Flag OFF ⇒ legacy SUMMARY_TEMPLATE, byte-for-byte pre-V4.0.1.
+      // opens an information hole. Flag OFF ⇒ UPD-005 structured nine-section template (the pre-UPD-005
+      // legacy SUMMARY_TEMPLATE lived in core buildPrompt; the structured template supersedes it on this
+      // compatibility path only). Flag ON ⇒ NARROW template, byte-for-byte unchanged.
       const nextPrompt =
         compacting.prompt ??
-        buildPrompt({ previousSummary, context: compacting.context, narrow: flags.worldStateReinjection })
+        (flags.worldStateReinjection
+          ? buildPrompt({ previousSummary, context: compacting.context, narrow: true })
+          : buildStructuredSummaryPrompt({ previousSummary, context: compacting.context }))
       const msgs = structuredClone(selected.head)
       yield* plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
       const modelMessages = yield* MessageV2.toModelMessagesEffect(msgs, model, {
@@ -1441,15 +1748,40 @@ export const layer = Layer.effect(
       if (result.action === "continue") {
         const persisted = yield* session.messages({ sessionID: input.sessionID }).pipe(Effect.orDie)
         const checkpointIndex = persisted.findIndex((item) => item.info.id === currentProcessor.message.id)
-        const checkpoint = persisted[checkpointIndex] ?? {
+        let checkpoint = persisted[checkpointIndex] ?? {
           info: msg,
           parts: [],
         }
-        const summary = summaryText(checkpoint)
+        // UPD-005: strip the <analysis> drafting scratchpad before the summary enters ANY durable or
+        // projected surface. The persisted text parts are rewritten FIRST so HistoryAuthority hashes,
+        // the commit validation (which re-hydrates from the DB), and the post-compaction projection all
+        // see the stripped text. stripSummaryAnalysis is a pure function and returns tag-free input
+        // byte-for-byte unchanged, so pre-UPD-005 summaries are unaffected.
+        const rawSummary = summaryText(checkpoint)
+        const summary = rawSummary ? stripSummaryAnalysis(rawSummary) : undefined
         if (!summary) {
+          // Information-hole gate: a local_summary run MUST commit text. Remote runs
+          // never reach this checkpoint (they commit earlier via commitRemoteRun) and
+          // are exempt per remoteCompactionInformationHoleExempt — their NULL
+          // summary_text is legal because the server-held encrypted context, not
+          // text, guarantees no information is lost (§4.2).
           yield* failRun(run.run_id, "summary_text_missing")
           return "stop"
         }
+        if (summary !== rawSummary) {
+          const textParts = checkpoint.parts.filter((part): part is SessionV1.TextPart => part.type === "text")
+          const strippedParts = checkpoint.parts.map((part) => {
+            if (part.type !== "text") return part
+            return part.id === textParts[0]?.id ? { ...part, text: summary } : { ...part, text: "" }
+          })
+          for (const part of strippedParts) {
+            if (part.type !== "text") continue
+            const original = checkpoint.parts.find((item): item is SessionV1.TextPart => item.id === part.id)
+            if (original && original.text === part.text) continue
+            yield* session.updatePart(part)
+          }
+          checkpoint = { info: checkpoint.info, parts: strippedParts }
+        }
         if (summary) {
           const contextModel = yield* provider
             .getModel(userMessage.model.providerID, userMessage.model.modelID)
@@ -1533,6 +1865,19 @@ export const layer = Layer.effect(
             yield* failRun(run.run_id, "compaction_commit_conflict")
             return "stop"
           }
+          // UPD-005 (post-compact re-injection hook, conservative version): record the candidate list of
+          // recently-read files from the compacted head ONLY. There is no injection point in the committed
+          // chain yet, so nothing is re-injected here. Persisting the list on compaction_run would require
+          // a core-owned schema migration (out of scope) — recorded as a report item for future wiring.
+          const postCompactCandidates = selectPostCompactFileCandidates(selected.head)
+          if (postCompactCandidates.length > 0)
+            log.info("post-compact file candidates", {
+              runID: run.run_id,
+              count: postCompactCandidates.length,
+              maxFiles: POST_COMPACT_MAX_FILES_TO_RESTORE,
+              maxCharsPerFile: POST_COMPACT_MAX_CHARS_PER_FILE,
+              files: postCompactCandidates.map((candidate) => candidate.filePath),
+            })
           yield* publishCommittedRun(run.run_id)
         }
       }
@@ -1680,12 +2025,29 @@ export const layer = Layer.effect(
       }))
     })
 
+    const failContinuationClosed = Effect.fn("SessionCompaction.failContinuationClosed")(function* (input: {
+      runID: string
+    }) {
+      yield* db
+        .update(CompactionRunTable)
+        .set({ continuation_state: "failed" })
+        .where(
+          and(
+            eq(CompactionRunTable.run_id, input.runID),
+            inArray(CompactionRunTable.continuation_state, ["pending", "admitted", "dispatching"] as const),
+          ),
+        )
+        .run()
+        .pipe(Effect.orDie)
+    })
+
     return Service.of({
       isOverflow,
       prune,
       process: processCompaction,
       create,
       recover,
+      failContinuationClosed,
       recoverableContinuations,
       hasPending,
     })
@@ -1704,6 +2066,7 @@ export const defaultLayer = Layer.suspend(() =>
     Layer.provide(EventV2Bridge.defaultLayer),
     Layer.provide(Database.defaultLayer),
     Layer.provide(PromptEpoch.defaultLayer),
+    Layer.provide(RequestExecutor.defaultLayer),
   ),
 )
 
diff --git a/packages/deepagent-code/src/session/diff-artifact.ts b/packages/deepagent-code/src/session/diff-artifact.ts
index d4c8983b..0d03e58f 100644
--- a/packages/deepagent-code/src/session/diff-artifact.ts
+++ b/packages/deepagent-code/src/session/diff-artifact.ts
@@ -1,5 +1,6 @@
 import { Database } from "@deepagent-code/core/database/database"
-import { EventArtifactChunkTable, EventArtifactTable } from "@deepagent-code/core/event/sql"
+import { EventV2 } from "@deepagent-code/core/event"
+import { EventArtifactChunkTable, EventArtifactTable, EventTable } from "@deepagent-code/core/event/sql"
 import { MessageTable, SessionPromptEpochMessageTable, SessionTable } from "@deepagent-code/core/session/sql"
 import { CanonicalJson } from "@deepagent-code/core/util/canonical-json"
 import { Hash } from "@deepagent-code/core/util/hash"
@@ -543,6 +544,289 @@ function migrateBoundedCandidate(db: Database.Interface["db"], candidate: Candid
     )
 }
 
+/**
+ * RISK-003 ① runtime writer. Persists the inline `summary.diffs` of a just-published user message
+ * into the session_diff_artifact authority and rewrites the message row to the compact
+ * `diffArtifact` descriptor, so runtime writes converge on the same durable shape the backfill
+ * (`migrate`) produces for legacy rows. Runs AFTER the message.updated event is committed (the
+ * event row supplies `source_event_id` + `original_data_hash`) and is best-effort: any validation
+ * or CAS failure leaves the bounded inline diffs in place and surfaces as a typed `Invalid` the
+ * caller logs. Never deletes events, never rewrites history hashes (user summary is excluded from
+ * HistoryAuthority, proven per call via `validateEpochHashes`).
+ */
+export const capture = Effect.fn("SessionDiffArtifact.capture")(function* (input: {
+  sessionID: SessionID
+  messageID: MessageID
+  sourceEventID: EventV2.ID
+  now?: number
+}) {
+  const { db } = yield* Database.Service
+  const now = input.now ?? Date.now()
+  const source = yield* db
+    .select({ text: sql<string>`CAST(${EventTable.data} AS TEXT)`, seq: EventTable.seq })
+    .from(EventTable)
+    .where(and(eq(EventTable.id, input.sourceEventID), eq(EventTable.aggregate_id, input.sessionID)))
+    .get()
+    .pipe(Effect.orDie)
+  if (!source) return yield* Effect.fail(new Invalid({ message: "runtime capture source event is missing" }))
+  const current = yield* db
+    .get<{ data: string }>(sql`
+      SELECT CAST(data AS TEXT) AS data
+      FROM message
+      WHERE id = ${input.messageID}
+        AND session_id = ${input.sessionID}
+        AND json_extract(data, '$.role') = 'user'
+    `)
+    .pipe(Effect.orDie)
+  if (!current) return yield* Effect.fail(new Invalid({ message: "runtime capture message is missing" }))
+  const decoded = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(current.data)
+  const parsed = decoded._tag === "Some" ? decoded.value : undefined
+  if (!record(parsed) || parsed.role !== "user")
+    return yield* Effect.fail(new Invalid({ message: "runtime capture message shape is invalid" }))
+  const summary = record(parsed.summary) ? parsed.summary : undefined
+  if (!summary) return yield* Effect.fail(new Invalid({ message: "runtime capture message shape is invalid" }))
+  if (summary.diffArtifact) return { state: "skipped" as const }
+  const diffs = summary.diffs
+  if (!Array.isArray(diffs) || diffs.length === 0) return { state: "skipped" as const }
+  if (diffs.length > MAX_MIGRATION_FILES)
+    return yield* Effect.fail(new Invalid({ message: `runtime diff count exceeds ${MAX_MIGRATION_FILES}` }))
+  const files = [] as Array<{
+    index: number
+    path: string
+    pathKey: string
+    additions: number
+    deletions: number
+    status: "added" | "deleted" | "modified" | null
+    patch: Buffer
+  }>
+  const pathKeys = new Set<string>()
+  for (const [index, entry] of diffs.entries()) {
+    if (!record(entry)) return yield* Effect.fail(new Invalid({ message: `runtime diff ${index} is invalid` }))
+    const path = normalizePath(entry.file)
+    if (!path)
+      return yield* Effect.fail(new Invalid({ message: `runtime diff ${index} file path is invalid` }))
+    const pathKey = path.toLocaleLowerCase("en-US")
+    if (pathKeys.has(pathKey))
+      return yield* Effect.fail(new Invalid({ message: "runtime diffs contain a case-colliding file path" }))
+    pathKeys.add(pathKey)
+    const additions = entry.additions
+    const deletions = entry.deletions
+    if (typeof additions !== "number" || !Number.isSafeInteger(additions) || additions < 0)
+      return yield* Effect.fail(new Invalid({ message: `runtime diff ${index} additions are invalid` }))
+    if (typeof deletions !== "number" || !Number.isSafeInteger(deletions) || deletions < 0)
+      return yield* Effect.fail(new Invalid({ message: `runtime diff ${index} deletions are invalid` }))
+    const status = entry.status
+    if (status !== undefined && status !== "added" && status !== "deleted" && status !== "modified")
+      return yield* Effect.fail(new Invalid({ message: `runtime diff ${index} status is invalid` }))
+    const patch = entry.patch
+    if (patch !== undefined && patch !== null && typeof patch !== "string")
+      return yield* Effect.fail(new Invalid({ message: `runtime diff ${index} patch is invalid` }))
+    files.push({
+      index,
+      path,
+      pathKey,
+      additions,
+      deletions,
+      status: status ?? null,
+      patch: Buffer.from(typeof patch === "string" ? patch : "", "utf8"),
+    })
+  }
+  const body = Buffer.from(JSON.stringify({ diffs }))
+  if (body.byteLength > MAX_MIGRATION_BODY_BYTES)
+    return yield* Effect.fail(new Invalid({ message: "runtime diff body exceeds the byte budget" }))
+  const bodyHash = Hash.sha256(body)
+  const originalDataHash = Hash.sha256(source.text)
+  const artifactID = `evtart_${Hash.sha256(`legacy-message-diff.v2:${input.sourceEventID}:${originalDataHash}:${bodyHash}`)}`
+  const descriptor: CanonicalArtifact = {
+    id: artifactID,
+    hash: bodyHash,
+    codec: "legacy-message-diff.v2",
+    fileCount: diffs.length,
+    previewFileCount: Math.min(diffs.length, MessageV2.ClientDiffLimits.files),
+    previewTruncated: diffs.length > MessageV2.ClientDiffLimits.files,
+  }
+  const nextSummary: Record<string, unknown> = { ...summary, diffArtifact: descriptor }
+  delete nextSummary.diffs
+  const next = { ...parsed, summary: nextSummary }
+  const nextData = CanonicalJson.stringify(next)
+  const canonicalData = {
+    sessionID: input.sessionID,
+    info: { ...next, id: input.messageID, sessionID: input.sessionID },
+  }
+  const canonicalText = JSON.stringify(canonicalData)
+  const bodyChunks = Array.from(
+    { length: Math.max(1, Math.ceil(body.byteLength / FILE_CHUNK_BYTES)) },
+    (_, index) => body.subarray(index * FILE_CHUNK_BYTES, (index + 1) * FILE_CHUNK_BYTES),
+  )
+  return yield* db
+    .transaction(
+      (tx) =>
+        Effect.gen(function* () {
+          const existing = yield* tx
+            .select()
+            .from(SessionDiffMigrationReceiptTable)
+            .where(eq(SessionDiffMigrationReceiptTable.message_id, input.messageID))
+            .get()
+          if (existing) return { state: "skipped" as const }
+          const epochs = yield* validateEpochHashes(
+            tx as unknown as Database.Interface["db"],
+            input.sessionID,
+            input.messageID,
+            parsed,
+            next,
+          )
+          if ("failure" in epochs)
+            return yield* Effect.fail(new Invalid({ message: epochs.failure ?? "history authority validation failed" }))
+          const sessionSummary = yield* tx.get<{ data: string | null; body: string | null }>(sql`
+            SELECT CAST(summary_diffs AS TEXT) AS data,
+              CASE WHEN summary_diffs IS NULL THEN NULL ELSE json_object('diffs', json(summary_diffs)) END AS body
+            FROM session
+            WHERE id = ${input.sessionID}
+          `)
+          if (!sessionSummary) return yield* Effect.fail(new Invalid({ message: "runtime capture Session is missing" }))
+          const expectedMessageDataHash = Hash.sha256(current.data)
+          const expectedSessionSummaryHash = Hash.sha256(sessionSummary.data ?? "null")
+          yield* tx
+            .run(sql`
+              INSERT INTO event_artifact (
+                artifact_id, event_id, aggregate_id, seq, kind,
+                original_data_hash, canonical_data_hash, canonical_data,
+                body_hash, body_bytes, chunk_count, codec_version, created_at
+              ) VALUES (
+                ${artifactID}, ${input.sourceEventID}, ${input.sessionID}, ${source.seq}, 'legacy_message_diff',
+                ${originalDataHash}, ${Hash.sha256(canonicalText)}, ${canonicalText},
+                ${bodyHash}, ${body.byteLength}, ${bodyChunks.length}, 2, ${now}
+              ) ON CONFLICT DO NOTHING
+            `)
+            .pipe(Effect.orDie)
+          yield* Effect.forEach(
+            bodyChunks,
+            (chunk, index) =>
+              tx
+                .run(sql`
+                  INSERT INTO event_artifact_chunk (artifact_id, chunk_index, data, chunk_hash)
+                  VALUES (${artifactID}, ${index}, ${chunk}, ${Hash.sha256(chunk)})
+                  ON CONFLICT DO NOTHING
+                `)
+                .pipe(Effect.orDie),
+            { discard: true },
+          )
+          // The receipt FK targets event_artifact, so the artifact rows must exist first; the
+          // receipt_guard trigger then requires the prepared receipt before any file rows land.
+          yield* tx
+            .insert(SessionDiffMigrationReceiptTable)
+            .values({
+              message_id: input.messageID,
+              session_id: input.sessionID,
+              artifact_id: artifactID,
+              source_event_id: input.sourceEventID,
+              expected_message_data_hash: expectedMessageDataHash,
+              expected_session_summary_hash: expectedSessionSummaryHash,
+              canonicalizer_version: 2,
+              canonicalization_version: HistoryAuthority.CANONICALIZATION_VERSION,
+              epoch_hashes: epochs.values,
+              state: "prepared",
+              created_at: now,
+              updated_at: now,
+            })
+            .run()
+          for (const file of files) {
+            const chunkCount = Math.max(1, Math.ceil(file.patch.byteLength / FILE_CHUNK_BYTES))
+            yield* tx
+              .insert(SessionDiffArtifactFileTable)
+              .values({
+                artifact_id: artifactID,
+                file_index: file.index,
+                path: file.path,
+                path_key: file.pathKey,
+                additions: file.additions,
+                deletions: file.deletions,
+                status: file.status,
+                patch_hash: Hash.sha256(file.patch),
+                patch_bytes: file.patch.byteLength,
+                patch_chunk_count: chunkCount,
+              })
+              .run()
+            yield* Effect.forEach(
+              Array.from(
+                { length: chunkCount },
+                (_, index) => file.patch.subarray(index * FILE_CHUNK_BYTES, (index + 1) * FILE_CHUNK_BYTES),
+              ),
+              (data, index) =>
+                tx
+                  .insert(SessionDiffArtifactFileChunkTable)
+                  .values({
+                    artifact_id: artifactID,
+                    file_index: file.index,
+                    chunk_index: index,
+                    data,
+                    chunk_hash: Hash.sha256(data),
+                  })
+                  .run(),
+              { discard: true },
+            )
+          }
+          const updated = yield* tx
+            .update(MessageTable)
+            .set({
+              data: sql`json(${nextData})` as unknown as typeof MessageTable.$inferInsert.data,
+              time_updated: now,
+            })
+            .where(
+              and(
+                eq(MessageTable.id, input.messageID),
+                eq(MessageTable.session_id, input.sessionID),
+                sql`CAST(${MessageTable.data} AS TEXT) = ${current.data}`,
+              ),
+            )
+            .returning({ data: sql<string>`CAST(${MessageTable.data} AS TEXT)` })
+            .get()
+          if (!updated)
+            return yield* Effect.fail(new Invalid({ message: "runtime capture message compare-and-swap lost" }))
+          if (Hash.sha256(updated.data) !== Hash.sha256(nextData))
+            return yield* Effect.die(new Error(`Runtime diff message bytes diverged: ${input.messageID}`))
+          let summaryNulled = false
+          if (sessionSummary.data !== null && sessionSummary.body !== null && Hash.sha256(sessionSummary.body) === bodyHash) {
+            const sessionUpdated = yield* tx
+              .update(SessionTable)
+              .set({ summary_diffs: null })
+              .where(
+                and(
+                  eq(SessionTable.id, input.sessionID),
+                  sql`CAST(${SessionTable.summary_diffs} AS TEXT) = ${sessionSummary.data}`,
+                ),
+              )
+              .returning({ id: SessionTable.id })
+              .get()
+            if (!sessionUpdated)
+              return yield* Effect.fail(new Invalid({ message: "runtime capture Session summary compare-and-swap lost" }))
+            summaryNulled = true
+          }
+          yield* tx
+            .update(SessionDiffMigrationReceiptTable)
+            .set({
+              state: "committed",
+              committed_message_data_hash: Hash.sha256(updated.data),
+              committed_session_summary_hash: summaryNulled ? NULL_SUMMARY_HASH : expectedSessionSummaryHash,
+              updated_at: now,
+              committed_at: now,
+            })
+            .where(
+              and(
+                eq(SessionDiffMigrationReceiptTable.message_id, input.messageID),
+                eq(SessionDiffMigrationReceiptTable.state, "prepared"),
+              ),
+            )
+            .run()
+          return { state: "captured" as const, artifact: descriptor }
+        }),
+      // Same WAL/deferred rationale as migrate: validation reads stay on one snapshot without
+      // reserving the writer; concurrent commits surface as CAS misses instead of stale authority.
+      { behavior: "deferred" },
+    )
+    .pipe(Effect.orDie)
+})
+
 function migrationBudget(db: Database.Interface["db"], candidate: Candidate) {
   return db
     .get<{
diff --git a/packages/deepagent-code/src/session/durable-executor-lock.ts b/packages/deepagent-code/src/session/durable-executor-lock.ts
index 88afa39b..189c1997 100644
--- a/packages/deepagent-code/src/session/durable-executor-lock.ts
+++ b/packages/deepagent-code/src/session/durable-executor-lock.ts
@@ -60,7 +60,10 @@ export function acquireDurableExecutorLease(input: {
         fs.mkdirSync(lockPath, { mode: 0o700 })
       } catch (error) {
         if (!hasCode(error, "EEXIST")) return
-        if (!leaseIsStale(lockPath, staleMs)) return
+        if (!leaseIsStale(lockPath, staleMs)) {
+          warnLiveStaleLeaseHolder({ directory: input.directory, lockPath, staleMs })
+          return
+        }
         if (!quarantineStaleLease(lockPath)) continue
         fs.mkdirSync(lockPath, { mode: 0o700 })
       }
@@ -126,6 +129,36 @@ export function releaseDurableExecutorLease(lease: DurableExecutorLease) {
   }
 }
 
+/**
+ * Alert when a lease is past its staleness window but its owner process is still alive, so the
+ * fail-closed refusal in leaseIsStale is observable instead of a silent startup stall.
+ */
+function warnLiveStaleLeaseHolder(input: { readonly directory: string; readonly lockPath: string; readonly staleMs: number }) {
+  const metadata = readMetadata(path.join(input.lockPath, "meta.json"))
+  if (!metadata || !processIsAlive(metadata.pid)) return
+  let leaseAgeMs: number | undefined
+  try {
+    leaseAgeMs = Date.now() - fs.statSync(path.join(input.lockPath, "heartbeat")).mtimeMs
+  } catch (error) {
+    if (!hasCode(error, "ENOENT")) return
+  }
+  if (leaseAgeMs === undefined) {
+    try {
+      leaseAgeMs = Date.now() - fs.statSync(input.lockPath).mtimeMs
+    } catch {
+      return
+    }
+  }
+  if (leaseAgeMs <= input.staleMs) return
+  console.warn("[durable-executor-lock] stale lease held by a live process; refusing takeover (fail-closed)", {
+    workspace: input.directory,
+    pid: metadata.pid,
+    leaseAgeMs,
+    staleMs: input.staleMs,
+    lockPath: input.lockPath,
+  })
+}
+
 function quarantineStaleLease(lockPath: string) {
   const quarantine = `${lockPath}.stale-${randomUUID()}`
   try {
diff --git a/packages/deepagent-code/src/session/event-dispatcher.ts b/packages/deepagent-code/src/session/event-dispatcher.ts
index be9f196d..407d83ba 100644
--- a/packages/deepagent-code/src/session/event-dispatcher.ts
+++ b/packages/deepagent-code/src/session/event-dispatcher.ts
@@ -474,11 +474,17 @@ export const layerWith = (options?: LayerOptions) =>
       const pumpRetries: Interface["pumpRetries"] = (nowArg) =>
         Effect.gen(function* () {
           const at = nowArg ?? now()
-          const due = yield* bus.dueRetries(at)
+          // RISK-001: claim our group's due rows before executing — dueRetries() was an unlocked
+          // global scan, so two processes could re-drive the same retry concurrently. The claim's
+          // lease (default 5min) must exceed worst-case processing time; if it lapses mid-handling
+          // another claimant may re-drive the same event (bounded duplicate, same as pre-fix).
+          const claim = yield* bus.claimDue({
+            subscriptionGroup: DISPATCH_GROUP,
+            claimantId: `event-dispatcher:${process.pid}`,
+            now: at,
+          })
           let redriven = 0
-          for (const delivery of due) {
-            // only our own group's deliveries — dueRetries is global across groups.
-            if (delivery.subscriptionGroup !== DISPATCH_GROUP) continue
+          for (const delivery of claim.deliveries) {
             const event = yield* bus.getByID(delivery.eventID)
             if (!event) {
               // event row gone (retention sweep?) — the delivery is unrecoverable; leave it for the DLQ.
diff --git a/packages/deepagent-code/src/session/facade-activity.ts b/packages/deepagent-code/src/session/facade-activity.ts
new file mode 100644
index 00000000..08782579
--- /dev/null
+++ b/packages/deepagent-code/src/session/facade-activity.ts
@@ -0,0 +1,986 @@
+/**
+ * FEAT-011 T3 — FacadeActivity dispatcher (统一活动 facade 入口).
+ *
+ * Design: docs/feature-002-407.md (§2 tool contract, §11 non-goals).
+ *
+ * The facade is a THIN delegation layer over the three existing runners — it NEVER duplicates
+ * lifecycle state and NEVER builds a parallel runtime:
+ *
+ *   task  → TaskDispatcher durable queue (admitTaskRun → input projection → enqueueRun),
+ *           concurrency through TaskConcurrency's two-layer semaphore.
+ *   goal  → GoalManager.start / pause / resume / stop; steer via the goal_steer channel.
+ *   panel → PanelConsult.consultPanel wrapped in a BackgroundJob owned by THIS service.
+ *
+ * Every start first writes a `session_facade_activity` row (state=active). The partial unique
+ * index `(parent_session_id, subkind) WHERE state='active'` is the fail-closed admission fence:
+ * a second active facade of the same subkind for the same parent session is refused. Terminal
+ * state is settled through DeepAgentActivityAuthority.settle(kind=facade) with the
+ * mutation_epoch CAS token.
+ *
+ * Ownership is runtime-owned: each start mints `${processOwnerToken}:facade:<uuid>` which is
+ * only used for runner-side bookkeeping and is NEVER surfaced to the model.
+ */
+import { randomUUID } from "node:crypto"
+import { and, desc, eq } from "drizzle-orm"
+import { Context, Data, Effect, Layer, Option } from "effect"
+import { Database } from "@deepagent-code/core/database/database"
+import { SessionFacadeActivityTable } from "@deepagent-code/core/deepagent/activity-authority.sql"
+import { DeepAgentActivityAuthority } from "@deepagent-code/core/deepagent/index"
+import { Prompt } from "@deepagent-code/core/session/prompt"
+import { TaskRunTable } from "@deepagent-code/core/session/sql"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { Agent } from "@/agent/agent"
+import { deriveSubagentSessionPermission } from "@/agent/subagent-permissions"
+import { BackgroundJob } from "@/background/job"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { PanelConsult } from "@/panel/consult"
+import { Provider } from "@/provider/provider"
+import { GoalDriver } from "@/session/goal-driver"
+import { GoalManager } from "@/session/goal-manager"
+import { GoalLoopWiring } from "@/session/goal-loop-wiring"
+import { LegacyTaskInput } from "@/session/task-input"
+import { SessionPrompt } from "@/session/prompt"
+import { SessionSteer } from "@/session/steer"
+import { SessionActivityOwner } from "@/session/activity-owner"
+import { Session } from "@/session/session"
+import { TaskDispatcher } from "@/session/task-dispatcher"
+import { MessageID, SessionID } from "@/session/schema"
+import { Identifier } from "@/id/id"
+import { TaskConcurrency } from "@/tool/task-concurrency"
+import {
+  admitTaskRun,
+  closeTask,
+  getTaskRun,
+  transitionToAdmitting,
+  type Run as TaskRun,
+} from "@/tool/task-run"
+
+export type FacadeSubkind = "task" | "goal" | "panel"
+
+/**
+ * Hard budget caps the facade enforces (policy ceiling). Model-supplied limits are clamped with
+ * `min` against these — mirroring GoalManager's DEFAULT_LIMITS pattern (never loosen the policy).
+ */
+export const FACADE_POLICY_LIMITS = {
+  maxTicks: 50,
+  maxTokens: 500_000,
+  maxWallclockMs: 60 * 60 * 1000,
+} as const
+
+export type FacadeBudget = {
+  readonly maxTicks: number
+  readonly maxTokens: number
+  readonly maxWallclockMs: number
+}
+
+const clampPositiveInt = (requested: number | undefined, ceiling: number): number => {
+  if (requested == null || !Number.isFinite(requested) || requested <= 0) return ceiling
+  return Math.min(Math.floor(requested), ceiling)
+}
+
+/** min-clamp model limits against the policy ceiling; unset/invalid fields fall back to the ceiling. */
+export const clampFacadeBudget = (requested?: Partial<FacadeBudget>): FacadeBudget => ({
+  maxTicks: clampPositiveInt(requested?.maxTicks, FACADE_POLICY_LIMITS.maxTicks),
+  maxTokens: clampPositiveInt(requested?.maxTokens, FACADE_POLICY_LIMITS.maxTokens),
+  maxWallclockMs: clampPositiveInt(requested?.maxWallclockMs, FACADE_POLICY_LIMITS.maxWallclockMs),
+})
+
+/**
+ * T6 — bounded projection helper. Code-point safe slice (never splits a surrogate pair) with an
+ * explicit truncation marker so callers can programmatically detect the bound (design G5).
+ */
+export const applyResultBound = (
+  text: string,
+  maxChars: number,
+): { readonly text: string; readonly truncated: boolean } => {
+  if (text.length <= maxChars) return { text, truncated: false }
+  const points = Array.from(text)
+  if (points.length <= maxChars) return { text, truncated: false }
+  return { text: `${points.slice(0, maxChars).join("")}…[truncated]`, truncated: true }
+}
+
+export class FacadeActivityConflict extends Data.TaggedError("FacadeActivity.Conflict")<{
+  readonly sessionID: string
+  readonly subkind: FacadeSubkind
+  readonly reason: string
+}> {}
+
+export class FacadeActivityNotFound extends Data.TaggedError("FacadeActivity.NotFound")<{
+  readonly sessionID: string
+  readonly subkind: FacadeSubkind
+}> {}
+
+export class FacadeActivityRunnerUnavailable extends Data.TaggedError("FacadeActivity.RunnerUnavailable")<{
+  readonly subkind: FacadeSubkind
+  readonly reason: string
+}> {}
+
+export class FacadeActivityInvalidInput extends Data.TaggedError("FacadeActivity.InvalidInput")<{
+  readonly reason: string
+}> {}
+
+export class FacadeActivityUnsupportedControl extends Data.TaggedError("FacadeActivity.UnsupportedControl")<{
+  readonly subkind: FacadeSubkind
+  readonly action: FacadeControlAction
+  readonly reason: string
+}> {}
+
+export type FacadeError =
+  | FacadeActivityConflict
+  | FacadeActivityNotFound
+  | FacadeActivityRunnerUnavailable
+  | FacadeActivityInvalidInput
+  | FacadeActivityUnsupportedControl
+
+export type FacadeStartInput = {
+  readonly sessionID: string
+  readonly subkind: FacadeSubkind
+  readonly objective: string
+  readonly budget?: Partial<FacadeBudget>
+  /** The spawning tool-call id; doubles as the task_run.tool_call_id join key for task facades. */
+  readonly spawnToolCallID?: string
+  readonly parentMessageID?: string
+  /** task-only: subagent type (defaults to "explore"). */
+  readonly subagentType?: string
+  /** task-only: the task prompt (defaults to the objective). */
+  readonly prompt?: string
+}
+
+export type FacadeStartResult = {
+  readonly activityID: string
+  readonly subkind: FacadeSubkind
+  readonly budget: FacadeBudget
+  /** Domain reference — task: run/child session; goal: goalId; panel: background job id. */
+  readonly ref: Record<string, string>
+}
+
+export type FacadeStatusEntry = {
+  readonly activityID: string
+  readonly subkind: FacadeSubkind
+  readonly state: string
+  readonly reason?: string
+  readonly createdAt: number
+  readonly settledAt?: number
+  readonly objective?: string
+  readonly ref: Record<string, string>
+}
+
+export type FacadeResultProjection = {
+  readonly activityID: string
+  readonly subkind: FacadeSubkind
+  readonly terminal: boolean
+  /** Facade base state (active/settled/interrupted/failed). */
+  readonly state: string
+  readonly reason?: string
+  readonly summary?: string
+  /** task subkind: structured settlement receipt (bounded). */
+  readonly receipt?: Record<string, unknown>
+  /** panel subkind: the arbiter verdict (bounded). */
+  readonly verdict?: unknown
+  /** goal subkind: terminal phase snapshot. */
+  readonly phase?: string
+  readonly truncated: boolean
+}
+
+export type FacadeControlAction = "pause" | "resume" | "stop" | "steer"
+
+export type FacadeControlInput = {
+  readonly sessionID: string
+  readonly subkind: FacadeSubkind
+  readonly action: FacadeControlAction
+  /** steer-only: the guidance text admitted to the goal_steer channel. */
+  readonly message?: string
+  readonly reason?: string
+}
+
+export type FacadeControlResult = {
+  readonly applied: boolean
+  readonly subkind: FacadeSubkind
+  readonly action: FacadeControlAction
+  readonly detail: string
+}
+
+export interface Interface {
+  readonly start: (input: FacadeStartInput) => Effect.Effect<FacadeStartResult, FacadeError>
+  readonly status: (input: {
+    readonly sessionID: string
+    readonly subkind?: FacadeSubkind
+    readonly limit?: number
+  }) => Effect.Effect<ReadonlyArray<FacadeStatusEntry>>
+  readonly result: (input: {
+    readonly sessionID: string
+    readonly subkind: FacadeSubkind
+  }) => Effect.Effect<FacadeResultProjection, FacadeActivityNotFound>
+  readonly control: (input: FacadeControlInput) => Effect.Effect<FacadeControlResult, FacadeError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@deepagent-code/FacadeActivity") {}
+
+type FacadeRow = typeof SessionFacadeActivityTable.$inferSelect
+
+const STATUS_LIMIT_CEILING = 20
+
+/**
+ * The dispatcher construction effect. Hard requirements are ONLY Database + RuntimeFlags; every
+ * runner dependency (GoalManager, SessionPrompt, BackgroundJob, SessionSteer, Session/Agent/
+ * Provider) is resolved via serviceOption so the registry can build the facade inline from
+ * whatever the surrounding graph provides, without adding requirements to ToolRegistry.layer.
+ */
+export const build: Effect.Effect<Interface, never, Database.Service | RuntimeFlags.Service> = Effect.gen(
+  function* () {
+    const database = yield* Database.Service
+    const { db } = database
+    const flags = yield* RuntimeFlags.Service
+    const goals = Option.getOrUndefined(yield* Effect.serviceOption(GoalManager.Service))
+    const steerBuffer = Option.getOrUndefined(yield* Effect.serviceOption(SessionSteer.Service))
+    const background = Option.getOrUndefined(yield* Effect.serviceOption(BackgroundJob.Service))
+    const sessions = Option.getOrUndefined(yield* Effect.serviceOption(Session.Service))
+    const agents = Option.getOrUndefined(yield* Effect.serviceOption(Agent.Service))
+    const sessionPrompt = Option.getOrUndefined(yield* Effect.serviceOption(SessionPrompt.Service))
+    const provider = Option.getOrUndefined(yield* Effect.serviceOption(Provider.Service))
+
+    // Runtime-owned facade owners: minted per start, used only for runner-side bookkeeping and
+    // NEVER returned to the model (the facade row intentionally has no owner_token column).
+    const facadeOwners = new Map<string, string>()
+
+    // ── facade base-table IO ──────────────────────────────────────────────────────────────────
+
+    const insertFacadeRow = (input: {
+      activityID: string
+      subkind: FacadeSubkind
+      sessionID: string
+      objective: string
+      budget: FacadeBudget
+      spawnToolCallID?: string
+      parentMessageID?: string
+    }) =>
+      Effect.gen(function* () {
+        const inserted = yield* db
+          .insert(SessionFacadeActivityTable)
+          .values({
+            activity_id: input.activityID,
+            subkind: input.subkind,
+            parent_session_id: SessionID.make(input.sessionID),
+            spawn_tool_call_id: input.spawnToolCallID,
+            objective_text: input.objective,
+            budget_json: input.budget,
+            state: "active",
+            source: "activity_facade",
+            created_at: Date.now(),
+            mutation_epoch: 0,
+          })
+          // The partial unique index (parent_session_id, subkind) WHERE state='active' is the
+          // fail-closed fence: a concurrent/lingering active facade makes this insert vanish.
+          .onConflictDoNothing()
+          .returning()
+          .get()
+          .pipe(Effect.orDie)
+        if (!inserted)
+          return yield* Effect.fail(
+            new FacadeActivityConflict({
+              sessionID: input.sessionID,
+              subkind: input.subkind,
+              reason: "an active facade of this subkind already exists for this session; settle it first",
+            }),
+          )
+        return inserted
+      })
+
+    const readFacadeRow = (activityID: string) =>
+      db
+        .select()
+        .from(SessionFacadeActivityTable)
+        .where(eq(SessionFacadeActivityTable.activity_id, activityID))
+        .get()
+        .pipe(Effect.orDie)
+
+    const latestFacadeRow = (sessionID: string, subkind: FacadeSubkind) =>
+      db
+        .select()
+        .from(SessionFacadeActivityTable)
+        .where(
+          and(
+            eq(SessionFacadeActivityTable.parent_session_id, SessionID.make(sessionID)),
+            eq(SessionFacadeActivityTable.subkind, subkind),
+          ),
+        )
+        .orderBy(desc(SessionFacadeActivityTable.created_at))
+        .get()
+        .pipe(Effect.orDie)
+
+    const listFacadeRows = (sessionID: string, subkind: FacadeSubkind | undefined, limit: number) =>
+      db
+        .select()
+        .from(SessionFacadeActivityTable)
+        .where(
+          and(
+            eq(SessionFacadeActivityTable.parent_session_id, SessionID.make(sessionID)),
+            ...(subkind ? [eq(SessionFacadeActivityTable.subkind, subkind)] : []),
+          ),
+        )
+        .orderBy(desc(SessionFacadeActivityTable.created_at))
+        .limit(limit)
+        .all()
+        .pipe(Effect.orDie)
+
+    // ── settlement via the ActivityAuthority facade branch (mutation_epoch CAS) ───────────────
+
+    const settleFacadeRow = (row: FacadeRow, state: "completed" | "interrupted" | "recovery_required", reason: string) =>
+      DeepAgentActivityAuthority.settle({
+        activityKind: "facade",
+        activityID: row.activity_id,
+        expectedVersion: row.mutation_epoch,
+        state,
+        terminalReason: reason,
+      }).pipe(
+        // The authority set requires Database.Service; pin it to the instance captured at build
+        // time so converge/settle stay requirement-free for the public ports.
+        Effect.provideService(Database.Service, database),
+        Effect.map(() => true),
+        // A lost CAS / already-terminal row is not a facade defect — convergence is best-effort
+        // and the domain authority remains the source of truth.
+        Effect.catchCause(() => Effect.succeed(false)),
+      )
+
+    // ── domain probes (the runners remain the state authority) ────────────────────────────────
+
+    const taskRunForFacade = (row: FacadeRow) => {
+      if (!row.spawn_tool_call_id) return Effect.succeed(undefined)
+      return db
+        .select()
+        .from(TaskRunTable)
+        .where(
+          and(
+            eq(TaskRunTable.parent_session_id, row.parent_session_id),
+            eq(TaskRunTable.tool_call_id, row.spawn_tool_call_id),
+          ),
+        )
+        .orderBy(desc(TaskRunTable.generation))
+        .get()
+        .pipe(Effect.orDie)
+    }
+
+    const TASK_TERMINAL_STATES = new Set(["completed", "error", "failed", "cancelled", "interrupted"])
+    const GOAL_TERMINAL_PHASES = new Set(["done", "needs_human", "rolled_back", "stopped"])
+
+    /**
+     * Lazy convergence: when the domain runner already reached a terminal state but the facade
+     * row is still active, settle it through the authority. task/goal runs are NOT owned by the
+     * facade, so settlement happens at the next status/result/control touch point (panel settles
+     * eagerly from its own background job).
+     */
+    const converge = (row: FacadeRow): Effect.Effect<FacadeRow> =>
+      Effect.gen(function* () {
+        if (row.state !== "active") return row
+        if (row.subkind === "task") {
+          const run = yield* taskRunForFacade(row)
+          if (!run || !TASK_TERMINAL_STATES.has(run.state)) return row
+          const state =
+            run.state === "completed"
+              ? ("completed" as const)
+              : run.state === "cancelled" || run.state === "interrupted"
+                ? ("interrupted" as const)
+                : ("recovery_required" as const)
+          yield* settleFacadeRow(row, state, run.reason ?? `task_run_${run.state}`)
+        } else if (row.subkind === "goal") {
+          if (!goals) return row
+          const snapshot = yield* goals.status(row.parent_session_id).pipe(Effect.catchCause(() => Effect.succeed(null)))
+          if (!snapshot || !GOAL_TERMINAL_PHASES.has(snapshot.phase)) return row
+          const state =
+            snapshot.phase === "done"
+              ? ("completed" as const)
+              : snapshot.phase === "rolled_back"
+                ? ("recovery_required" as const)
+                : ("interrupted" as const)
+          yield* settleFacadeRow(row, state, `goal_${snapshot.phase}`)
+        } else {
+          if (!background) return row
+          const job = yield* background.get(row.activity_id).pipe(Effect.catchCause(() => Effect.succeed(undefined)))
+          if (!job || job.status === "running") return row
+          const state =
+            job.status === "completed"
+              ? ("completed" as const)
+              : job.status === "cancelled"
+                ? ("interrupted" as const)
+                : ("recovery_required" as const)
+          yield* settleFacadeRow(row, state, `panel_${job.status}`)
+        }
+        return (yield* readFacadeRow(row.activity_id)) ?? row
+      })
+
+    // ── subkind delegation: task ──────────────────────────────────────────────────────────────
+
+    // Domain errors that escape the delegation internals (input-projection conflicts, raw SQL
+    // errors) are folded into RunnerUnavailable so the public ports expose ONLY FacadeError.
+    const toFacadeError = (error: unknown): FacadeError =>
+      error instanceof FacadeActivityConflict ||
+      error instanceof FacadeActivityNotFound ||
+      error instanceof FacadeActivityRunnerUnavailable ||
+      error instanceof FacadeActivityInvalidInput ||
+      error instanceof FacadeActivityUnsupportedControl
+        ? error
+        : new FacadeActivityRunnerUnavailable({
+            subkind: "task",
+            reason: `task delegation failed: ${
+              typeof error === "object" && error !== null && "_tag" in error ? String((error as { _tag: unknown })._tag) : "unknown"
+            }`,
+          })
+
+    const startTask = (
+      row: FacadeRow,
+      input: FacadeStartInput,
+    ): Effect.Effect<Record<string, string>, FacadeError> =>
+      Effect.gen(function* () {
+        if (flags.subagentControlPlane !== "durable")
+          return yield* Effect.fail(
+            new FacadeActivityRunnerUnavailable({
+              subkind: "task",
+              reason:
+                "task facade delegates to the durable TaskDispatcher queue; requires DEEPAGENT_CODE_SUBAGENT_CONTROL_PLANE=durable",
+            }),
+          )
+        if (!sessions || !agents || !provider)
+          return yield* Effect.fail(
+            new FacadeActivityRunnerUnavailable({ subkind: "task", reason: "session/agent/provider services unavailable" }),
+          )
+        const subagentType = input.subagentType ?? "explore"
+        const agentInfo = yield* agents.get(subagentType)
+        if (!agentInfo)
+          return yield* Effect.fail(
+            new FacadeActivityInvalidInput({ reason: `unknown subagent_type: ${subagentType}` }),
+          )
+        const model = yield* provider.defaultModel().pipe(
+          Effect.catchCause(() =>
+            Effect.fail(
+              new FacadeActivityRunnerUnavailable({ subkind: "task", reason: "no default model configured" }),
+            ),
+          ),
+        )
+        const promptText = input.prompt ?? input.objective
+        const toolCallID = row.spawn_tool_call_id ?? `facade:${row.activity_id}`
+        const parentMessageID = input.parentMessageID
+          ? MessageID.make(input.parentMessageID)
+          : MessageID.ascending("facade")
+
+        // Concurrency: reuse TaskConcurrency's two-layer (session + agent-type) semaphore — the
+        // facade must not bypass the code-layer cap the task tool enforces.
+        return yield* TaskConcurrency.withTaskSlot({
+          parentSessionID: row.parent_session_id,
+          subagentType,
+          effect: Effect.gen(function* () {
+            const parent = yield* sessions.get(SessionID.make(row.parent_session_id)).pipe(Effect.orDie)
+            const parentAgent = parent.agent
+              ? yield* agents.get(parent.agent).pipe(Effect.orElseSucceed(() => undefined))
+              : undefined
+            const childPermission = deriveSubagentSessionPermission({
+              parentSessionPermission: parent.permission ?? [],
+              parentAgent,
+              subagent: agentInfo,
+            })
+            const admission = yield* admitTaskRun({
+              parentSessionID: SessionID.make(row.parent_session_id),
+              parentMessageID,
+              toolCallID,
+              request: {
+                facade: "activity_facade",
+                subagent_type: subagentType,
+                description: input.objective,
+                prompt: promptText,
+              },
+              deliveryMode: "background",
+              // The facade never escalates: delegated tasks start read-only; write worktree
+              // isolation remains the dedicated task tool's explicit surface.
+              mutationCapability: "read_only",
+              toolCapabilityHash: "facade-static",
+              inputState: "pending",
+              workspaceMode: "shared",
+              workspaceOwner: "parent",
+              workspaceVisibility: "live",
+              parentDirtyPolicy: "allow_live",
+              workspacePreflightState: "pending",
+              sessionMode: "new",
+              executionSpec: {
+                description: input.objective,
+                prompt: { text: promptText },
+                agent: agentInfo.name,
+                model: { providerID: model.providerID, modelID: model.modelID },
+                permission: childPermission,
+              },
+            }).pipe(
+              Effect.provideService(Database.Service, database),
+              Effect.mapError(
+                (error) =>
+                  new FacadeActivityConflict({
+                    sessionID: row.parent_session_id,
+                    subkind: "task",
+                    reason: `task admission refused: ${error._tag}/${"reason" in error ? error.reason : "unknown"}`,
+                  }),
+              ),
+            )
+
+            if (admission.exactRetry && TASK_TERMINAL_STATES.has(admission.run.state)) {
+              const replayed: Record<string, string> = {
+                runID: admission.run.runID,
+                childSessionID: admission.run.childSessionID,
+                replayed: "true",
+              }
+              return replayed
+            }
+
+            // Child session adoption (mirrors task.ts's durable projection ordering).
+            const existingChild = yield* sessions
+              .get(admission.run.childSessionID)
+              .pipe(Effect.catchCause(() => Effect.succeed(undefined)))
+            if (!existingChild) {
+              yield* sessions
+                .create({
+                  id: admission.run.childSessionID,
+                  parentID: SessionID.make(row.parent_session_id),
+                  title: `${input.objective} (@${agentInfo.name} facade task)`,
+                  agent: agentInfo.name,
+                  model: {
+                    id: ModelV2.ID.make(model.modelID),
+                    providerID: ProviderV2.ID.make(model.providerID),
+                  },
+                  permission: childPermission,
+                  directory: parent.directory,
+                })
+                .pipe(Effect.orDie)
+            }
+            // Terminal-projector identity fence (run_id/generation metadata) — minimal replica of
+            // task.ts's private projectSubagentRun, required by the settlement projection path.
+            const childSession =
+              existingChild ?? (yield* sessions.get(admission.run.childSessionID).pipe(Effect.orDie))
+            const meta = (childSession.metadata ?? {}) as Record<string, unknown>
+            const deepagent = (meta.deepagent ?? {}) as Record<string, unknown>
+            yield* sessions
+              .setMetadata({
+                sessionID: admission.run.childSessionID,
+                metadata: {
+                  ...meta,
+                  deepagent: {
+                    ...deepagent,
+                    subagent: {
+                      finished: false,
+                      state: "researching",
+                      phase: "research",
+                      run_id: admission.run.runID,
+                      generation: admission.run.generation,
+                      attempts: 0,
+                      started_at: Date.now(),
+                    },
+                  },
+                },
+              })
+              .pipe(Effect.orDie)
+
+            // Durable input projection: admitted → admitting → input ready → queued. The executor
+            // startup CAS requires input_state="ready", so this sequence is mandatory.
+            const latest = yield* getTaskRun(admission.run.runID).pipe(
+              Effect.provideService(Database.Service, database),
+            )
+            if (!latest)
+              return yield* Effect.fail(
+                new FacadeActivityRunnerUnavailable({ subkind: "task", reason: `run ${admission.run.runID} disappeared` }),
+              )
+            if (latest.inputState !== "ready" && latest.inputState !== "legacy") {
+              const admitting = yield* transitionToAdmitting({
+                runID: admission.run.runID,
+                version: latest.version,
+              }).pipe(Effect.provideService(Database.Service, database))
+              if (admitting) {
+                const prepared = yield* LegacyTaskInput.prepare(admitting, undefined).pipe(Effect.orDie)
+                yield* LegacyTaskInput.projectExact({
+                  prepared,
+                  runID: admission.run.runID,
+                  expectedRunVersion: admitting.version,
+                }).pipe(Effect.provideService(Database.Service, database))
+              }
+            }
+            const current = yield* getTaskRun(admission.run.runID).pipe(
+              Effect.provideService(Database.Service, database),
+            )
+            if (current && (current.inputState === "ready" || current.inputState === "legacy")) {
+              yield* TaskDispatcher.enqueueRun({
+                runID: admission.run.runID,
+                runVersion: current.version,
+              }).pipe(Effect.provideService(Database.Service, database))
+            }
+            const admitted: Record<string, string> = {
+              runID: admission.run.runID,
+              childSessionID: admission.run.childSessionID,
+            }
+            return admitted
+          }),
+        }).pipe(Effect.mapError(toFacadeError))
+      })
+
+    // ── subkind delegation: goal ──────────────────────────────────────────────────────────────
+
+    const startGoal = (
+      input: FacadeStartInput,
+      budget: FacadeBudget,
+    ): Effect.Effect<Record<string, string>, FacadeError> =>
+      Effect.gen(function* () {
+        if (!goals)
+          return yield* Effect.fail(
+            new FacadeActivityRunnerUnavailable({ subkind: "goal", reason: "GoalManager service unavailable" }),
+          )
+        const snapshot = yield* goals
+          .start({
+            sessionID: input.sessionID,
+            objective: input.objective,
+            limits: {
+              maxTicks: budget.maxTicks,
+              maxTokens: budget.maxTokens,
+              maxWallclockMs: budget.maxWallclockMs,
+            },
+          })
+          .pipe(
+            Effect.mapError(
+              (error) => new FacadeActivityInvalidInput({ reason: `goal rejected: ${error.message}` }),
+            ),
+          )
+        return { goalID: snapshot.goalId, planDocID: snapshot.planDocId, phase: snapshot.phase }
+      })
+
+    // ── subkind delegation: panel (facade-owned background job) ───────────────────────────────
+
+    const startPanel = (
+      row: FacadeRow,
+      input: FacadeStartInput,
+    ): Effect.Effect<Record<string, string>, FacadeError> =>
+      Effect.gen(function* () {
+        if (!background || !sessions || !agents || !sessionPrompt || !provider)
+          return yield* Effect.fail(
+            new FacadeActivityRunnerUnavailable({
+              subkind: "panel",
+              reason: "panel runner dependencies (session/agent/prompt/provider/background-job) unavailable",
+            }),
+          )
+        const model = yield* provider.defaultModel().pipe(
+          Effect.catchCause(() =>
+            Effect.fail(
+              new FacadeActivityRunnerUnavailable({ subkind: "panel", reason: "no default model configured" }),
+            ),
+          ),
+        )
+        // Same child-session turn runner the goal loop + HTTP panel route use — no parallel runtime.
+        const runTurn = GoalLoopWiring.makeTaskSubagentRunner({
+          sessions,
+          agents,
+          sessionPrompt,
+          parentSessionID: SessionID.make(row.parent_session_id),
+          model: { providerID: model.providerID, modelID: model.modelID },
+          purpose: "panel",
+        })
+        const panelTurnRunner = (turnInput: Parameters<typeof runTurn>[0]) =>
+          runTurn(turnInput).pipe(Effect.map((r) => ({ structured: r.structured })))
+        const job = yield* background.start({
+          id: row.activity_id,
+          type: "facade-panel",
+          title: applyResultBound(input.objective, 120).text,
+          metadata: { facadeActivityID: row.activity_id, subkind: "panel" },
+          run: PanelConsult.consultPanel(
+            { question: input.objective, codeRefs: [], parentSessionID: row.parent_session_id },
+            { runTurn: panelTurnRunner },
+          ).pipe(
+            Effect.tap((verdict) =>
+              settleFacadeRow(row, "completed", `panel_${verdict.decision}`).pipe(Effect.ignore),
+            ),
+            Effect.map((verdict) => JSON.stringify(verdict)),
+            Effect.catchCause((cause) =>
+              settleFacadeRow(row, "recovery_required", "panel_run_error").pipe(
+                Effect.ignore,
+                Effect.andThen(Effect.failCause(cause)),
+              ),
+            ),
+          ),
+        })
+        return { jobID: job.id }
+      })
+
+    // ── public ports ──────────────────────────────────────────────────────────────────────────
+
+    const start: Interface["start"] = Effect.fn("FacadeActivity.start")(function* (input) {
+      const objective = input.objective.trim()
+      if (!objective)
+        return yield* Effect.fail(new FacadeActivityInvalidInput({ reason: "objective must be non-empty" }))
+      const budget = clampFacadeBudget(input.budget)
+      // "job" is the closest legal ascending prefix for a facade-owned background activity id.
+      const activityID = Identifier.ascending("job")
+      const ownerToken = `${SessionActivityOwner.processOwnerToken}:facade:${randomUUID()}`
+      const spawnToolCallID = input.spawnToolCallID ?? `facade:${activityID}`
+      const row = yield* insertFacadeRow({
+        activityID,
+        subkind: input.subkind,
+        sessionID: input.sessionID,
+        objective,
+        budget,
+        spawnToolCallID,
+      })
+      facadeOwners.set(activityID, ownerToken)
+
+      // Delegation failure settles the freshly-admitted row as failed (fail-closed: an active
+      // facade row with no live runner would block the unique index forever).
+      const delegation: Effect.Effect<Record<string, string>, FacadeError> =
+        input.subkind === "task"
+          ? startTask({ ...row, spawn_tool_call_id: spawnToolCallID }, input)
+          : input.subkind === "goal"
+            ? startGoal(input, budget)
+            : startPanel(row, input)
+      return yield* delegation.pipe(
+        Effect.tap((ref) => Effect.sync(() => facadeOwners.set(activityID, ownerToken))),
+        Effect.map((ref) => ({ activityID, subkind: input.subkind, budget, ref })),
+        Effect.catch((error: FacadeError) =>
+          Effect.gen(function* () {
+            const current = yield* readFacadeRow(activityID)
+            if (current && current.state === "active") {
+              yield* settleFacadeRow(current, "recovery_required", `start_failed:${error._tag}`).pipe(Effect.ignore)
+            }
+            return yield* Effect.fail(error)
+          }),
+        ),
+      )
+    })
+
+    const status: Interface["status"] = Effect.fn("FacadeActivity.status")(function* (input) {
+      const limit = Math.max(1, Math.min(input.limit ?? STATUS_LIMIT_CEILING, STATUS_LIMIT_CEILING))
+      const rows = yield* listFacadeRows(input.sessionID, input.subkind, limit)
+      const converged: FacadeStatusEntry[] = []
+      for (const row of rows) {
+        const current = yield* converge(row)
+        const ref: Record<string, string> = {}
+        if (current.subkind === "task") {
+          const run = yield* taskRunForFacade(current)
+          if (run) {
+            ref.runID = run.run_id
+            ref.childSessionID = run.child_session_id
+            ref.runState = run.state
+          }
+        } else if (current.subkind === "goal") {
+          const snapshot = goals
+            ? yield* goals.status(current.parent_session_id).pipe(Effect.catchCause(() => Effect.succeed(null)))
+            : null
+          if (snapshot) {
+            ref.goalID = snapshot.goalId
+            ref.phase = snapshot.phase
+          }
+        } else {
+          const job = background
+            ? yield* background.get(current.activity_id).pipe(Effect.catchCause(() => Effect.succeed(undefined)))
+            : undefined
+          if (job) {
+            ref.jobID = job.id
+            ref.jobStatus = job.status
+          }
+        }
+        converged.push({
+          activityID: current.activity_id,
+          subkind: current.subkind,
+          state: current.state,
+          reason: current.reason_code ?? undefined,
+          createdAt: current.created_at,
+          settledAt: current.settled_at ?? undefined,
+          objective: current.objective_text ? applyResultBound(current.objective_text, 200).text : undefined,
+          ref,
+        })
+      }
+      return converged
+    })
+
+    const result: Interface["result"] = Effect.fn("FacadeActivity.result")(function* (input) {
+      const row = yield* latestFacadeRow(input.sessionID, input.subkind)
+      if (!row) return yield* Effect.fail(new FacadeActivityNotFound(input))
+      const current = yield* converge(row)
+      const maxChars = flags.subagentOutputMaxChars
+      const summary = current.objective_text ? applyResultBound(current.objective_text, maxChars) : undefined
+      if (current.state === "active") {
+        return {
+          activityID: current.activity_id,
+          subkind: current.subkind,
+          terminal: false,
+          state: current.state,
+          summary: summary?.text,
+          truncated: summary?.truncated ?? false,
+        }
+      }
+      let truncated = summary?.truncated ?? false
+      let receipt: Record<string, unknown> | undefined
+      let verdict: unknown
+      let phase: string | undefined
+      if (current.subkind === "task") {
+        const run = yield* taskRunForFacade(current)
+        if (run) {
+          const output = run.output ? applyResultBound(run.output, maxChars) : undefined
+          truncated = truncated || (output?.truncated ?? false)
+          receipt = {
+            runID: run.run_id,
+            childSessionID: run.child_session_id,
+            runState: run.state,
+            reason: run.reason ?? undefined,
+            output: output?.text,
+          }
+        }
+      } else if (current.subkind === "goal") {
+        const snapshot = goals
+          ? yield* goals.status(current.parent_session_id).pipe(Effect.catchCause(() => Effect.succeed(null)))
+          : null
+        phase = snapshot?.phase
+      } else {
+        const job = background
+          ? yield* background.get(current.activity_id).pipe(Effect.catchCause(() => Effect.succeed(undefined)))
+          : undefined
+        if (job?.output) {
+          const bounded = applyResultBound(job.output, maxChars)
+          truncated = truncated || bounded.truncated
+          try {
+            verdict = JSON.parse(job.output)
+          } catch {
+            verdict = bounded.text
+          }
+        }
+      }
+      return {
+        activityID: current.activity_id,
+        subkind: current.subkind,
+        terminal: true,
+        state: current.state,
+        reason: current.reason_code ?? undefined,
+        summary: summary?.text,
+        ...(receipt ? { receipt } : {}),
+        ...(verdict !== undefined ? { verdict } : {}),
+        ...(phase !== undefined ? { phase } : {}),
+        truncated,
+      }
+    })
+
+    const control: Interface["control"] = Effect.fn("FacadeActivity.control")(function* (input) {
+      const row = yield* latestFacadeRow(input.sessionID, input.subkind)
+      if (!row) return yield* Effect.fail(new FacadeActivityNotFound({ sessionID: input.sessionID, subkind: input.subkind }))
+
+      let outcome: FacadeControlResult
+      if (input.subkind === "goal") {
+        if (!goals)
+          return yield* Effect.fail(
+            new FacadeActivityRunnerUnavailable({ subkind: "goal", reason: "GoalManager service unavailable" }),
+          )
+        if (input.action === "pause") {
+          const applied = yield* goals.pause(input.sessionID)
+          outcome = { applied, subkind: "goal", action: "pause", detail: applied ? "goal paused" : "no running goal to pause" }
+        } else if (input.action === "resume") {
+          const applied = yield* goals.resume(input.sessionID)
+          outcome = { applied, subkind: "goal", action: "resume", detail: applied ? "goal resumed" : "no paused goal to resume" }
+        } else if (input.action === "stop") {
+          const applied = yield* goals.stop(input.sessionID)
+          outcome = { applied, subkind: "goal", action: "stop", detail: applied ? "goal stop requested" : "no active goal to stop" }
+        } else if (input.action === "steer") {
+          const text = input.message?.trim()
+          if (!text)
+            return yield* Effect.fail(new FacadeActivityInvalidInput({ reason: "steer requires a non-empty message" }))
+          if (!steerBuffer)
+            return yield* Effect.fail(
+              new FacadeActivityRunnerUnavailable({ subkind: "goal", reason: "steer buffer unavailable" }),
+            )
+          const admitted = yield* steerBuffer
+            .admit({
+              sessionID: SessionID.make(input.sessionID),
+              prompt: Prompt.make({ text }),
+              delivery: GoalDriver.GOAL_STEER_DELIVERY,
+            })
+            .pipe(
+              Effect.mapError(
+                (error) => new FacadeActivityInvalidInput({ reason: `steer admission refused: ${error._tag}` }),
+              ),
+            )
+          outcome = { applied: true, subkind: "goal", action: "steer", detail: `steer admitted as ${admitted.id}` }
+        } else {
+          return yield* Effect.fail(
+            new FacadeActivityUnsupportedControl({
+              subkind: "goal",
+              action: input.action,
+              reason: "goal supports pause/resume/stop/steer",
+            }),
+          )
+        }
+      } else if (input.subkind === "task") {
+        // Honest control-plane gap: the durable task surface only offers close (best-effort for
+        // active runs, immediate for queued/admitted). pause/resume/steer are NOT fabricated —
+        // callers fall back to stop.
+        if (input.action !== "stop")
+          return yield* Effect.fail(
+            new FacadeActivityUnsupportedControl({
+              subkind: "task",
+              action: input.action,
+              reason: "task facade supports only stop (delegates to durable task_close); pause/resume/steer are not available",
+            }),
+          )
+        const run = yield* taskRunForFacade(row)
+        if (!run)
+          outcome = { applied: false, subkind: "task", action: "stop", detail: "no task run recorded for this facade" }
+        else {
+          const closeResult = yield* closeTask({
+            childSessionID: SessionID.make(run.child_session_id),
+            parentSessionID: SessionID.make(row.parent_session_id),
+            reason: input.reason ?? "facade_stop",
+          }).pipe(
+            Effect.provideService(Database.Service, database),
+            Effect.mapError(
+              (error) =>
+                new FacadeActivityConflict({
+                  sessionID: row.parent_session_id,
+                  subkind: "task",
+                  reason: `task close refused: ${error._tag}`,
+                }),
+            ),
+          )
+          outcome = {
+            applied: closeResult.closed,
+            subkind: "task",
+            action: "stop",
+            detail: closeResult.closed
+              ? "task close requested; active runs settle at the next provider boundary"
+              : "task has no open run (already settled or closed)",
+          }
+        }
+      } else {
+        if (input.action !== "stop")
+          return yield* Effect.fail(
+            new FacadeActivityUnsupportedControl({
+              subkind: "panel",
+              action: input.action,
+              reason: "panel facade supports only stop (cancels the background consult job)",
+            }),
+          )
+        if (!background)
+          return yield* Effect.fail(
+            new FacadeActivityRunnerUnavailable({ subkind: "panel", reason: "background job service unavailable" }),
+          )
+        const cancelled = yield* background.cancel(row.activity_id)
+        outcome = {
+          applied: cancelled !== undefined,
+          subkind: "panel",
+          action: "stop",
+          detail: cancelled ? "panel consult job cancelled" : "no running panel job to cancel",
+        }
+      }
+
+      // Best-effort eager convergence so a stop that immediately settles the domain (queued task
+      // close, goal stop) also settles the facade row without waiting for the next read.
+      const current = yield* readFacadeRow(row.activity_id)
+      if (current) yield* converge(current)
+      return outcome
+    })
+
+    return Service.of({ start, status, result, control })
+  },
+)
+
+export const layer = Layer.effect(Service, build)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(Layer.provide(Database.defaultLayer), Layer.provide(RuntimeFlags.defaultLayer)),
+)
+
+export * as FacadeActivity from "./facade-activity"
diff --git a/packages/deepagent-code/src/session/goal-manager.ts b/packages/deepagent-code/src/session/goal-manager.ts
index 459ae120..db95b8ae 100644
--- a/packages/deepagent-code/src/session/goal-manager.ts
+++ b/packages/deepagent-code/src/session/goal-manager.ts
@@ -629,6 +629,7 @@ export const layer = Layer.effect(
         // (same shared index as the tool path + the first driver) so the resumed loop's plan reads/writes
         // stay coherent with any concurrent `plan` tool write on the same session.
         const store = DocumentStore.shared(goalStoreRoot(sessionID))
+        const session = yield* sessions.get(SessionID.make(sessionID)).pipe(Effect.orDie)
 
         // V4.1 §N DUAL-PATH resume. flag ON ⇒ RE-SEED the event chain rather than starting a BackgroundJob.
         // The paused command consumed the current normal cursor key without advancing state. Resume keeps
@@ -645,6 +646,10 @@ export const layer = Layer.effect(
                 planDocId: c.planDocId,
                 seq: tick?.seq ?? 0,
                 expectedPlanVersion,
+                // FEATURE-003-407 residual: re-stamp the real workspace id on resume too — the consumer
+                // chain carries it from the PAYLOAD, so without this the resumed chain (and its quiet-hours
+                // gate) would silently lose the workspace and degrade to the "" global fallback.
+                ...(session.workspaceID != null ? { workspaceID: String(session.workspaceID) } : {}),
               }),
             )
             .pipe(Effect.ignore)
@@ -652,7 +657,6 @@ export const layer = Layer.effect(
           return true
         }
 
-        const session = yield* sessions.get(SessionID.make(sessionID)).pipe(Effect.orDie)
         // Resume can't run without a model; if none resolves, don't crash — just report "not resumed".
         const modelOpt = yield* resolveGoalModel(session).pipe(Effect.option)
         if (Option.isNone(modelOpt)) return false
diff --git a/packages/deepagent-code/src/session/goal-tick-consumer.ts b/packages/deepagent-code/src/session/goal-tick-consumer.ts
index 85c48627..15429536 100644
--- a/packages/deepagent-code/src/session/goal-tick-consumer.ts
+++ b/packages/deepagent-code/src/session/goal-tick-consumer.ts
@@ -105,7 +105,13 @@ export const tickCommand = (request: {
 }): DeepAgentEvent.PublishInput => ({
   type: LMNEvents.GOAL_TICK_REQUESTED,
   source: "system",
-  workspaceID: request.sessionID,
+  // FEATURE-003-407 residual: the durable event row's workspace_id MUST be the REAL workspace id, not
+  // the sessionID. The bus's groupsFor routes workspace-bound consumer groups (workspace_id != "") by
+  // this column, so a sessionID here misroutes the event to zero tenants and poisons per-workspace
+  // queries. The real id travels in `request.workspaceID` (stamped by goal-manager from the session);
+  // when it is genuinely unavailable (legacy commands), fall back to "" — the bus's GLOBAL semantics
+  // (a "" row is owed only to global groups, same as any cross-workspace event).
+  workspaceID: request.workspaceID ?? "",
   actorID: request.sessionID,
   // §N: the command is the goal's own work — normal priority; it is NOT an approval-queue candidate.
   priority: "normal",
diff --git a/packages/deepagent-code/src/session/llm.ts b/packages/deepagent-code/src/session/llm.ts
index fca354dc..6cb60db8 100644
--- a/packages/deepagent-code/src/session/llm.ts
+++ b/packages/deepagent-code/src/session/llm.ts
@@ -821,6 +821,9 @@ const live: Layer.Layer<
           headers: prepared.headers,
           abort: input.abort,
           metadata: prepared.metadata,
+          // UPD-002: wire-level structured output travels through the native
+          // runtime only; the AI SDK runtime keeps the synthetic-tool path.
+          responseFormat: prepared.responseFormat,
           durableAttempt: input.durableAttempt,
           requestSeal: requestReceipt
             ? ({ wireHash }) =>
diff --git a/packages/deepagent-code/src/session/llm/native-request.ts b/packages/deepagent-code/src/session/llm/native-request.ts
index 74a2c532..f88cb4ec 100644
--- a/packages/deepagent-code/src/session/llm/native-request.ts
+++ b/packages/deepagent-code/src/session/llm/native-request.ts
@@ -9,6 +9,7 @@ import {
   OpenAICompatible,
   OpenRouter,
 } from "@deepagent-code/llm/providers/compat"
+import { byProvider as OpenAICompatibleProfiles } from "@deepagent-code/llm/providers/openai-compatible-profile"
 import type { ModelMessage } from "ai"
 import type { Provider } from "@/provider/provider"
 import { isRecord } from "@/util/record"
@@ -33,6 +34,9 @@ export type RequestInput = {
   readonly providerOptions?: LLMRequest["providerOptions"]
   readonly headers?: Record<string, string>
   readonly metadata?: LLMRequest["metadata"]
+  // UPD-002: wire-level structured output (json_schema text.format). Only set
+  // when the turn takes the wire path — see LLMRequestPrep.shouldUseWireStructuredOutput.
+  readonly responseFormat?: { readonly name: string; readonly schema: Record<string, unknown> }
 }
 
 const providerMetadata = (value: unknown): ProviderMetadata | undefined => {
@@ -169,12 +173,20 @@ export const model = (input: Provider.Model | RequestInput, headers?: Record<str
   if (model.api.npm === "@ai-sdk/anthropic") return Anthropic.configure(options).model(model.api.id)
   if (model.api.npm === "@ai-sdk/google") return Google.configure(options).model(model.api.id)
   if (model.api.npm === "@ai-sdk/amazon-bedrock") return AmazonBedrock.configure(options).model(model.api.id)
-  if (model.api.npm === "@ai-sdk/openai-compatible")
-    return OpenAICompatible.configure({
+  if (model.api.npm === "@ai-sdk/openai-compatible") {
+    const configured = OpenAICompatible.configure({
       ...options,
       provider: String(model.providerID),
       baseURL: requireBaseURL(model, url),
-    }).model(model.api.id)
+    })
+    // Capability detection lives on the compatible profile: families that
+    // also serve the Responses API (currently deepseek) branch to the
+    // Responses route; everyone else stays on the Chat route.
+    const compatibleModel = OpenAICompatibleProfiles[String(model.providerID)]?.supportsResponses
+      ? configured.responses
+      : configured.chat
+    return compatibleModel(model.api.id)
+  }
   if (model.api.npm === "@openrouter/ai-sdk-provider") return OpenRouter.configure(options).model(model.api.id)
   throw new Error(`Native LLM request adapter does not support provider package ${model.api.npm}`)
 }
@@ -192,6 +204,11 @@ export const request = (input: RequestInput) => {
     generation: generation(input),
     providerOptions: input.providerOptions,
     metadata: input.metadata,
+    // UPD-002: lower the prepared wire format onto the canonical request so
+    // the Responses protocol emits `text.format` and validates the output.
+    responseFormat: input.responseFormat
+      ? { type: "json", name: input.responseFormat.name, schema: input.responseFormat.schema as JsonSchema }
+      : undefined,
   })
 }
 
diff --git a/packages/deepagent-code/src/session/llm/native-runtime.ts b/packages/deepagent-code/src/session/llm/native-runtime.ts
index 8e5c1056..9d33980b 100644
--- a/packages/deepagent-code/src/session/llm/native-runtime.ts
+++ b/packages/deepagent-code/src/session/llm/native-runtime.ts
@@ -44,6 +44,8 @@ type StreamInput = {
   readonly headers: Record<string, string>
   readonly abort: AbortSignal
   readonly metadata?: Record<string, unknown>
+  // UPD-002: wire-level structured output forwarded from LLMRequestPrep.Prepared.
+  readonly responseFormat?: { readonly name: string; readonly schema: Record<string, unknown> }
   readonly durableAttempt?: boolean
   readonly requestSeal?: RequestExecutor.RequestSeal["seal"]
 }
@@ -61,9 +63,13 @@ function statusWithFetch(
     providerID !== "openai" &&
     providerID !== "anthropic" &&
     providerID !== "deepagent" &&
+    providerID !== "deepseek" &&
     !providerID.startsWith("deepagent-code")
   )
-    return { type: "unsupported", reason: "provider is not openai, deepagent-code, anthropic, or deepagent" }
+    return {
+      type: "unsupported",
+      reason: "provider is not openai, deepagent-code, anthropic, deepagent, or deepseek",
+    }
   const npm = input.model.api.npm
   if (npm !== "@ai-sdk/openai" && npm !== "@ai-sdk/openai-compatible" && npm !== "@ai-sdk/anthropic")
     return { type: "unsupported", reason: "provider package is not OpenAI, OpenAI-compatible, or Anthropic" }
@@ -116,6 +122,7 @@ export function stream(input: StreamInput): StreamResult {
     providerOptions: ProviderTransform.providerOptions(input.model, input.providerOptions ?? {}),
     headers: { ...providerHeaders(input.provider.options.headers), ...input.headers },
     metadata: input.metadata,
+    responseFormat: input.responseFormat,
   })
   const stream = Stream.scoped(
     Stream.unwrap(
diff --git a/packages/deepagent-code/src/session/llm/request.ts b/packages/deepagent-code/src/session/llm/request.ts
index 8bc76fb2..28692fa6 100644
--- a/packages/deepagent-code/src/session/llm/request.ts
+++ b/packages/deepagent-code/src/session/llm/request.ts
@@ -36,9 +36,78 @@ type McpServerRef = AgentGateway.McpServerRef
 import { jsonSchema, tool as aiTool, type ModelMessage, type Tool } from "ai"
 import type { Plugin } from "@/plugin"
 import { mergeDeep } from "remeda"
+import { byProvider as OpenAICompatibleProfiles } from "@deepagent-code/llm/providers/openai-compatible-profile"
 
 const USER_AGENT = `deepagent-code/${InstallationVersion}`
 
+// =============================================================================
+// UPD-002: wire-level structured output capability detection
+// =============================================================================
+// Two INDEPENDENT capability facts (hard constraint: never assume Responses ⇒
+// wire structured output):
+//
+// 1. "Responses family" — does the model speak the OpenAI Responses API?
+//    Declared by the compatible profile (`supportsResponses`, e.g. deepseek)
+//    or by the npm package that only serves Responses (openai/azure).
+// 2. "wire structured text format" — does the route actually honor
+//    `text.format` json_schema? This is deliberately narrower than the family:
+//    a Responses-capable provider may still lack constrained text output.
+//
+// CANONICAL capability declaration (UPD-002 residual): openai-compatible
+// families declare it on their profile (`supportsStructuredTextFormat`,
+// openai-compatible-profile.ts) — never assumed from Responses support. The
+// dedicated OpenAI/Azure packages are the reference Responses implementations
+// the wire lowering targets, so they are inherently format-capable. No
+// compatible family advertises it today (deepseek serves Responses but NOT
+// constrained `text.format`), so opting one in is a one-line profile flag,
+// not a code change here.
+const responsesFamily = (model: Provider.Model): boolean =>
+  model.api.npm === "@ai-sdk/openai" ||
+  model.api.npm === "@ai-sdk/azure" ||
+  (model.api.npm === "@ai-sdk/openai-compatible" &&
+    OpenAICompatibleProfiles[String(model.providerID)]?.supportsResponses === true)
+
+const supportsStructuredTextFormat = (model: Provider.Model): boolean => {
+  if (model.api.npm === "@ai-sdk/openai" || model.api.npm === "@ai-sdk/azure") return true
+  if (model.api.npm === "@ai-sdk/openai-compatible")
+    return OpenAICompatibleProfiles[String(model.providerID)]?.supportsStructuredTextFormat === true
+  return false
+}
+
+/**
+ * UPD-002: decide whether this turn delivers json_schema output through the
+ * wire (`text.format`) instead of the synthesized StructuredOutput tool.
+ *
+ * Requirements for wire mode — ALL must hold:
+ * - the user requested json_schema output
+ * - the turn is NOT a structured finalizer (finalizers keep the bounded
+ *   synthetic-tool semantics: FINALIZER_ATTEMPTS / retryCount / allow_text)
+ * - the native runtime will actually carry the request (wire lowering lives
+ *   in @deepagent-code/llm's Responses protocol; the AI SDK runtime has no
+ *   delivery path yet)
+ * - the model is a Responses family AND independently format-capable
+ *
+ * prompt.ts and prepare() must agree on this decision (prompt.ts decides
+ * whether to inject the synthetic tool; prepare() decides whether to lower
+ * `responseFormat`), so both call this single helper.
+ */
+export function shouldUseWireStructuredOutput(input: {
+  readonly user: SessionV1.User
+  readonly model: Provider.Model
+  readonly flags: RuntimeFlags.Info
+}): boolean {
+  if (input.user.format?.type !== "json_schema") return false
+  if (isStructuredFinalizerMetadata(input.user.metadata)) return false
+  if (!input.flags.experimentalNativeLlm) return false
+  return responsesFamily(input.model) && supportsStructuredTextFormat(input.model)
+}
+
+function isStructuredFinalizerMetadata(metadata: unknown): boolean {
+  if (!isRecord(metadata)) return false
+  if (!isRecord(metadata.deepagent)) return false
+  return isRecord(metadata.deepagent.structured_finalizer)
+}
+
 type PrepareInput = {
   readonly user: SessionV1.User
   readonly sessionID: string
@@ -83,6 +152,10 @@ export type Prepared = {
   readonly messageTransformOptions: Record<string, any>
   readonly headers: Record<string, string>
   readonly releasedKnowledgeSelectedRefs: readonly DocumentRef[]
+  // UPD-002: wire-level structured output. Set only when the turn takes the
+  // wire path (see shouldUseWireStructuredOutput); the native runtime lowers
+  // it onto LLMRequest.responseFormat → Responses `text.format`.
+  readonly responseFormat?: { readonly name: string; readonly schema: Record<string, unknown> }
 }
 
 const mergeOptions = (target: Record<string, any>, source: Record<string, any> | undefined): Record<string, any> =>
@@ -325,7 +398,11 @@ export const prepare = Effect.fn("LLMRequestPrep.prepare")(function* (input: Pre
   }
 
   const instance = yield* InstanceState.context
-  const metadata = prepareMetadata(input, tools, instance.directory)
+  // UPD-002: wire structured-output decision. Must match prompt.ts's decision
+  // (single helper): wire ⇒ no synthesized StructuredOutput tool, and the
+  // format travels here instead; synthetic ⇒ responseFormat stays unset.
+  const wireStructuredOutput = shouldUseWireStructuredOutput(input)
+  const metadata = prepareMetadata(input, tools, instance.directory, wireStructuredOutput)
 
   const deepagentCodeProjectID = input.model.providerID.startsWith("deepagent-code") ? instance.project.id : undefined
 
@@ -357,6 +434,9 @@ export const prepare = Effect.fn("LLMRequestPrep.prepare")(function* (input: Pre
       ...headers,
     },
     releasedKnowledgeSelectedRefs,
+    ...(wireStructuredOutput && input.user.format?.type === "json_schema"
+      ? { responseFormat: { name: "structured_output", schema: input.user.format.schema } }
+      : {}),
   } satisfies Prepared
   if (input.flags.assembledRequestFingerprint)
     emitAssembledRequestFingerprint(input, prepared, validationCommands, volatileContextKind)
@@ -444,6 +524,7 @@ const prepareMetadata = (
   input: PrepareInput,
   tools: Record<string, Tool>,
   workspacePath: string,
+  wireStructuredOutput: boolean,
 ): Record<string, unknown> => {
   const agentMode = deepAgentAgentModeOverride(input.user.metadata)
   const deepagent =
@@ -459,6 +540,11 @@ const prepareMetadata = (
       parentSessionID: input.parentSessionID,
       agent: input.agent.name,
       workspacePath,
+      // UPD-002 receipt: record which structured-output delivery mode this
+      // request uses (wire text.format vs synthesized StructuredOutput tool).
+      ...(input.user.format?.type === "json_schema"
+        ? { structured_output_mode: wireStructuredOutput ? "wire_format" : "synthetic_tool" }
+        : {}),
     },
     deepagent: {
       ...(typeof deepagent.goal_id === "string" ? { goal_id: deepagent.goal_id } : {}),
diff --git a/packages/deepagent-code/src/session/llm/tool-pairing.ts b/packages/deepagent-code/src/session/llm/tool-pairing.ts
new file mode 100644
index 00000000..ce1a1d0b
--- /dev/null
+++ b/packages/deepagent-code/src/session/llm/tool-pairing.ts
@@ -0,0 +1,157 @@
+import type { ModelMessage } from "ai"
+
+/**
+ * Wire text used when synthesizing a tool result for a tool call that never
+ * got one. Mirrors the interrupted-tool synthesis in message-v2.ts
+ * ("[Tool execution was interrupted]") so the model sees one consistent style.
+ */
+export const INTERRUPTED_TOOL_ERROR_TEXT = "[Tool execution was interrupted]"
+
+export interface RepairReport {
+  /** call_ids that had no result → a synthetic error result was inserted. */
+  readonly synthesizedResults: string[]
+  /** call_ids of orphan results (no preceding call) that were stripped. */
+  readonly strippedOrphanResults: string[]
+  /** call_ids dropped as duplicates (a repeated call or a repeated result; first wins). */
+  readonly droppedDuplicates: string[]
+  /** Number of tool→user gaps bridged with a synthetic assistant turn. */
+  bridgedToolUserGaps: number
+}
+
+export const emptyRepairReport = (): RepairReport => ({
+  synthesizedResults: [],
+  strippedOrphanResults: [],
+  droppedDuplicates: [],
+  bridgedToolUserGaps: 0,
+})
+
+export const repairReportIsEmpty = (report: RepairReport): boolean =>
+  report.synthesizedResults.length === 0 &&
+  report.strippedOrphanResults.length === 0 &&
+  report.droppedDuplicates.length === 0 &&
+  report.bridgedToolUserGaps === 0
+
+export interface RepairOptions {
+  /**
+   * After repair, if a tool message ends up directly followed by a user
+   * message, insert a synthetic assistant "Done." between them. This mirrors
+   * the tool→user sequence fix applied by the mistral scrub in
+   * transform.normalizeMessages, which runs BEFORE this repairer and cannot
+   * see the synthetic tool messages this repairer inserts.
+   */
+  bridgeToolUserGap?: boolean
+  /**
+   * UPD-001 telemetry: optional caller-provided collector populated in place
+   * with exactly what the repairer changed. The receipt's `call_ids` records
+   * the PRE-repair projection, so a repaired wire body diverges from it; this
+   * report is what makes that divergence explainable (which call_ids were
+   * synthesized / stripped / deduped). Omitted → no collection (pure repair).
+   */
+  report?: RepairReport
+}
+
+/**
+ * Repair tool_use/tool_result pairing so providers never receive:
+ *
+ * 1. an assistant tool-call with no matching tool-result → a synthetic error
+ *    result is inserted directly after the message carrying the call
+ * 2. an orphan tool-result whose callID never appeared as a call → stripped
+ * 3. duplicate callIDs → only the first call and first result survive
+ *
+ * Constraints:
+ * - Pure function: no logging, no I/O, no receipt-semantics changes; input
+ *   messages are never mutated (callers may log around it if needed).
+ * - MUST run after transform.ts normalizeMessages: the mistral toolCallId
+ *   scrub truncates IDs to 9 alphanumeric chars and can collide distinct IDs
+ *   into duplicates that only exist post-scrub, so dedup has to come last.
+ */
+export function repairToolPairing(msgs: ModelMessage[], options: RepairOptions = {}): ModelMessage[] {
+  const report = options.report
+  const seenCallIDs = new Set<string>()
+  const seenResultIDs = new Set<string>()
+  // Surviving, not-yet-matched calls: callID -> { toolName, index of message holding the call }
+  const unmatched = new Map<string, { toolName: string; messageIndex: number }>()
+
+  // Pass 1: decide which parts survive (dedup + orphan stripping) without
+  // emitting anything. A result can legally appear several messages after
+  // its call, so missing-result synthesis can only be decided after the full
+  // scan.
+  const planned = msgs.map((msg, messageIndex) => {
+    if (!Array.isArray(msg.content)) return { msg, content: undefined, changed: false }
+    let changed = false
+    const content = msg.content.filter((part) => {
+      if (part.type === "tool-call") {
+        if (seenCallIDs.has(part.toolCallId)) {
+          changed = true
+          report?.droppedDuplicates.push(part.toolCallId)
+          return false // duplicate callID: keep the first
+        }
+        seenCallIDs.add(part.toolCallId)
+        unmatched.set(part.toolCallId, { toolName: part.toolName, messageIndex })
+        return true
+      }
+      if (part.type === "tool-result") {
+        if (!seenCallIDs.has(part.toolCallId)) {
+          changed = true
+          report?.strippedOrphanResults.push(part.toolCallId)
+          return false // orphan result: no preceding call
+        }
+        if (seenResultIDs.has(part.toolCallId)) {
+          changed = true
+          report?.droppedDuplicates.push(part.toolCallId)
+          return false // duplicate result for one call: keep the first
+        }
+        seenResultIDs.add(part.toolCallId)
+        unmatched.delete(part.toolCallId)
+        return true
+      }
+      return true
+    })
+    return { msg, content, changed }
+  })
+
+  // Pass 2: rebuild, inserting synthetic results directly after the message
+  // carrying the call so the assistant tool_use is always immediately
+  // followed by its result.
+  const output: ModelMessage[] = []
+  planned.forEach(({ msg, content, changed }, messageIndex) => {
+    if (content === undefined) {
+      output.push(msg)
+      return
+    }
+    // If every part was stripped (orphans/duplicates only), drop the message
+    // entirely — an empty content array is rejected by providers. Unmatched
+    // calls cannot live here: a surviving call always survives the filter.
+    if (content.length === 0) return
+    output.push(changed ? ({ ...msg, content } as ModelMessage) : msg)
+
+    const missing = [...unmatched.entries()].filter(([, info]) => info.messageIndex === messageIndex)
+    if (missing.length === 0) return
+    if (report) for (const [toolCallId] of missing) report.synthesizedResults.push(toolCallId)
+    output.push({
+      role: "tool",
+      content: missing.map(([toolCallId, info]) => ({
+        type: "tool-result" as const,
+        toolCallId,
+        toolName: info.toolName,
+        output: { type: "error-text" as const, value: INTERRUPTED_TOOL_ERROR_TEXT },
+      })),
+    })
+  })
+
+  if (!options.bridgeToolUserGap) return output
+
+  // normalizeMessages already bridged every pre-existing tool→user gap for
+  // mistral, so any gap left here was introduced by this repairer.
+  const bridged: ModelMessage[] = []
+  for (let i = 0; i < output.length; i++) {
+    bridged.push(output[i])
+    if (output[i].role === "tool" && output[i + 1]?.role === "user") {
+      bridged.push({ role: "assistant", content: [{ type: "text", text: "Done." }] })
+      if (report) report.bridgedToolUserGaps += 1
+    }
+  }
+  return bridged
+}
+
+export * as ToolPairing from "./tool-pairing"
diff --git a/packages/deepagent-code/src/session/processor.ts b/packages/deepagent-code/src/session/processor.ts
index 2236a38f..6d197dca 100644
--- a/packages/deepagent-code/src/session/processor.ts
+++ b/packages/deepagent-code/src/session/processor.ts
@@ -487,6 +487,9 @@ export type ProcessorDecision =
 
 export interface Handle {
   readonly message: SessionV1.Assistant
+  // BUG-407-012 gap C: outcome of the pre-stream snapshot capture, so the turn
+  // boundary layer can persist `snapshot_finished` / `snapshot_degraded` evidence.
+  readonly snapshotOutcome: Snapshot.TrackOutcome
   readonly updateToolCall: (
     toolCallID: string,
     update: (part: SessionV1.ToolPart) => SessionV1.ToolPart,
@@ -534,6 +537,11 @@ type Input = {
    */
   sequenceTracker?: ToolSequenceTracker
   planTracker?: PlanProtocolTracker
+  /**
+   * BUG-407-012 gap C: legacy activity identity for snapshot budget attribution.
+   * Absent when the caller has no activity binding (legacy paths).
+   */
+  activityID?: string
   loopPolicy?: "ask" | "error"
   noProgressLimit?: number
 }
@@ -601,7 +609,11 @@ export const layer = Layer.effect(
       // Pre-capture snapshot before the LLM stream starts. The AI SDK
       // may execute tools internally before emitting start-step events,
       // so capturing inside the event handler can be too late.
-      const initialSnapshot = yield* snapshot.track()
+      const snapshotOutcome = yield* snapshot.trackOutcome({
+        sessionId: input.sessionID,
+        ...(input.activityID ? { activityId: input.activityID } : {}),
+      })
+      const initialSnapshot = snapshotOutcome.hash
       const ctx: ProcessorContext = {
         assistantMessage: input.assistantMessage,
         sessionID: input.sessionID,
@@ -680,7 +692,6 @@ export const layer = Layer.effect(
 
       const observeDurableTurn = Effect.fn("SessionProcessor.observeDurableTurn")(function* () {
         if (
-          flags.activityAuthority !== "durable" ||
           ctx.loopPolicy !== "ask" ||
           ctx.assistantMessage.summary ||
           ctx.activityToolNames.size === 0
@@ -689,10 +700,17 @@ export const layer = Layer.effect(
         const activity = yield* SessionPromptIntent.activeActivityForSession(ctx.sessionID).pipe(
           Effect.provideService(Database.Service, database),
         )
-        if (!activity)
-          return yield* Effect.die(
-            new Error(`durable activity authority has no active legacy activity: ${ctx.sessionID}`),
-          )
+        if (!activity) {
+          // The durable authority governs ADMITTED legacy activities. A turn driven without an
+          // admitted activity (direct legacy loop entry, recovery edge windows, seeded history)
+          // keeps legacy semantics: policy evaluation still applies, but there is no durable
+          // objective/progress/no-progress governance to observe. Skipping here must not defect —
+          // dying would crash every un-admitted turn the moment any tool settles.
+          slog.warn("durable observation skipped: no active legacy activity for session", {
+            activityToolCount: ctx.activityToolNames.size,
+          })
+          return
+        }
         const current = yield* DeepAgentActivityAuthority.reconstruct({
           activityKind: "legacy",
           activityID: activity.activityID,
@@ -939,7 +957,7 @@ export const layer = Layer.effect(
             attachments: output.attachments,
           },
         })
-        if (flags.activityAuthority === "durable" && ctx.loopPolicy === "ask") {
+        if (ctx.loopPolicy === "ask") {
           const workspaceRevision = yield* snapshot.track()
           const resultFingerprint =
             match.part.tool && ctx.sequenceTracker
@@ -1033,7 +1051,7 @@ export const layer = Layer.effect(
             time: { start: match.part.state.time.start, end: Date.now() },
           },
         })
-        if (flags.activityAuthority === "durable" && ctx.loopPolicy === "ask") {
+        if (ctx.loopPolicy === "ask") {
           const workspaceRevision = yield* snapshot.track()
           const message = errorMessage(error)
           const evidenceFingerprint = Hash.sha256(
@@ -1436,24 +1454,6 @@ export const layer = Layer.effect(
                     }),
                   )
                 }
-                if (flags.activityAuthority === "durable") {
-                  ctx.sequenceTracker.setTriggered(detected.sequenceKey)
-                  return
-                }
-                const agent = yield* agents.get(ctx.assistantMessage.agent)
-                yield* permission.ask({
-                  permission: "doom_loop",
-                  patterns: [value.name],
-                  sessionID: ctx.assistantMessage.sessionID,
-                  metadata: {
-                    tool: value.name,
-                    input,
-                    period: detected.period,
-                    count: detected.count,
-                  },
-                  always: [value.name],
-                  ruleset: agent.permission,
-                })
                 ctx.sequenceTracker.setTriggered(detected.sequenceKey)
               }
               // Tracker handles all detection for this call; skip legacy path.
@@ -1498,18 +1498,8 @@ export const layer = Layer.effect(
                 }),
               )
             }
-
-            if (flags.activityAuthority === "durable") return
-
-            const agent = yield* agents.get(ctx.assistantMessage.agent)
-            yield* permission.ask({
-              permission: "doom_loop",
-              patterns: [value.name],
-              sessionID: ctx.assistantMessage.sessionID,
-              metadata: { tool: value.name, input },
-              always: [value.name],
-              ruleset: agent.permission,
-            })
+            // Interactive policies surface the doom loop through the durable no-progress authority
+            // (recorded on the activity), not through a permission prompt.
             return
           }
 
@@ -2223,6 +2213,7 @@ export const layer = Layer.effect(
         get message() {
           return ctx.assistantMessage
         },
+        snapshotOutcome,
         updateToolCall,
         completeToolCall,
         process,
diff --git a/packages/deepagent-code/src/session/prompt-intent.ts b/packages/deepagent-code/src/session/prompt-intent.ts
index 17222ddf..61f9a1d3 100644
--- a/packages/deepagent-code/src/session/prompt-intent.ts
+++ b/packages/deepagent-code/src/session/prompt-intent.ts
@@ -21,7 +21,10 @@ import {
   SessionLegacyActivityTable,
   SessionLegacyActivityTerminalTable,
 } from "./activity-sql"
-import { SessionActivityObjectiveTable } from "@deepagent-code/core/deepagent/activity-authority.sql"
+import {
+  SessionActivityObjectiveTable,
+  SessionActivityPermissionEffectDispatchTable,
+} from "@deepagent-code/core/deepagent/activity-authority.sql"
 import { SessionToolRequestReceiptTable } from "./tool-request-receipt.sql"
 import { SessionActivityOwner } from "./activity-owner"
 import { pause as pauseAtActivityCrashPoint } from "./activity-crash-test"
@@ -56,7 +59,15 @@ export type Receipt = {
   readonly intentID: string
   readonly sessionID: SessionID
   readonly source: Source
-  readonly state: "preparing" | "admitting" | "admitted" | "canceled" | "superseded" | "failed"
+  readonly state:
+    | "preparing"
+    | "awaiting_confirmation"
+    | "selected"
+    | "admitting"
+    | "admitted"
+    | "canceled"
+    | "superseded"
+    | "failed"
   readonly variant?: Variant
   readonly payloadHash?: string
   readonly delivery?: Delivery
@@ -729,6 +740,7 @@ export const materializeTurn = Effect.fn("SessionPromptIntent.materializeTurn")(
               .get()
               .pipe(Effect.orDie))?.generation ?? -1) + 1
           const runOwnerToken = input.run?.ownerToken ?? SessionActivityOwner.processOwnerToken
+          let steerAdmissionID: string | undefined
           if (!existingActivity) {
             const active = yield* tx
               .select()
@@ -741,13 +753,89 @@ export const materializeTurn = Effect.fn("SessionPromptIntent.materializeTurn")(
               )
               .get()
               .pipe(Effect.orDie)
-            if (active)
-              return yield* Effect.fail(
-                new Conflict({
-                  intentID: input.receipt.intentID,
-                  reason: `legacy activity ${active.activity_id} requires recovery before a new turn`,
-                }),
-              )
+            if (active) {
+              // BUG-008 third leak window — admission adoption (route a).
+              //
+              // A turn that dies AFTER the session went busy but BEFORE its own
+              // materialization transaction commits leaves nothing behind; yet a
+              // steer admitted inside that window sees no active activity and
+              // creates a PLACEHOLDER activity (trigger = the steer admission,
+              // intent run_now/pending, zero run rows). The dead turn's outer
+              // hooks own no run, and recoverActiveActivities deliberately skips
+              // the run_now/pending/no-run shape, so the placeholder would block
+              // every later admission with "requires recovery before a new turn".
+              //
+              // The task's original adoption condition (active activity triggered
+              // by the SAME intent messageID) is unreachable: materialization is a
+              // single atomic transaction, so a same-intent retry can never
+              // observe its own half-written activity. The actually-observed leak
+              // (live steer-boundary suite) is the steer placeholder above, so
+              // adoption is generalized to it. In-place reuse of the placeholder
+              // row is forbidden by the state machine (trigger_admission_id is
+              // immutable and session_legacy_activity_admission rejects UPDATEs),
+              // so adoption takes the undo-and-reattach form below. Route b
+              // (terminalize at the creation point) was rejected: the placeholder
+              // is created by steer.admit, which cannot know a concurrent turn
+              // will materialize; destroying it there would drop legal steers.
+              const placeholderAdmission = yield* tx
+                .select()
+                .from(SessionActivityAdmissionTable)
+                .where(eq(SessionActivityAdmissionTable.admission_id, active.trigger_admission_id))
+                .get()
+                .pipe(Effect.orDie)
+              const placeholderIntent = placeholderAdmission?.legacy_intent_id
+                ? yield* tx
+                    .select()
+                    .from(SessionIntentTable)
+                    .where(eq(SessionIntentTable.intent_id, placeholderAdmission.legacy_intent_id))
+                    .get()
+                    .pipe(Effect.orDie)
+                : undefined
+              const placeholderRun = yield* tx
+                .select({ runID: SessionLegacyActivityRunTable.run_id })
+                .from(SessionLegacyActivityRunTable)
+                .where(eq(SessionLegacyActivityRunTable.activity_id, active.activity_id))
+                .get()
+                .pipe(Effect.orDie)
+              const adoptable =
+                placeholderAdmission?.delivery === "steer" &&
+                placeholderIntent !== undefined &&
+                placeholderIntent.execution_state === "pending" &&
+                placeholderIntent.execution_claim_id === null &&
+                placeholderIntent.mutation_epoch === session.mutationEpoch &&
+                placeholderRun === undefined
+              if (!adoptable)
+                return yield* Effect.fail(
+                  new Conflict({
+                    intentID: input.receipt.intentID,
+                    reason: `legacy activity ${active.activity_id} requires recovery before a new turn`,
+                  }),
+                )
+              // The placeholder is a zero-footprint reservation: no run, no
+              // progress, no terminal, never claimed. Undo it (delete the
+              // membership row, then the activity row — both have no DELETE
+              // triggers and no surviving references) and re-attach the steer
+              // admission to this turn's activity below, which converges on
+              // EXACTLY the durable state the healthy race ordering produces
+              // (turn materializes first, steer attaches as role "steer"), so
+              // drain/freeze/cancel/progress semantics downstream are unchanged.
+              yield* tx
+                .delete(SessionLegacyActivityAdmissionTable)
+                .where(eq(SessionLegacyActivityAdmissionTable.activity_id, active.activity_id))
+                .run()
+                .pipe(Effect.orDie)
+              yield* tx
+                .delete(SessionLegacyActivityTable)
+                .where(
+                  and(
+                    eq(SessionLegacyActivityTable.activity_id, active.activity_id),
+                    eq(SessionLegacyActivityTable.state, "active"),
+                  ),
+                )
+                .run()
+                .pipe(Effect.orDie)
+              steerAdmissionID = active.trigger_admission_id
+            }
             const latest = yield* tx
               .select({ ordinal: max(SessionLegacyActivityTable.ordinal) })
               .from(SessionLegacyActivityTable)
@@ -792,6 +880,29 @@ export const materializeTurn = Effect.fn("SessionPromptIntent.materializeTurn")(
             return yield* Effect.fail(
               new Conflict({ intentID: input.receipt.intentID, reason: "activity trigger membership conflicts" }),
             )
+          if (steerAdmissionID) {
+            // BUG-008 third window adoption, final step: re-attach the orphaned
+            // steer admission as role "steer" on the adopting activity. The
+            // steer's intent stays run_now/pending and is claimed by this turn's
+            // run at drain time, exactly as in the healthy race ordering.
+            const latestMembership = yield* tx
+              .select({ ordinal: max(SessionLegacyActivityAdmissionTable.ordinal) })
+              .from(SessionLegacyActivityAdmissionTable)
+              .where(eq(SessionLegacyActivityAdmissionTable.activity_id, activityID))
+              .get()
+              .pipe(Effect.orDie)
+            yield* tx
+              .insert(SessionLegacyActivityAdmissionTable)
+              .values({
+                activity_id: activityID,
+                admission_id: steerAdmissionID,
+                ordinal: (latestMembership?.ordinal ?? 0) + 1,
+                role: "steer",
+                attached_at: now,
+              })
+              .run()
+              .pipe(Effect.orDie)
+          }
           const claimed = yield* tx
             .update(SessionIntentTable)
             .set({ execution_state: "claimed", execution_claim_id: runID, execution_claimed_at: now })
@@ -1732,6 +1843,43 @@ export const settleProgressOnly = Effect.fn("SessionPromptIntent.settleProgressO
     .pipe(Effect.orDie)
 })
 
+// The durable terminal guard (session_legacy_activity_permission_effect_terminal_guard) refuses to
+// move a legacy activity to a terminal state while one of its permission effect dispatches is still
+// `started` (and to `settled`/`interrupted` while one is `unknown`). On a host interrupt the
+// in-flight tool is concurrently finishing and settles its effect imminently; a caller that settles
+// the activity straight away races that settlement and dies on the guard. Wait for any `started`
+// effect to leave `started` before the caller picks the terminal state, reporting whether an
+// `unknown` (quarantined) effect remains so the caller can route to `recovery_required`.
+const PERMISSION_EFFECT_TERMINAL_WAIT_MS = 8_000
+export const awaitTerminalPermissionEffects = Effect.fn("SessionPromptIntent.awaitTerminalPermissionEffects")(
+  function* (input: { readonly activityID: string }) {
+    const { db } = yield* Database.Service
+    const deadline = Date.now() + PERMISSION_EFFECT_TERMINAL_WAIT_MS
+    while (true) {
+      const outstanding = yield* db
+        .select({ state: SessionActivityPermissionEffectDispatchTable.state })
+        .from(SessionActivityPermissionEffectDispatchTable)
+        .where(
+          and(
+            eq(SessionActivityPermissionEffectDispatchTable.activity_kind, "legacy"),
+            eq(SessionActivityPermissionEffectDispatchTable.activity_id, input.activityID),
+            inArray(SessionActivityPermissionEffectDispatchTable.state, ["started", "unknown"] as const),
+          ),
+        )
+        .all()
+        .pipe(Effect.orDie)
+      const started = outstanding.some((row) => row.state === "started")
+      if (!started) return { unresolvedUnknown: outstanding.length > 0, startedTimedOut: false }
+      if (Date.now() >= deadline)
+        return {
+          unresolvedUnknown: outstanding.some((row) => row.state === "unknown"),
+          startedTimedOut: true,
+        }
+      yield* Effect.sleep("25 millis")
+    }
+  },
+)
+
 export const finalizeActivityWithRevision = Effect.fn("SessionPromptIntent.finalizeActivityWithRevision")(
   function* (input: {
     readonly run: RunIdentity
diff --git a/packages/deepagent-code/src/session/prompt.ts b/packages/deepagent-code/src/session/prompt.ts
index 4d47c277..168ee6e6 100644
--- a/packages/deepagent-code/src/session/prompt.ts
+++ b/packages/deepagent-code/src/session/prompt.ts
@@ -47,6 +47,8 @@ import { SessionSummary } from "./summary"
 import { Snapshot } from "@/snapshot"
 import { NamedError } from "@deepagent-code/core/util/error"
 import { SessionProcessor } from "./processor"
+import { TurnStageEvidence } from "./turn-stage-evidence"
+import { TurnDeadlineWatchdog } from "./turn-deadline-watchdog"
 import { Tool } from "@/tool/tool"
 import { ToolInternal } from "@/tool/internal"
 import { Permission } from "@/permission"
@@ -85,6 +87,7 @@ import {
   Types,
 } from "effect"
 import * as EffectLogger from "@deepagent-code/core/effect/logger"
+import { KeyedMutex } from "@deepagent-code/core/effect/keyed-mutex"
 import { InstanceState } from "@/effect/instance-state"
 import {
   projectDurableSettledRun,
@@ -95,6 +98,7 @@ import {
   TaskTool,
   type TaskPromptOps,
 } from "@/tool/task"
+import { validateStructuredOutput } from "@/tool/task-structured-output"
 import { SessionRunState } from "./run-state"
 import { SessionSteer } from "./steer"
 import { SessionPromptIntent } from "./prompt-intent"
@@ -129,6 +133,7 @@ import {
 import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
 import { SessionProviderAttempt } from "@deepagent-code/core/context-federation/provider-attempt"
 import { ContextFederationExecutionParity } from "@deepagent-code/core/context-federation/execution-parity"
+import { ContextReconciliation } from "@deepagent-code/core/context-federation/reconciliation"
 import { Hash } from "@deepagent-code/core/util/hash"
 import { SessionFederatedContext } from "@/context-federation/session-context-runtime"
 import { ContextFederationReadiness } from "@/context-federation/readiness"
@@ -149,7 +154,7 @@ import {
 } from "@deepagent-code/core/session/prompt"
 import { Reference } from "@/reference/reference"
 import * as DateTime from "effect/DateTime"
-import { and, eq, exists, gt, inArray, isNull, max, notExists, notInArray, or } from "drizzle-orm"
+import { and, desc, eq, exists, gt, inArray, isNull, max, notExists, notInArray, or } from "drizzle-orm"
 import {
   SessionHistoryStateTable,
   SessionTable,
@@ -800,11 +805,17 @@ function buildStructuredOutputRuntimeTail(
   format: SessionV1.OutputFormat,
   finalizerMode: boolean,
   finalizerAllowsText = false,
+  wireFormat = false,
 ): string {
   if (finalizerAllowsText) {
     return "This is a bounded finalizer turn. Read the supplied research result and return exactly one JSON value. No research, Markdown, explanatory prose, or tool use is permitted."
   }
   if (format.type !== "json_schema") return ""
+  // UPD-002: wire mode — the provider enforces the schema via text.format, so
+  // the tail must NOT reference the (absent) StructuredOutput tool.
+  if (wireFormat) {
+    return "IMPORTANT: The user has requested structured output. Your final response text is schema-constrained by the provider. Reply with ONLY a single JSON value matching the required schema - no Markdown fences, prose, or wrapping."
+  }
   return [
     buildStructuredOutputSystemPrompt(format.schema),
     finalizerMode
@@ -1189,25 +1200,46 @@ export const layer = Layer.effect(
       yield* Effect.forEach(activities, publishActivityProjection, { discard: true })
     })
     const providerOwner = yield* SessionProviderOwner.Service
-    const providerOwnerToken = `${process.pid}:${randomUUID()}`
+    // BUG-407-012 root cause A: the process owner token is mutable. Sleeping past LeaseMs fences
+    // the startup token (correct fencing), and the maintenance loop below rotates to a successor
+    // generation instead of latching unhealthy forever. Every consumer must read the current token
+    // from `providerOwnerState` at use time — never capture a startup-time token constant.
+    const providerOwnerBase = `${process.pid}:${randomUUID()}`
+    const providerOwnerInitialToken = ContextFederationProviderOwnerRuntime.nextOwnerToken({
+      ownerBase: providerOwnerBase,
+      generation: 0,
+    })
     yield* providerOwner
       .register({
-        ownerToken: providerOwnerToken,
+        ownerToken: providerOwnerInitialToken,
         leaseMs: SessionProviderOwner.LeaseMs,
       })
       .pipe(Effect.orDie)
+    const providerOwnerState = yield* Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({
+      ownerToken: providerOwnerInitialToken,
+      generation: 0,
+    })
     const providerOwnerHealthy = yield* Ref.make(true)
-    yield* Effect.addFinalizer(() => providerOwner.release({ ownerToken: providerOwnerToken }).pipe(Effect.ignore))
-    yield* recoverProviderReceiptsOnStartup({ ownerToken: providerOwnerToken })
+    yield* Effect.addFinalizer(() =>
+      Ref.get(providerOwnerState).pipe(
+        Effect.flatMap((state) => providerOwner.release({ ownerToken: state.ownerToken })),
+        Effect.ignore,
+      ),
+    )
+    yield* recoverProviderReceiptsOnStartup({ ownerToken: providerOwnerInitialToken })
     yield* Effect.gen(function* () {
       while (yield* Ref.get(providerOwnerHealthy)) {
         const continued = yield* ContextFederationProviderOwnerRuntime.tick({
           owners: providerOwner,
-          ownerToken: providerOwnerToken,
+          owner: providerOwnerState,
+          ownerBase: providerOwnerBase,
           leaseMs: SessionProviderOwner.LeaseMs,
           healthy: providerOwnerHealthy,
           label: "provider",
-          recover: recoverProviderReceiptsOnStartup({ ownerToken: providerOwnerToken }),
+          recover: Effect.gen(function* () {
+            const current = yield* Ref.get(providerOwnerState)
+            yield* recoverProviderReceiptsOnStartup({ ownerToken: current.ownerToken })
+          }),
         })
         if (!continued) return
         yield* Effect.sleep(Duration.millis(SessionProviderOwner.LeaseMs / 3))
@@ -1216,6 +1248,35 @@ export const layer = Layer.effect(
       Effect.catchCause((cause) => Effect.logError(`provider owner maintenance failed: ${Cause.pretty(cause)}`)),
       Effect.forkScoped,
     )
+    // BUG-407-012 gap C (§8.3-3/4 conservative): optional watchdog that fails activities
+    // stuck before provider dispatch once the total deadline elapses without durable
+    // receipt/dispatch evidence. DEFAULT OFF; forked only when the flag is enabled. The
+    // sweep never throws (per-activity errors degrade to skipped outcomes) and reuses the
+    // existing terminalization path — no new recovery states.
+    if (flags.providerPreDispatchWatchdog)
+      yield* Effect.gen(function* () {
+        while (true) {
+          const outcomes = yield* TurnDeadlineWatchdog.sweep({
+            database,
+            deadlineMs: flags.providerPreDispatchDeadlineMs,
+          })
+          for (const outcome of outcomes)
+            if (outcome.kind === "failed")
+              yield* Effect.logWarning(
+                `pre-dispatch deadline watchdog failed stale activity ${outcome.activityID} (run ${outcome.runID})`,
+              )
+          yield* Effect.sleep(Duration.seconds(30))
+        }
+      }).pipe(
+        Effect.catchCause((cause) =>
+          Effect.logError(`pre-dispatch deadline watchdog failed: ${Cause.pretty(cause)}`),
+        ),
+        Effect.forkScoped,
+      )
+    // BUG-407-012 root cause A: a fenced lease no longer reaches this gate — rotation happens on
+    // the maintenance tick (LeaseMs/3 cadence, well inside one lease), so the successor token is
+    // live before the next prompt dispatch. `healthy` only latches false if the maintenance loop
+    // itself dies, which is the only condition that must keep rejecting prompts.
     const ensureProviderOwnerHealthy = Effect.gen(function* () {
       if (!(yield* Ref.get(providerOwnerHealthy)))
         return yield* Effect.die(new Error("provider owner runtime is unhealthy"))
@@ -1231,7 +1292,25 @@ export const layer = Layer.effect(
           : Effect.void,
       ),
     )
+    // BUG-003 restart recovery: settle federation activities left `active` by a dead run loop,
+    // mirroring the legacy recovery above (both run once at process start; without this the
+    // session's partial unique index stays locked and every new input attaches to the stale
+    // activity). Failures are logged, never fatal — startup must not die on best-effort cleanup.
+    if (federation) {
+      yield* federation.settleOrphanedActivities().pipe(
+        Effect.tap((count) =>
+          count > 0 ? Effect.logWarning(`settled ${count} orphaned federated activities after restart`) : Effect.void,
+        ),
+        Effect.catchCause((cause) =>
+          Effect.logWarning(`federated activity restart recovery failed: ${Cause.pretty(cause)}`),
+        ),
+      )
+    }
     const activeFederatedContexts = new Map<SessionID, SessionFederatedContext.Resolved>()
+    // BUG-004: consecutive steer-absorption rounds within the current activity run, per session.
+    // Reset at the top of every runLoop invocation (one invocation = one activity run); bounded by
+    // flags.steerAbsorbLimit at the model boundary so steers cannot extend old work without bound.
+    const steerAbsorbRounds = new Map<SessionID, number>()
     const activeReleasedKnowledge = new Map<
       SessionID,
       {
@@ -2893,21 +2972,39 @@ export const layer = Layer.effect(
           const run = admitted.materialized.run
           if (!run)
             return yield* Effect.die(new Error(`run-now prompt created an empty activity run: ${input.sessionID}`))
+          // BUG-407-012 gap C: durable evidence that the legacy activity run was claimed.
+          yield* TurnStageEvidence.record(db, {
+            sessionID: input.sessionID,
+            activityID: run.activityID,
+            stage: "activity_claimed",
+            details: { via: "admit" },
+          })
           yield* pauseAtActivityCrashPoint("after_admit_and_bind")
           if (lifecycle) yield* lifecycle.ready({ messageID: admitted.message.info.id, delivery: "turn" })
           return yield* runLoop(input.sessionID, false, run)
         }).pipe(
-          Effect.onInterrupt(() => {
+          // BUG-008: terminalize on EVERY abnormal exit, not only interruption. A failure or defect
+          // between admit (which claims the legacy activity run) and runLoop's own exit hook
+          // previously left the activity `active`; the next admission then refused with "requires
+          // recovery before a new turn". finalizeCancellationBeforeProgress is CAS-guarded, so the
+          // loop-level hook and this handler are safe to both run.
+          Effect.onExit((exit) => {
+            if (Exit.isSuccess(exit)) return Effect.void
+            const interrupted = Cause.interruptors(exit.cause).size > 0
             const run = ownedRun.value
             return Effect.all(
               [
-                settleFederatedActivity(input.sessionID, "interrupted"),
+                settleFederatedActivity(input.sessionID, interrupted ? "interrupted" : "failed"),
                 run
                   ? SessionPromptIntent.finalizeCancellationBeforeProgress(run).pipe(
                       Effect.provideService(Database.Service, database),
                       Effect.flatMap((result) =>
                         result ? publishActivityProjection(result.invalidation) : Effect.void,
                       ),
+                      // The loop-level hook may have committed a terminal with a different decision
+                      // shape already (failure exit); the activity is terminal either way, so the
+                      // divergent replay is benign here.
+                      Effect.catchTag("SessionPromptIntent.Conflict", () => Effect.void),
                     )
                   : Effect.void,
               ],
@@ -3358,12 +3455,7 @@ export const layer = Layer.effect(
       "</system-reminder>",
     ].join("\n")
 
-    const runLoop: (
-      sessionID: SessionID,
-      drainFirst?: boolean,
-      activityRun?: SessionPromptIntent.RunIdentity,
-      onActivityRun?: (run: SessionPromptIntent.RunIdentity) => void,
-    ) => Effect.Effect<SessionV1.WithParts, SessionPromptIntent.Error> = Effect.fn("SessionPrompt.run")(
+    const runLoopInner = Effect.fn("SessionPrompt.run")(
       // §S1.2: `drainFirst` — a PURE-DRAIN turn (started to absorb a steer that landed in the isBusy→admit
       // race, with no initiating user message of its own) must drain on step 0 too; otherwise the step-0
       // skip + the immediate finish check would break before the steer is ever consumed. A normal turn
@@ -3384,6 +3476,8 @@ export const layer = Layer.effect(
         // that occurs when the model repeatedly guesses wrong field names (e.g. "summary" instead
         // of "module" for ResearchResult) and the AI SDK silently rejects them before execute().
         let structuredFailedAttempts = 0
+        // BUG-004: fresh activity run — restart the steer-absorption accounting.
+        steerAbsorbRounds.delete(sessionID)
         yield* sessions.recoverForks()
         yield* sessions.assertRunnable(sessionID).pipe(Effect.orDie)
         const session = yield* sessions.get(sessionID).pipe(Effect.orDie)
@@ -3442,6 +3536,14 @@ export const layer = Layer.effect(
                 Effect.map((activity) => (activity?.state === "active" ? activity : undefined)),
               )
             : undefined
+        // BUG-407-012 gap C: persist durable stage evidence at each provider-turn boundary.
+        // Record-only: single forward-only upsert that never throws, so it cannot alter
+        // turn timing (in particular terminal settlement ordering).
+        const recordTurnStage = (stage: TurnStageEvidence.Stage, details?: Record<string, unknown>) => {
+          const activityID = currentActivityRun?.activityID ?? legacyActivity?.activityID
+          if (!activityID) return Effect.void
+          return TurnStageEvidence.record(db, { sessionID, activityID, stage, ...(details ? { details } : {}) })
+        }
         let providerBoundary: SessionPromptIntent.ProviderInputBoundary | undefined
         let activityTerminalCommitted = false
         const enterFinalizing = (run: SessionPromptIntent.RunIdentity) =>
@@ -3578,9 +3680,16 @@ export const layer = Layer.effect(
                 if (currentActivityRun) {
                   yield* pauseAtActivityCrashPoint("after_admit_and_bind")
                   legacyActivity = { activityID: currentActivityRun.activityID, state: "active" as const }
+                  yield* TurnStageEvidence.record(db, {
+                    sessionID,
+                    activityID: currentActivityRun.activityID,
+                    stage: "activity_claimed",
+                    details: { via: "steer_claim" },
+                  })
                 }
               }
               const absorbed = yield* drainSteers(sessionID, drainFirst && step === 0)
+              if (absorbed.length > 0) steerAbsorbRounds.set(sessionID, (steerAbsorbRounds.get(sessionID) ?? 0) + 1)
               pendingContextInputIds = [...pendingContextInputIds, ...absorbed]
             }
           }
@@ -3718,6 +3827,16 @@ export const layer = Layer.effect(
 
           const model = yield* getModel(lastUser.model.providerID, lastUser.model.modelID, sessionID)
           const finalizerDecision = finalizerMode ? LLM.finalizerCapability(model) : undefined
+          // UPD-002: wire structured-output decision (single helper shared with
+          // LLMRequestPrep.prepare). Wire mode ⇒ skip the synthesized
+          // StructuredOutput tool below; the json_schema travels as the
+          // request's wire format and the final assistant text carries the
+          // JSON value. Synthetic path unchanged for every other family.
+          const wireStructuredOutput = LLMRequestPrep.shouldUseWireStructuredOutput({
+            user: lastUser,
+            model,
+            flags,
+          })
           const task = finalizerMode ? undefined : tasks.pop()
 
           if (task?.type === "subtask") {
@@ -3806,6 +3925,16 @@ export const layer = Layer.effect(
               }
               if (action === "fallback") {
                 yield* writeSoftLandingState(sessionID, nextState)
+                // UPD-005 micro-compact: on entering the fallback phase, prune with a SMALLER
+                // protect window (MICRO_COMPACT_PROTECT < PRUNE_PROTECT) to truncate older
+                // non-protected tool results in place and buy headroom before the hard line.
+                // prune keeps its time.compacted idempotency guard, so repeated fallback entries
+                // (and the later turn-end / hard-phase prunes) never double-truncate. Failure is
+                // swallowed (same posture as the turn-end prune) — micro-compact is an
+                // optimization and must not block the soft-landing fallback note.
+                yield* compaction
+                  .prune({ sessionID, protect: SessionCompaction.MICRO_COMPACT_PROTECT })
+                  .pipe(Effect.ignore)
                 yield* injectTailReminder(
                   sessionID,
                   fallbackTailText(sessionID),
@@ -3948,49 +4077,84 @@ export const layer = Layer.effect(
           const receiptFinalizer: { value?: () => Effect.Effect<void> } = {}
           const activityProgressFinalizer: { value?: () => Effect.Effect<void> } = {}
           let progressAssistantMessageID: MessageID | undefined
-          const finalizeInterruptedTurn = Effect.uninterruptible(
-            Effect.gen(function* () {
-              yield* finalizeInterruptedAssistant
-              receiptTerminal.value ??= { state: "failed", errorCode: "AbortError" }
-              if (receiptFinalizer.value) yield* receiptFinalizer.value()
-              const decision = terminalDecision("interrupted", "user_cancelled", "cancel")
-              const finalized =
-                currentActivityRun && providerBoundary && decision
-                  ? yield* (
-                      progressAssistantMessageID
-                        ? SessionPromptIntent.finalizeActivityWithRevision({
-                            run: currentActivityRun,
-                            assistantMessageID: progressAssistantMessageID,
-                            decision,
-                          })
-                        : SessionPromptIntent.finalizeActivityWithoutRevision({
-                            run: currentActivityRun,
-                            membershipOrdinal: providerBoundary.membershipOrdinal,
-                            decision,
-                          })
-                    ).pipe(
-                      Effect.provideService(Database.Service, database),
-                      Effect.tap((result) =>
-                        Effect.sync(() => {
-                          activityTerminalCommitted = result.kind !== "follow_up_required"
-                        }),
-                      ),
-                      Effect.tap((result) =>
-                        result.kind === "follow_up_required"
-                          ? Effect.void
-                          : publishActivityProjection(result.invalidation),
-                      ),
-                    )
-                  : undefined
-              if (!finalized && activityProgressFinalizer.value) yield* activityProgressFinalizer.value()
-              if (legacyActivity && !activityProgressFinalizer.value && !finalized)
-                yield* SessionPromptIntent.interruptActivity(legacyActivity.activityID).pipe(
-                  Effect.provideService(Database.Service, database),
-                  Effect.flatMap((activity) => (activity ? publishActivityProjection(activity) : Effect.void)),
-                )
-            }),
-          )
+          const finalizeAbnormalTurn = (
+            terminalState: "interrupted" | "failed",
+            reasonCode: string,
+            source: "provider_final" | "host_stop" | "cancel",
+            errorCode: string,
+          ) =>
+            Effect.uninterruptible(
+              Effect.gen(function* () {
+                yield* finalizeInterruptedAssistant
+                receiptTerminal.value ??= { state: "failed", errorCode }
+                if (receiptFinalizer.value) yield* receiptFinalizer.value()
+                const baseDecision = terminalDecision(terminalState, reasonCode, source)
+                // Durable authority: the terminal guard rejects settling an activity while a tool
+                // permission effect is still in flight. A concurrently-finishing tool settles its
+                // effect imminently; wait for it, then route a clean interrupt/settle through
+                // recovery_required if a quarantined (unknown) effect remains.
+                const decision =
+                  baseDecision && currentActivityRun
+                    ? yield* SessionPromptIntent.awaitTerminalPermissionEffects({
+                        activityID: currentActivityRun.activityID,
+                      }).pipe(
+                        Effect.provideService(Database.Service, database),
+                        Effect.map((effects) =>
+                          (effects.unresolvedUnknown || effects.startedTimedOut) &&
+                          (baseDecision.state === "interrupted" || baseDecision.state === "settled")
+                            ? {
+                                ...baseDecision,
+                                state: "recovery_required" as const,
+                                reasonCode: "permission_effect_outcome_unknown",
+                              }
+                            : baseDecision,
+                        ),
+                      )
+                    : baseDecision
+                const finalized =
+                  currentActivityRun && providerBoundary && decision
+                    ? yield* (
+                        progressAssistantMessageID
+                          ? SessionPromptIntent.finalizeActivityWithRevision({
+                              run: currentActivityRun,
+                              assistantMessageID: progressAssistantMessageID,
+                              decision,
+                            })
+                          : SessionPromptIntent.finalizeActivityWithoutRevision({
+                              run: currentActivityRun,
+                              membershipOrdinal: providerBoundary.membershipOrdinal,
+                              decision,
+                            })
+                      ).pipe(
+                        Effect.provideService(Database.Service, database),
+                        Effect.tap((result) =>
+                          Effect.sync(() => {
+                            activityTerminalCommitted = result.kind !== "follow_up_required"
+                          }),
+                        ),
+                        Effect.tap((result) =>
+                          result.kind === "follow_up_required"
+                            ? Effect.void
+                            : publishActivityProjection(result.invalidation),
+                        ),
+                      )
+                    : undefined
+                if (!finalized && activityProgressFinalizer.value) yield* activityProgressFinalizer.value()
+                if (legacyActivity && !activityProgressFinalizer.value && !finalized)
+                  yield* SessionPromptIntent.interruptActivity(legacyActivity.activityID).pipe(
+                    Effect.provideService(Database.Service, database),
+                    Effect.flatMap((activity) => (activity ? publishActivityProjection(activity) : Effect.void)),
+                  )
+                yield* recordTurnStage("terminal_settled", {
+                  state: decision?.state,
+                  reasonCode: decision?.reasonCode,
+                  via: "abnormal_turn",
+                })
+              }),
+            )
+          const finalizeInterruptedTurn = finalizeAbnormalTurn("interrupted", "user_cancelled", "cancel", "AbortError")
 
+          yield* recordTurnStage("snapshot_started")
           const handle = yield* processor
             .create({
               assistantMessage: msg,
@@ -3998,10 +4162,14 @@ export const layer = Layer.effect(
               model,
               sequenceTracker: toolSequenceTracker,
               planTracker: planProtocolTracker,
+              ...(legacyActivity ? { activityID: legacyActivity.activityID } : {}),
               loopPolicy: finalizerMode || taskActivity ? "error" : "ask",
               noProgressLimit: taskActivity?.maxNoProgress,
             })
             .pipe(Effect.onInterrupt(() => finalizeInterruptedTurn))
+          yield* handle.snapshotOutcome.degraded
+            ? recordTurnStage("snapshot_degraded", handle.snapshotOutcome.degraded)
+            : recordTurnStage("snapshot_finished")
 
           const outcome: "break" | "continue" = yield* Effect.gen(function* () {
             sessionFederationActivation = yield* activateFederation()
@@ -4029,7 +4197,7 @@ export const layer = Layer.effect(
                   Effect.provideService(RuntimeFlags.Service, flags),
                 )
 
-            if (lastUser.format?.type === "json_schema") {
+            if (lastUser.format?.type === "json_schema" && !wireStructuredOutput) {
               tools["StructuredOutput"] = createStructuredOutputTool({
                 schema: lastUser.format.schema,
                 onSuccess(output) {
@@ -4081,6 +4249,7 @@ export const layer = Layer.effect(
                   })
                 : providerHistory
             const modelMsgs = yield* MessageV2.toModelMessagesEffect(historyForProvider, model, { terminalBoundaryID })
+            yield* recordTurnStage("history_loaded", { messages: providerHistory.length })
             const system = yield* Effect.all([
               sys.skills(agent),
               sys.environment(model),
@@ -4183,7 +4352,12 @@ export const layer = Layer.effect(
             // system prefix. Keep it in the same ephemeral tail used for other volatile runtime
             // context; strict turns use StructuredOutput as the hard gate, while the bounded text
             // fallback uses local JSON extraction plus the unchanged schema validator.
-            const structuredRuntimeTail = buildStructuredOutputRuntimeTail(format, finalizerMode, finalizerAllowsText)
+            const structuredRuntimeTail = buildStructuredOutputRuntimeTail(
+              format,
+              finalizerMode,
+              finalizerAllowsText,
+              wireStructuredOutput,
+            )
             const baseStreamInput: LLM.StreamInput = {
               user: lastUser,
               agent,
@@ -4198,7 +4372,9 @@ export const layer = Layer.effect(
               releasedKnowledgeSelection,
               toolChoice: finalizerAllowsText
                 ? "none"
-                : (finalizerDecision?.toolChoice ?? (format.type === "json_schema" ? "required" : undefined)),
+                : (finalizerDecision?.toolChoice ??
+                  // UPD-002: wire mode has no StructuredOutput tool to force.
+                  (format.type === "json_schema" && !wireStructuredOutput ? "required" : undefined)),
               reasoning: finalizerDecision?.reasoning,
               ...(structuredRuntimeTail ? { runtimeTail: structuredRuntimeTail } : {}),
               ...(!projectedContext && activeContext
@@ -4327,10 +4503,13 @@ export const layer = Layer.effect(
                         ),
                       )
                     const admittedAt = Date.now()
+                    // BUG-407-012 root cause A: read the live owner generation at use time; the
+                    // startup token may already be fenced and rotated away by the maintenance loop.
+                    const providerOwnerCurrent = yield* Ref.get(providerOwnerState)
                     const providerAttempt = providerAttemptAdmission
                       ? yield* SessionProviderAttempt.prepareInTransaction(tx, {
                           ...providerAttemptAdmission,
-                          ownerToken: providerOwnerToken,
+                          ownerToken: providerOwnerCurrent.ownerToken,
                           now: admittedAt,
                         })
                       : undefined
@@ -4388,6 +4567,12 @@ export const layer = Layer.effect(
                       context_readiness: sessionFederationActivation.readiness,
                       context_activation: contextActivation,
                       context_activation_fingerprint: contextActivationFingerprint,
+                      // FEAT-007 attribution: the gateway locks the run's active pack snapshot id onto
+                      // the session state at the run entry (single authority, FEAT-002 — derived from the
+                      // same activation knowledge retrieval constrains on). Read it through; NULL when no
+                      // gateway run locked a snapshot for this session (never blocks admission).
+                      context_active_pack_set_snapshot_id:
+                        AgentGateway.DeepAgentSessionState.get(sessionID)?.packSnapshotId ?? null,
                       released_knowledge_security_namespace_id: releasedKnowledgeIdentity.securityNamespaceId,
                       released_knowledge_project_scope_key: releasedKnowledgeIdentity.projectScopeKey,
                       released_knowledge_binding_state: releasedKnowledgeBinding.state,
@@ -4420,10 +4605,18 @@ export const layer = Layer.effect(
                       response_chain_reuse_decision: "not_supported",
                       response_chain_refusal_reason: "provider_path_not_stateful",
                       provider_state: "preparing",
-                      owner_token: providerOwnerToken,
+                      owner_token: providerOwnerCurrent.ownerToken,
                       request_state: "prepared",
                       created_at: admittedAt,
                     })
+                    if (legacyActivity)
+                      yield* TurnStageEvidence.recordInTransaction(tx, {
+                        sessionID,
+                        activityID: legacyActivity.activityID,
+                        stage: "request_prepared",
+                        now: admittedAt,
+                        details: { receiptID, requestOrdinal },
+                      })
                     if (continuation) {
                       const admitted = yield* tx
                         .update(CompactionRunTable)
@@ -4464,7 +4657,13 @@ export const layer = Layer.effect(
                 assistantMessageID: handle.message.id,
                 providerReceiptID: receiptID,
                 membershipOrdinal: providerBoundary?.membershipOrdinal,
-              }).pipe(Effect.provideService(Database.Service, database), Effect.tap(publishActivityProgress))
+              }).pipe(
+                Effect.provideService(Database.Service, database),
+                // BUG-407-008 §6.2 P1/P2: test-only crash points (no-op outside the crash env).
+                Effect.tap(() => pauseAtActivityCrashPoint("after_begin_progress_commit_before_provisional_event")),
+                Effect.tap(publishActivityProgress),
+                Effect.tap(() => pauseAtActivityCrashPoint("after_provisional_event_before_provider_dispatch")),
+              )
             if (progressActivity) progressAssistantMessageID = handle.message.id
             if (progressActivity)
               activityProgressFinalizer.value = () =>
@@ -4476,6 +4675,34 @@ export const layer = Layer.effect(
                   Effect.tap(publishActivityProgress),
                   Effect.asVoid,
                 )
+            // FEAT-007: durable per-turn reconciliation of the federated selection, written
+            // immediately after the receipt admission. Best-effort by contract — a write
+            // failure is observable via the degraded metric but must never block the turn.
+            if (activeContext) {
+              yield* ContextReconciliation.record(db, {
+                sessionId: sessionID,
+                activityId: activeContext.selection.activityId,
+                turnReceiptId: receiptID,
+                selectionId: activeContext.selection.selectionId,
+                projectionRefs: activeContext.selection.selectedRefs.map((selected) => selected.ref),
+                // Legacy selected refs only materialize inside the provider prepare path; the
+                // receipt write site sees the projection selection exclusively, so the record
+                // degrades to projection-internal consistency (legacy fingerprint stays NULL).
+              }).pipe(
+                Effect.asVoid,
+                Effect.catchCause((cause) =>
+                  Effect.sync(() => {
+                    slog.warn("session context reconciliation write failed", {
+                      receiptID,
+                      sessionID,
+                      cause: Cause.pretty(cause),
+                      metric: "session_context_reconciliation_degraded_total",
+                      increment: 1,
+                    })
+                  }),
+                ),
+              )
+            }
             const bestEffortReceiptWrite = (operation: string, write: Effect.Effect<unknown, unknown>) =>
               write.pipe(
                 Effect.asVoid,
@@ -4551,12 +4778,15 @@ export const layer = Layer.effect(
                               ? input.values.terminal_at
                               : Date.now()
                       const observedAt = yield* SessionProviderOwner.observedAtInTransaction(tx)
+                      // BUG-407-012 root cause A: the lease guard runs against the current owner
+                      // generation, not the startup token captured when the layer started.
+                      const providerOwnerCurrent = yield* Ref.get(providerOwnerState)
                       const owner = yield* tx
                         .select({ ownerToken: SessionProviderOwnerLeaseTable.owner_token })
                         .from(SessionProviderOwnerLeaseTable)
                         .where(
                           and(
-                            eq(SessionProviderOwnerLeaseTable.owner_token, providerOwnerToken),
+                            eq(SessionProviderOwnerLeaseTable.owner_token, providerOwnerCurrent.ownerToken),
                             isNull(SessionProviderOwnerLeaseTable.released_at),
                             gt(SessionProviderOwnerLeaseTable.lease_expires_at, observedAt),
                           ),
@@ -4569,7 +4799,7 @@ export const layer = Layer.effect(
                         .where(
                           and(
                             eq(SessionToolRequestReceiptTable.receipt_id, receiptID),
-                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerToken),
+                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerCurrent.ownerToken),
                           ),
                         )
                         .get()
@@ -4616,7 +4846,7 @@ export const layer = Layer.effect(
                       if (input.attemptTransition && providerAttempt) {
                         yield* SessionProviderAttempt.transitionInTransaction(tx, {
                           attemptId: providerAttempt.attemptId,
-                          expectedOwnerToken: providerOwnerToken,
+                          expectedOwnerToken: providerOwnerCurrent.ownerToken,
                           from: [...input.attemptTransition.from],
                           to: input.attemptTransition.state,
                           now: input.attemptTransition.at,
@@ -4638,7 +4868,7 @@ export const layer = Layer.effect(
                         .where(
                           and(
                             eq(SessionToolRequestReceiptTable.receipt_id, receiptID),
-                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerToken),
+                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerCurrent.ownerToken),
                             eq(SessionToolRequestReceiptTable.provider_state, current.state),
                           ),
                         )
@@ -4816,6 +5046,13 @@ export const layer = Layer.effect(
                 if (!finalized && activityProgressFinalizer.value) yield* activityProgressFinalizer.value()
                 activityProgressFinalizer.value = undefined
                 turnSettled.value = true
+                // BUG-407-012 gap C: record-only evidence; settlement ordering above is unchanged.
+                yield* recordTurnStage(
+                  "terminal_settled",
+                  decision ? { state: decision.state, reasonCode: decision.reasonCode } : undefined,
+                )
+                // BUG-407-008 §6.2 P6: test-only crash point (no-op outside the crash env).
+                yield* pauseAtActivityCrashPoint("after_progress_settle_before_next_admission")
                 // Summary diffs mutate user-message metadata. Run them only after the Provider
                 // receipt is terminal so cancellation cannot strand an admitted request.
                 if (step === 1 && !finalizerMode)
@@ -4835,12 +5072,14 @@ export const layer = Layer.effect(
                     Effect.gen(function* () {
                       const preparedAt = Date.now()
                       const observedAt = yield* SessionProviderOwner.observedAtInTransaction(tx)
+                      // BUG-407-012 root cause A: read the live owner generation at use time.
+                      const providerOwnerCurrent = yield* Ref.get(providerOwnerState)
                       const owner = yield* tx
                         .select({ ownerToken: SessionProviderOwnerLeaseTable.owner_token })
                         .from(SessionProviderOwnerLeaseTable)
                         .where(
                           and(
-                            eq(SessionProviderOwnerLeaseTable.owner_token, providerOwnerToken),
+                            eq(SessionProviderOwnerLeaseTable.owner_token, providerOwnerCurrent.ownerToken),
                             isNull(SessionProviderOwnerLeaseTable.released_at),
                             gt(SessionProviderOwnerLeaseTable.lease_expires_at, observedAt),
                           ),
@@ -4880,7 +5119,7 @@ export const layer = Layer.effect(
                       if (providerAttempt)
                         yield* SessionProviderAttempt.transitionInTransaction(tx, {
                           attemptId: providerAttempt.attemptId,
-                          expectedOwnerToken: providerOwnerToken,
+                          expectedOwnerToken: providerOwnerCurrent.ownerToken,
                           from: ["prepared"],
                           to: "prepared",
                           now: preparedAt,
@@ -4938,7 +5177,7 @@ export const layer = Layer.effect(
                         .where(
                           and(
                             eq(SessionToolRequestReceiptTable.receipt_id, receiptID),
-                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerToken),
+                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerCurrent.ownerToken),
                             eq(SessionToolRequestReceiptTable.provider_state, "preparing"),
                           ),
                         )
@@ -4962,12 +5201,14 @@ export const layer = Layer.effect(
                   (tx) =>
                     Effect.gen(function* () {
                       const observedAt = yield* SessionProviderOwner.observedAtInTransaction(tx)
+                      // BUG-407-012 root cause A: read the live owner generation at use time.
+                      const providerOwnerCurrent = yield* Ref.get(providerOwnerState)
                       const owner = yield* tx
                         .select({ ownerToken: SessionProviderOwnerLeaseTable.owner_token })
                         .from(SessionProviderOwnerLeaseTable)
                         .where(
                           and(
-                            eq(SessionProviderOwnerLeaseTable.owner_token, providerOwnerToken),
+                            eq(SessionProviderOwnerLeaseTable.owner_token, providerOwnerCurrent.ownerToken),
                             isNull(SessionProviderOwnerLeaseTable.released_at),
                             gt(SessionProviderOwnerLeaseTable.lease_expires_at, observedAt),
                           ),
@@ -4980,7 +5221,7 @@ export const layer = Layer.effect(
                         .where(
                           and(
                             eq(SessionToolRequestReceiptTable.receipt_id, receiptID),
-                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerToken),
+                            eq(SessionToolRequestReceiptTable.owner_token, providerOwnerCurrent.ownerToken),
                             eq(SessionToolRequestReceiptTable.provider_state, "preparing"),
                           ),
                         )
@@ -5003,9 +5244,10 @@ export const layer = Layer.effect(
                 now: Date.now(),
               })
               if (!gate.allowed) {
+                const providerOwnerCurrentForRejection = yield* Ref.get(providerOwnerState)
                 yield* rejectUndispatchedProviderTurn({
                   receiptID,
-                  ownerToken: providerOwnerToken,
+                  ownerToken: providerOwnerCurrentForRejection.ownerToken,
                   ...(providerAttempt ? { providerAttemptID: providerAttempt.attemptId } : {}),
                   errorCode: `provider_dispatch_${gate.reason}`,
                 }).pipe(Effect.provideService(Database.Service, database))
@@ -5072,6 +5314,7 @@ export const layer = Layer.effect(
                         : {}),
                     })
                     if (!transitioned) return
+                    yield* recordTurnStage("provider_dispatch_started", { dispatchingAt })
                   }),
                 streaming: () =>
                   Effect.gen(function* () {
@@ -5147,6 +5390,57 @@ export const layer = Layer.effect(
             )
             if (!response) return yield* Effect.die(new Error(`provider response is missing: ${handle.message.id}`))
 
+            // UPD-002 wire mode: the provider enforced the schema via text.format,
+            // so the final assistant TEXT carries the JSON value (no synthetic
+            // tool call). Capture it here with the same validator the synthetic
+            // path uses; failures reuse the structuredFailedAttempts retry-cap.
+            if (wireStructuredOutput && structured === undefined && format.type === "json_schema") {
+              const wireText = response.parts
+                .filter(
+                  (part): part is SessionV1.TextPart =>
+                    part.type === "text" && !part.synthetic && !part.ignored && part.text.trim() !== "",
+                )
+                .map((part) => part.text)
+                .join("")
+                .trim()
+              if (wireText.length > 0) {
+                let parsed: unknown
+                let wireError: string | undefined = "Wire structured output is not valid JSON."
+                try {
+                  parsed = JSON.parse(wireText)
+                  wireError = validateStructuredOutput(format.schema, parsed)
+                } catch {
+                  parsed = undefined
+                }
+                if (!wireError) {
+                  structured = parsed
+                } else {
+                  const retryMax = format.retryCount ?? 2
+                  structuredFailedAttempts++
+                  const fields = extractSchemaTopLevelFields(format.schema)
+                  const fieldList = fields.length > 0 ? fields.join(", ") : "(see schema)"
+                  if (structuredFailedAttempts >= retryMax) {
+                    handle.message.error = new SessionV1.StructuredOutputError({
+                      message: `Wire structured output validation failed after ${structuredFailedAttempts} attempt(s). Required fields: ${fieldList}`,
+                      retries: structuredFailedAttempts,
+                    }).toObject()
+                    yield* sessions.updateMessage(handle.message)
+                    yield* settleProviderTurn(terminalDecision("failed", "structured_output_retry_exhausted"))
+                    return "break" as const
+                  }
+                  yield* settleProviderTurn()
+                  yield* injectTailReminder(
+                    sessionID,
+                    `[structured-output correction] Your previous JSON response did not match the required schema: ${wireError.slice(0, 500)} Respond again with ONLY a single JSON value using exactly these top-level fields: ${fieldList}.`,
+                    lastUser.model,
+                    lastUser.agent,
+                    SessionProcessor.planProtocolActivityID(lastUser.metadata) ?? lastUser.id,
+                  )
+                  return "continue" as const
+                }
+              }
+            }
+
             if (structured !== undefined) {
               handle.message.structured = structured
               handle.message.finish = handle.message.finish ?? "stop"
@@ -5294,7 +5588,17 @@ export const layer = Layer.effect(
             return "continue" as const
           }).pipe(
             Effect.ensuring(instruction.clear(handle.message.id)),
-            Effect.onInterrupt(() => finalizeInterruptedTurn),
+            // BUG-008: terminalize the legacy activity on EVERY abnormal exit, not only interruption.
+            // A failed/defect loop exit previously left the activity `active` and the next prompt
+            // admission refused with "requires recovery before a new turn". Success exits already
+            // commit the terminal inside the loop (activityTerminalCommitted); finalizers are
+            // idempotent through the activity CAS, so double-firing is safe.
+            Effect.onExit((exit) => {
+              if (Exit.isSuccess(exit) || activityTerminalCommitted) return Effect.void
+              return Cause.interruptors(exit.cause).size > 0
+                ? finalizeInterruptedTurn
+                : finalizeAbnormalTurn("failed", "run_loop_exit_failure", "host_stop", "RunLoopExitFailure")
+            }),
           )
           // V4.1 §S1.1 needsFollowUp: the model finished this step (outcome === "break"), but if a steer
           // arrived while it was running, do NOT exit — loop once more so the top-of-loop drain absorbs
@@ -5303,6 +5607,17 @@ export const layer = Layer.effect(
           if (outcome === "break") {
             if (activityTerminalCommitted) break
             if (!finalizerMode && flags.v4Steering && (yield* steerBuffer.hasPending(sessionID))) {
+              // BUG-004: bound the absorption. Past the limit we end THIS activity instead of
+              // continuing; drainPendingSteers re-enters with drainFirst and consumes the pending
+              // steers as a FRESH activity (the old one settles on loop exit), so input is never
+              // lost and no single activity extends without bound.
+              if ((steerAbsorbRounds.get(sessionID) ?? 0) >= flags.steerAbsorbLimit) {
+                yield* slog.info("steer absorb limit reached; ending activity, pending steers start a fresh one", {
+                  rounds: steerAbsorbRounds.get(sessionID) ?? 0,
+                  limit: flags.steerAbsorbLimit,
+                })
+                break
+              }
               yield* slog.info("steer pending at model boundary, continuing to absorb")
               continue
             }
@@ -5330,6 +5645,34 @@ export const layer = Layer.effect(
       },
     )
 
+    // BUG-003: settle the federated activity on EVERY terminal exit of the run loop. The happy
+    // path above settles just before returning; this wrapper covers error/defect/interrupt exits
+    // for all callers (prompt, loop drains, driveParentLoop) in one place instead of relying on
+    // each caller's onInterrupt hook. Idempotent with both (settle is a no-op once terminal and
+    // the in-memory map entry is removed on first settle).
+    const runLoop: (
+      sessionID: SessionID,
+      drainFirst?: boolean,
+      activityRun?: SessionPromptIntent.RunIdentity,
+      onActivityRun?: (run: SessionPromptIntent.RunIdentity) => void,
+    ) => Effect.Effect<SessionV1.WithParts, SessionPromptIntent.Error> = (
+      sessionID,
+      drainFirst,
+      activityRun,
+      onActivityRun,
+    ) =>
+      runLoopInner(sessionID, drainFirst, activityRun, onActivityRun).pipe(
+        Effect.onExit((exit) => {
+          if (Exit.isSuccess(exit)) return Effect.void
+          const state = Cause.interruptors(exit.cause).size > 0 ? ("interrupted" as const) : ("failed" as const)
+          return settleFederatedActivity(sessionID, state).pipe(
+            Effect.catchCause((cause) =>
+              Effect.logWarning(`federated activity settle failed on run-loop exit: ${Cause.pretty(cause)}`),
+            ),
+          )
+        }),
+      )
+
     // V4.1 §S1.1: admit a mid-turn user message into the durable steer buffer.
     // The canonical durable ID is always server-minted by admit(); the caller's messageID is used
     // only as an optional correlationID for idempotent retries.
@@ -5561,7 +5904,22 @@ export const layer = Layer.effect(
       if (FSUtil.resolve(session.directory) !== FSUtil.resolve(current.directory)) {
         return yield* instances.provide({ directory: session.directory }, loop(input, onRunning))
       }
-      if (federationRollout.enabled.coreV2ExecutionOwner) {
+      // FEAT-010: V2/legacy fork observability. Pure observation — the fork logic itself is
+      // untouched (no tightening, no loosening). Every loop() execution records ONE info-level
+      // structured slog with the owner selection plus the decision-factor snapshot, so production
+      // audits can answer "was the V2 owner branch selected, and why (not)" at any time.
+      const v2OwnerSelected = federationRollout.enabled.coreV2ExecutionOwner
+      yield* elog.info("v2 owner fork", {
+        sessionID: input.sessionID,
+        owner: v2OwnerSelected ? "v2" : "legacy",
+        releaseQualified: coreV2ParityVerified,
+        coreV2ExecutionOwnerFlag: flags.coreV2ExecutionOwner,
+        coreV2ExecutionOwnerEnabled: v2OwnerSelected,
+        parityCampaign: parityCampaign ? `${parityCampaign.id}:${parityCampaign.case}` : "none",
+        ownerCampaign: ownerCampaign ?? "release",
+        blockedReasons: federationRollout.blocked.coreV2ExecutionOwner ?? [],
+      })
+      if (v2OwnerSelected) {
         if (parityCampaign)
           return yield* Effect.die(new Error("V2 owner and parity recorder cannot run in the same process"))
         if (!(yield* V2ProviderTurn.ownerQualified(database.db, ownerCampaign)))
@@ -5580,6 +5938,13 @@ export const layer = Layer.effect(
         )
           return yield* Effect.die(new Error(`Legacy provider owner is still active: ${input.sessionID}`))
         return yield* Effect.gen(function* () {
+          yield* elog.info("v2 owner branch selected", {
+            sessionID: input.sessionID,
+            owner: "v2",
+            reason: "rollout_gate_open",
+            releaseQualified: coreV2ParityVerified,
+            ownerCampaign: ownerCampaign ?? "release",
+          })
           yield* status.set(input.sessionID, { type: "busy" })
           if (onRunning) yield* onRunning
           const readiness = yield* federationReadiness?.snapshot() ??
@@ -5599,6 +5964,44 @@ export const layer = Layer.effect(
             .resume(SessionV2.ID.make(input.sessionID))
             .pipe(Effect.provideService(V2ProviderTurn.CurrentOwnerCampaign, ownerCampaign))
             .pipe(Effect.orDie)
+          // FEAT-010: durable evidence correlation. The receipt row itself is written by the core
+          // runner (V2ProviderTurn.admit inside SessionRunner.runTurn during resume); read back the
+          // latest owner=v2 receipt so the slog trail ties this selection to its durable row.
+          // Best-effort: never fails the turn.
+          yield* database.db
+            .select({
+              receiptID: V2ProviderTurnReceiptTable.receipt_id,
+              state: V2ProviderTurnReceiptTable.state,
+            })
+            .from(V2ProviderTurnReceiptTable)
+            .where(
+              and(
+                eq(V2ProviderTurnReceiptTable.session_id, input.sessionID),
+                eq(V2ProviderTurnReceiptTable.owner_mode, "v2"),
+              ),
+            )
+            .orderBy(desc(V2ProviderTurnReceiptTable.request_ordinal))
+            .get()
+            .pipe(
+              Effect.orDie,
+              Effect.flatMap((receipt) =>
+                elog.info("v2 owner turn receipt", {
+                  sessionID: input.sessionID,
+                  owner: "v2",
+                  receiptID: receipt?.receiptID ?? "missing",
+                  receiptState: receipt?.state ?? "missing",
+                }),
+              ),
+            )
+            .pipe(
+              Effect.catchCause((cause) =>
+                elog.warn("v2 owner turn receipt lookup failed", {
+                  sessionID: input.sessionID,
+                  owner: "v2",
+                  error: Cause.pretty(cause),
+                }),
+              ),
+            )
           const assistant = (yield* coreV2Session
             .context(SessionV2.ID.make(input.sessionID))
             .pipe(Effect.orDie)).findLast(
@@ -5691,6 +6094,11 @@ export const layer = Layer.effect(
       )
     })
 
+    // Recovery attempts for one session serialize through this mutex: recursive instance loads
+    // (loop() redirects into instances.load when the EventRoute differs, which re-runs this
+    // initializer) can fork duplicate recovery loops before the fail-closed transition lands.
+    const recoveryMutex = KeyedMutex.makeUnsafe<string>()
+
     const wakeCommittedContinuations = (ctx: InstanceContext) =>
       Effect.runPromise(
         Effect.gen(function* () {
@@ -5698,19 +6106,36 @@ export const layer = Layer.effect(
           yield* Effect.forEach(
             pending,
             (item) =>
-              loop({ sessionID: item.sessionID }).pipe(
-                Effect.catchCause((cause) =>
-                  Effect.logError("committed compaction continuation recovery failed").pipe(
-                    Effect.annotateLogs({
-                      runID: item.runID,
-                      sessionID: item.sessionID,
-                      messageID: item.messageID,
-                      cause,
-                    }),
-                  ),
-                ),
-                Effect.forkIn(scope),
-              ),
+              recoveryMutex
+                .withLock(item.sessionID)(
+                  Effect.gen(function* () {
+                    // Re-check under the lock: a concurrent wake may already have failed the run
+                    // closed while this fork was waiting.
+                    const recoverable = yield* compaction.recoverableContinuations(ctx.project.id)
+                    if (!recoverable.some((row) => row.runID === item.runID)) return
+                    yield* loop({ sessionID: item.sessionID }).pipe(
+                      Effect.catchCause((cause) =>
+                        // BUG-407-009 §10.1: continuation recovery is a Maintenance deliverable,
+                        // so a failed attempt is the expected fail-closed outcome — warn (not
+                        // error) and stop advertising the run as recoverable.
+                        Effect.logWarning("compaction continuation recovery unavailable; failing closed").pipe(
+                          Effect.annotateLogs({
+                            runID: item.runID,
+                            sessionID: item.sessionID,
+                            messageID: item.messageID,
+                            causeDetail: Cause.pretty(cause),
+                          }),
+                          Effect.andThen(
+                            compaction
+                              .failContinuationClosed({ runID: item.runID })
+                              .pipe(Effect.provideService(Database.Service, database)),
+                          ),
+                        ),
+                      ),
+                    )
+                  }),
+                )
+                .pipe(Effect.forkIn(scope)),
             { discard: true },
           )
         }).pipe(Effect.provideService(InstanceRef, ctx)),
diff --git a/packages/deepagent-code/src/session/remote-compact.ts b/packages/deepagent-code/src/session/remote-compact.ts
new file mode 100644
index 00000000..66b9b9cd
--- /dev/null
+++ b/packages/deepagent-code/src/session/remote-compact.ts
@@ -0,0 +1,245 @@
+// UPD-005 (/responses/compact): server-side history compaction seam.
+//
+// OpenAI serves a unary `/responses/compact` endpoint that returns the
+// compacted item list with a `compaction` item carrying opaque
+// `encrypted_content` (server-held encrypted context). This module owns:
+//   1. the capability decision (canonical OpenAI Responses route only —
+//      compatible families are never assumed to serve it),
+//   2. the session-scoped staging of `encrypted_content`,
+//   3. the unary call itself, with fail-over to the local summary path on
+//      any error.
+//
+// PERSISTENCE (Gap 1 closed): `encrypted_content` is durably stored in
+// `session_compaction_encrypted_content` (migration
+// 20260820000000_remote_compact_persistence). EncryptedContentStore is the
+// read/write wrapper over that table — get/set/clear keep their signatures.
+// The compaction layer binds the Database handle (EncryptedContentStore.bind);
+// without a bound handle the store degrades to process-lifetime memory (unit
+// tests and callers outside the durable compaction path). With a bound handle,
+// a restart no longer loses the blob: the next compaction reads it back from
+// the table and replays it (§4.3).
+import { Effect } from "effect"
+import type { ModelMessage } from "ai"
+import { eq } from "drizzle-orm"
+import { OpenAIResponses } from "@deepagent-code/llm/protocols/openai-responses"
+import { byProvider as OpenAICompatibleProfiles } from "@deepagent-code/llm/providers/openai-compatible-profile"
+import type { LLMRequest } from "@deepagent-code/llm"
+import type { RequestExecutor } from "@deepagent-code/llm/route"
+import type { Database } from "@deepagent-code/core/database/database"
+import type { Auth } from "@/auth"
+import type { Provider } from "@/provider/provider"
+import { SessionCompactionEncryptedContentTable } from "./compaction-sql"
+import { LLMNative } from "./llm/native-request"
+import { LLMNativeRuntime } from "./llm/native-runtime"
+
+/**
+ * Capability probe for `/responses/compact`.
+ * - `@ai-sdk/openai` lowers onto the OpenAI Responses route, whose protocol
+ *   advertises compact support (canonical OpenAI).
+ * - `@ai-sdk/openai-compatible` families must opt in per profile
+ *   (`supportsResponsesCompact`); only DeepSeek does today (user-verified
+ *   2026-08-18) — never assumed for anyone else.
+ * - Azure also serves the Responses API, but its endpoint path is shaped
+ *   differently (`/openai/responses?api-version=…`) and compact there is
+ *   unverified — deliberately not assumed either.
+ */
+export const supportsRemoteCompaction = (model: Provider.Model): boolean => {
+  if (model.api.npm === "@ai-sdk/openai") return OpenAIResponses.supportsRemoteCompaction
+  if (model.api.npm === "@ai-sdk/openai-compatible")
+    return OpenAICompatibleProfiles[String(model.providerID)]?.supportsResponsesCompact === true
+  return false
+}
+
+// Attribution recorded with a stored blob: provenance for the same-source
+// replay check (providerID) plus optional capability re-check and run linkage.
+export type EncryptedContentAttribution = {
+  readonly providerID?: string
+  readonly modelID?: string
+  readonly sourceRunID?: string
+}
+
+export type EncryptedContentRecord = {
+  readonly encryptedContent: string
+  readonly providerID: string
+  readonly modelID: string | undefined
+  readonly sourceRunID: string | undefined
+  readonly createdAt: number
+  readonly updatedAt: number
+}
+
+// Bound by the compaction layer (production) or tests. The bun SQLite driver is
+// fully synchronous, so the store keeps its synchronous get/set/clear signatures
+// by running the drizzle effects with Effect.runSync.
+let boundDb: Database.Interface["db"] | undefined
+
+// Fallback for callers without a bound Database handle (unit tests, seams used
+// before the compaction layer is built). Never read when a handle is bound.
+const memory = new Map<string, EncryptedContentRecord>()
+
+const readRecord = (sessionID: string): EncryptedContentRecord | undefined => {
+  if (!boundDb) return memory.get(sessionID)
+  const row = Effect.runSync(
+    boundDb
+      .select()
+      .from(SessionCompactionEncryptedContentTable)
+      .where(eq(SessionCompactionEncryptedContentTable.session_id, sessionID))
+      .get()
+      .pipe(Effect.orDie),
+  )
+  if (!row) return undefined
+  return {
+    encryptedContent: row.encrypted_content,
+    providerID: row.provider_id,
+    modelID: row.model_id ?? undefined,
+    sourceRunID: row.source_run_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  }
+}
+
+const writeRecord = (sessionID: string, value: string, attribution: EncryptedContentAttribution | undefined) => {
+  const now = Date.now()
+  const providerID = attribution?.providerID ?? "unknown"
+  const modelID = attribution?.modelID ?? null
+  const sourceRunID = attribution?.sourceRunID ?? null
+  if (!boundDb) {
+    memory.set(sessionID, {
+      encryptedContent: value,
+      providerID,
+      modelID: modelID ?? undefined,
+      sourceRunID: sourceRunID ?? undefined,
+      createdAt: now,
+      updatedAt: now,
+    })
+    return
+  }
+  // Forward-only upsert: keep exactly the latest blob per session (§4.1).
+  Effect.runSync(
+    boundDb
+      .insert(SessionCompactionEncryptedContentTable)
+      .values({
+        session_id: sessionID,
+        encrypted_content: value,
+        provider_id: providerID,
+        model_id: modelID,
+        source_run_id: sourceRunID,
+        created_at: now,
+        updated_at: now,
+      })
+      .onConflictDoUpdate({
+        target: SessionCompactionEncryptedContentTable.session_id,
+        set: {
+          encrypted_content: value,
+          provider_id: providerID,
+          model_id: modelID,
+          source_run_id: sourceRunID,
+          updated_at: now,
+        },
+      })
+      .run()
+      .pipe(Effect.orDie),
+  )
+}
+
+const deleteRecord = (sessionID: string) => {
+  if (!boundDb) {
+    memory.delete(sessionID)
+    return
+  }
+  Effect.runSync(
+    boundDb
+      .delete(SessionCompactionEncryptedContentTable)
+      .where(eq(SessionCompactionEncryptedContentTable.session_id, sessionID))
+      .run()
+      .pipe(Effect.orDie),
+  )
+}
+
+export const EncryptedContentStore = {
+  /** Bind the durable Database handle; pass undefined to restore memory-only mode. */
+  bind: (db: Database.Interface["db"] | undefined): void => {
+    boundDb = db
+  },
+  get: (sessionID: string): string | undefined => readRecord(sessionID)?.encryptedContent,
+  /** Full record incl. provenance — used for the same-source replay check (§4.3). */
+  getRecord: (sessionID: string): EncryptedContentRecord | undefined => readRecord(sessionID),
+  set: (sessionID: string, value: string, attribution?: EncryptedContentAttribution): void => {
+    writeRecord(sessionID, value, attribution)
+  },
+  clear: (sessionID: string): void => {
+    deleteRecord(sessionID)
+  },
+} as const
+
+export type RemoteCompactionOutcome =
+  | { readonly used: "remote"; readonly encryptedContent: string }
+  | { readonly used: "local"; readonly reason: string }
+
+export type RemoteCompactionInput = {
+  readonly sessionID: string
+  readonly model: Provider.Model
+  readonly provider: Provider.Info
+  readonly auth: Auth.Info | undefined
+  readonly system?: readonly string[]
+  readonly messages: readonly ModelMessage[]
+}
+
+const errorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+/**
+ * Attempt server-side compaction; never throws the decision out — every
+ * failure mode (unsupported provider, missing API key, transport/HTTP error,
+ * malformed compact payload) resolves to `{ used: "local" }` so callers keep
+ * the existing local summary path with zero behavioural change.
+ *
+ * Requires `RequestExecutor.Service` in the environment (production provides
+ * `RequestExecutor.defaultLayer`; tests inject a mock HTTP layer).
+ */
+export const attemptRemoteCompaction = (
+  input: RemoteCompactionInput,
+): Effect.Effect<RemoteCompactionOutcome, never, RequestExecutor.Service> =>
+  Effect.gen(function* () {
+    if (!supportsRemoteCompaction(input.model)) {
+      // Capability lost (e.g. the session switched to a model whose route does
+      // not serve /responses/compact): local summarization takes over and the old
+      // blob is invalidated so it can never be replayed against an incapable route (§4.3).
+      EncryptedContentStore.clear(input.sessionID)
+      return { used: "local", reason: `provider package ${input.model.api.npm} does not serve /responses/compact` }
+    }
+
+    const runtime = LLMNativeRuntime.status(input)
+    if (runtime.type === "unsupported") return { used: "local", reason: runtime.reason }
+
+    // Same-provenance check BEFORE replay (§4.3): a blob minted by a different
+    // provider cannot be expanded by the current one — treat it as absent, drop
+    // it, and fail over to local summarization.
+    const record = EncryptedContentStore.getRecord(input.sessionID)
+    if (record && record.providerID !== input.model.providerID) {
+      EncryptedContentStore.clear(input.sessionID)
+      return {
+        used: "local",
+        reason: `encrypted_content belongs to provider ${record.providerID}, not ${input.model.providerID}`,
+      }
+    }
+    const previous = record?.encryptedContent
+
+    const request: LLMRequest = LLMNative.request({
+      model: input.model,
+      apiKey: runtime.apiKey,
+      baseURL: runtime.baseURL,
+      system: [...(input.system ?? [])],
+      messages: [...input.messages],
+    })
+    const result = yield* OpenAIResponses.compactConversation({ request, previousEncryptedContent: previous }).pipe(
+      Effect.map((value) => ({ ok: true as const, value })),
+      Effect.catch((error) => Effect.succeed({ ok: false as const, error })),
+    )
+    if (!result.ok) return { used: "local", reason: errorMessage(result.error) }
+    EncryptedContentStore.set(input.sessionID, result.value.encryptedContent, {
+      providerID: input.model.providerID,
+      modelID: input.model.id,
+    })
+    return { used: "remote", encryptedContent: result.value.encryptedContent } satisfies RemoteCompactionOutcome
+  })
+
+export * as RemoteCompact from "./remote-compact"
diff --git a/packages/deepagent-code/src/session/retry.ts b/packages/deepagent-code/src/session/retry.ts
index d025ba29..621b97f9 100644
--- a/packages/deepagent-code/src/session/retry.ts
+++ b/packages/deepagent-code/src/session/retry.ts
@@ -154,6 +154,60 @@ function parseJSON(value: unknown) {
   })
 }
 
+/**
+ * Structural view of `@deepagent-code/llm` `LLMError` values. Detection is
+ * structural (not instanceof) so the classification survives error wrapping
+ * across stream/runtime boundaries; the llm schema classes satisfy it.
+ */
+export interface LLMErrorShape {
+  readonly _tag: "LLM.Error"
+  readonly reason: {
+    readonly _tag: string
+    readonly message?: string | undefined
+    readonly phase?: "pre-dispatch" | "post-dispatch" | undefined
+    readonly status?: number | undefined
+  }
+}
+
+export function isLLMError(error: unknown): error is LLMErrorShape {
+  if (!isRecord(error) || error._tag !== "LLM.Error") return false
+  return isRecord(error.reason) && typeof error.reason._tag === "string"
+}
+
+/**
+ * Classification-first retry decision based on the llm package's error
+ * reason, used whenever a reason is available. The string heuristics in
+ * `retryable` remain only as the fallback for errors without a reason.
+ *
+ * - `RateLimit` / `ProviderInternal` (429 / 5xx): transient, retry.
+ * - `Transport`: retry ONLY for `phase: "pre-dispatch"` — the request never
+ *   reached the provider. Post-dispatch transport failures may already have
+ *   been billed, so re-sending them here would duplicate the physical
+ *   request; recovery belongs to provider-attempt replay.
+ * - Everything else (`InvalidRequest`, `Authentication`, `QuotaExceeded`,
+ *   `ContentPolicy`, `NoRoute`, `InvalidProviderOutput`, `UnknownProvider`)
+ *   is terminal: no retry, no fallback to message heuristics.
+ */
+export function retryableViaReason(error: LLMErrorShape): Retryable | undefined {
+  const reason = error.reason
+  switch (reason._tag) {
+    case "RateLimit":
+      return { message: reason.message ?? "Rate Limited" }
+    case "ProviderInternal":
+      return { message: reason.message ?? "Provider is overloaded" }
+    case "Transport":
+      return reason.phase === "pre-dispatch" ? { message: reason.message ?? "Provider connection failed" } : undefined
+    default:
+      return undefined
+  }
+}
+
+/** Retry decision for a raw stream failure plus its parsed `Err` form. */
+export function retryableFor(raw: unknown, parsed: Err, provider: string): Retryable | undefined {
+  if (isLLMError(raw)) return retryableViaReason(raw)
+  return retryable(parsed, provider)
+}
+
 export function policy(opts: {
   provider: string
   parse: (error: unknown) => Err
@@ -162,7 +216,9 @@ export function policy(opts: {
   return Schedule.fromStepWithMetadata(
     Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
       const error = opts.parse(meta.input)
-      const retry = retryable(error, opts.provider)
+      // Prefer the llm reason classification when the raw failure carries one;
+      // fall back to the string heuristics for SDK/plain errors.
+      const retry = retryableFor(meta.input, error, opts.provider)
       if (!retry) return Cause.done(meta.attempt)
       return Effect.gen(function* () {
         const wait = delay(meta.attempt, SessionV1.APIError.isInstance(error) ? error : undefined)
diff --git a/packages/deepagent-code/src/session/session.ts b/packages/deepagent-code/src/session/session.ts
index 2b7f1572..f32afb15 100644
--- a/packages/deepagent-code/src/session/session.ts
+++ b/packages/deepagent-code/src/session/session.ts
@@ -74,7 +74,8 @@ import { Hash } from "@deepagent-code/core/util/hash"
 import { CanonicalJson } from "@deepagent-code/core/util/canonical-json"
 import { SessionPromptEpochTable } from "./prompt-epoch.sql"
 import { HistoryAuthority } from "./history-authority"
-import { Data } from "effect"
+import { SessionDiffArtifact } from "./diff-artifact"
+import { Cause, Data } from "effect"
 import { KeyedMutex } from "@deepagent-code/core/effect/keyed-mutex"
 
 const log = Log.create({ service: "session" })
@@ -1050,7 +1051,7 @@ export const layer: Layer.Layer<
           .pipe(Effect.orDie)
         if (existing && existing.session_id !== msg.sessionID)
           return yield* Effect.die(`Session.updateMessage: message ${msg.id} belongs to another Session`)
-        yield* events.publish(
+        const payload = yield* events.publish(
           SessionV1.Event.MessageUpdated,
           {
             sessionID: msg.sessionID,
@@ -1058,18 +1059,59 @@ export const layer: Layer.Layer<
           },
           {
             commit: () =>
+              // QUAL-007: upsert, not plain update — messages created through updateMessage (fork
+              // fixtures, synthetic boundaries) must land in MessageTable; #115's commit callback
+              // dropped the insert half of the old projector's insert-or-update semantics.
               db
-                .update(MessageTable)
-                .set({
+                .insert(MessageTable)
+                .values({
+                  id: msg.id,
+                  session_id: msg.sessionID,
+                  time_created: msg.time.created,
+                  time_updated: msg.time.created,
                   data: Object.fromEntries(
                     Object.entries(msg).filter(([key]) => key !== "id" && key !== "sessionID"),
                   ) as typeof MessageTable.$inferInsert.data,
                 })
-                .where(and(eq(MessageTable.id, msg.id), eq(MessageTable.session_id, msg.sessionID)))
+                .onConflictDoUpdate({
+                  target: MessageTable.id,
+                  set: {
+                    data: Object.fromEntries(
+                      Object.entries(msg).filter(([key]) => key !== "id" && key !== "sessionID"),
+                    ) as typeof MessageTable.$inferInsert.data,
+                  },
+                })
                 .run()
                 .pipe(Effect.orDie),
           },
         )
+        // RISK-003 ①: runtime diff artifact writer. A user message carrying inline summary.diffs is
+        // converged onto the session_diff_artifact authority (durable files/chunks + committed
+        // receipt + compact diffArtifact descriptor on the message row) right after the
+        // message.updated event commits, so new writes never accumulate inline FileDiff[] bodies.
+        // Best-effort by design: capture failures only log and leave the bounded inline diffs in
+        // place (backfill/maintenance can pick them up later); a turn must never break here.
+        if (
+          flags.sessionDiffArtifactCapture &&
+          msg.role === "user" &&
+          msg.summary &&
+          msg.summary.diffs.length > 0 &&
+          !msg.summary.diffArtifact
+        )
+          yield* SessionDiffArtifact.capture({
+            sessionID: msg.sessionID,
+            messageID: msg.id,
+            sourceEventID: payload.id,
+          }).pipe(
+            Effect.provideService(Database.Service, database),
+            Effect.catchCause((cause) =>
+              Effect.logWarning("session diff artifact runtime capture skipped", {
+                sessionID: msg.sessionID,
+                messageID: msg.id,
+                cause: Cause.pretty(cause),
+              }).pipe(Effect.as({ state: "skipped" as const })),
+            ),
+          )
         return msg
       }).pipe(Effect.withSpan("Session.updateMessage"))
 
diff --git a/packages/deepagent-code/src/session/snapshot.ts b/packages/deepagent-code/src/session/snapshot.ts
new file mode 100644
index 00000000..76782fd6
--- /dev/null
+++ b/packages/deepagent-code/src/session/snapshot.ts
@@ -0,0 +1,384 @@
+import { Effect } from "effect"
+import { asc, eq, inArray, sql } from "drizzle-orm"
+import { randomBytes } from "node:crypto"
+import { Database } from "@deepagent-code/core/database/database"
+import { MessageTable, PartTable, SessionTable } from "@deepagent-code/core/session/sql"
+import {
+  ProjectScopeIdentityTable,
+  SecurityNamespaceTable,
+} from "@deepagent-code/core/context-federation/sql"
+import { SessionProviderOwnerLeaseTable } from "@deepagent-code/core/context-federation/session-sql"
+import { SessionActivityProgressTable, SessionLegacyActivityTable } from "./activity-sql"
+import { SessionToolRequestReceiptTable } from "./tool-request-receipt.sql"
+import { Identifier } from "@/id/id"
+
+// ---------------------------------------------------------------------------
+// 会话快照导出/导入(跨设备携带:完整现场 + 保证续跑)。
+//
+// 依据(已逐行核实):
+//  - 续跑读历史走 Session.Service.messages() → MessageTable/PartTable,不走 EventV2。
+//  - 续跑唯一硬阻塞:存在 state='active' 的 session_legacy_activity(prompt-intent.ts:803)。
+//  - 时间线活动标记由 message-v2.ts:385-443 联 session_activity_progress ⋈
+//    session_legacy_activity ⋈ message 计算,并强制 activity.session_id == message.session_id。
+// 故"完整现场 + 续跑"= 5 张表:session、message、part、session_legacy_activity、
+// session_activity_progress。
+//
+// 状态机触发器与导入的满足方式(全部核实到触发器定义):
+//  - session_activity_progress 的 BEFORE INSERT 触发器要求:activity 处于 active,且存在同
+//    session、同 assistant_message 的 session_tool_request_receipt。→ 逐活动"插 active →
+//    合成 receipt → 插 progress → 终态化";session_legacy_activity_active_idx 限定每 session
+//    同时至多一个 active,故严格逐活动串行。
+//  - session_tool_request_receipt 有 5 个 BEFORE INSERT 触发器,分别要求:
+//      * provider 执行簿记:owner_token 对应未释放且未过期的 session_provider_owner_lease;
+//        provider_attempt_id 置 NULL 即跳过 attempt 校验。
+//      * context 联邦权威:released_knowledge_security_namespace_id/project_scope_key 对应
+//        context_project_scope_identity(retired_at NULL);binding_state='unavailable'+空
+//        exact_refs+其 MD5 指纹满足 invalidBinding;context_selection_id 置 NULL 跳过 links。
+//      * prepared 守卫:provider_state='preparing'、selected_refs 为 NULL、prepared 域字段为空。
+//    上述行(owner lease / security namespace / scope identity)优先复用目标实例既有行,缺失才合成。
+//  - session_legacy_activity_legal_update 只允许 active → 终态(settled_at/terminal_reason 必填、
+//    不可变字段不得改);permission-effect 终态守卫对无 permission effect 的导入活动放行。
+//  - activity.trigger_admission_id 为 NOT NULL 外键→admission(其后又外键→intent/session_input),
+//    完整 FK 链会拉出整个执行簿记;时间线标记与续跑守卫均不读 admission,故导入时临时关闭
+//    foreign_keys 并以占位值落库,导入后恢复 FK 约束(触发器不受 foreign_keys 影响,仍生效)。
+// ---------------------------------------------------------------------------
+
+export const SNAPSHOT_FORMAT = "deepagent-code.session-snapshot"
+export const SNAPSHOT_VERSION = 1
+
+// Released-knowledge binding fingerprint for empty exact refs, exactly as required by the
+// released_knowledge_turn_binding trigger's 'unavailable' branch (hardcoded constant there).
+const EMPTY_REFS_FINGERPRINT = "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"
+
+type SessionRow = typeof SessionTable.$inferSelect
+type MessageRow = typeof MessageTable.$inferSelect
+type PartRow = typeof PartTable.$inferSelect
+type ActivityRow = typeof SessionLegacyActivityTable.$inferSelect
+type ProgressRow = typeof SessionActivityProgressTable.$inferSelect
+
+export interface SessionSnapshot {
+  format: typeof SNAPSHOT_FORMAT
+  format_version: number
+  exported_at: number
+  source: { session_id: string; title: string }
+  session: SessionRow
+  messages: MessageRow[]
+  parts: PartRow[]
+  activities: ActivityRow[]
+  progress: ProgressRow[]
+}
+
+const randomHex = (bytes: number) => randomBytes(bytes).toString("hex")
+
+/** 导出:读取会话的 5 张表,组装为自描述快照。 */
+export const exportSessionSnapshot = Effect.fn("Session.exportSnapshot")(function* (sessionID: string) {
+  const { db } = yield* Database.Service
+  const session = yield* db
+    .select()
+    .from(SessionTable)
+    .where(eq(SessionTable.id, sessionID as SessionRow["id"]))
+    .get()
+    .pipe(Effect.orDie)
+  if (!session) return yield* Effect.fail(new Error(`session not found: ${sessionID}`))
+
+  const messages = yield* db
+    .select()
+    .from(MessageTable)
+    .where(eq(MessageTable.session_id, session.id))
+    .orderBy(asc(MessageTable.time_created), asc(MessageTable.id))
+    .all()
+    .pipe(Effect.orDie)
+  const parts = yield* db
+    .select()
+    .from(PartTable)
+    .where(eq(PartTable.session_id, session.id))
+    .orderBy(asc(PartTable.time_created), asc(PartTable.id))
+    .all()
+    .pipe(Effect.orDie)
+  const activities = yield* db
+    .select()
+    .from(SessionLegacyActivityTable)
+    .where(eq(SessionLegacyActivityTable.session_id, session.id))
+    .orderBy(asc(SessionLegacyActivityTable.ordinal))
+    .all()
+    .pipe(Effect.orDie)
+  const activityIDs = activities.map((a) => a.activity_id)
+  const progress =
+    activityIDs.length === 0
+      ? []
+      : yield* db
+          .select()
+          .from(SessionActivityProgressTable)
+          .where(inArray(SessionActivityProgressTable.activity_id, activityIDs))
+          .orderBy(asc(SessionActivityProgressTable.activity_id), asc(SessionActivityProgressTable.revision))
+          .all()
+          .pipe(Effect.orDie)
+
+  return {
+    format: SNAPSHOT_FORMAT,
+    format_version: SNAPSHOT_VERSION,
+    exported_at: Date.now(),
+    source: { session_id: session.id, title: session.title },
+    session,
+    messages,
+    parts,
+    activities,
+    progress,
+  } satisfies SessionSnapshot
+})
+
+/**
+ * 导入:在单个事务内以全新 ID 重建 5 张表并重挂目标 project/directory;逐活动"插 active →
+ * 合成 receipt → 插 progress → 终态化",既复刻活动标记(完整现场),又保证导入后无 active
+ * activity(可续跑)。
+ */
+export const importSessionSnapshot = Effect.fn("Session.importSnapshot")(function* (input: {
+  snapshot: SessionSnapshot
+  projectID: string
+  directory: string
+}) {
+  const { db } = yield* Database.Service
+  const snap = input.snapshot
+  if (snap.format !== SNAPSHOT_FORMAT)
+    return yield* Effect.fail(new Error(`unsupported snapshot format: ${String(snap.format)}`))
+  if (typeof snap.format_version !== "number" || snap.format_version > SNAPSHOT_VERSION)
+    return yield* Effect.fail(new Error(`unsupported snapshot version: ${String(snap.format_version)}`))
+
+  const newSessionID = Identifier.ascending("session")
+  const messageMap = new Map<string, string>()
+  const partMap = new Map<string, string>()
+  const activityMap = new Map<string, string>()
+  for (const message of snap.messages) messageMap.set(message.id, Identifier.ascending("message"))
+  for (const part of snap.parts) partMap.set(part.id, Identifier.ascending("part"))
+  for (const activity of snap.activities) activityMap.set(activity.activity_id, randomHex(32))
+
+  const source = snap.session
+  const providerID = (source.model as { providerID?: string } | null)?.providerID ?? "imported"
+  const modelID = (source.model as { id?: string } | null)?.id ?? "imported"
+  const firstMessageID = snap.messages.length > 0 ? messageMap.get(snap.messages[0].id)! : newSessionID
+
+  const newSession = {
+    ...source,
+    id: newSessionID,
+    project_id: input.projectID,
+    directory: input.directory,
+    // A snapshot becomes a fresh root session on the target; drop cross-instance references that
+    // would otherwise dangle (workspace/parent/share are not FK-enforced but would be misleading).
+    workspace_id: null,
+    parent_id: null,
+    share_url: null,
+  }
+  const newMessages = snap.messages.map((message) => ({
+    ...message,
+    id: messageMap.get(message.id)!,
+    session_id: newSessionID,
+  }))
+  const newParts = snap.parts.map((part) => ({
+    ...part,
+    id: partMap.get(part.id)!,
+    message_id: messageMap.get(part.message_id) ?? part.message_id,
+    session_id: newSessionID,
+  }))
+  const progressByActivity = new Map<string, ProgressRow[]>()
+  for (const row of snap.progress) {
+    const list = progressByActivity.get(row.activity_id)
+    if (list) list.push(row)
+    else progressByActivity.set(row.activity_id, [row])
+  }
+  const now = Date.now()
+
+  yield* Effect.acquireUseRelease(
+    db.run("PRAGMA foreign_keys = OFF").pipe(Effect.orDie),
+    () =>
+      db.transaction(
+        (tx) =>
+          Effect.gen(function* () {
+            // Authority rows required by the receipt BEFORE INSERT triggers: reuse existing target
+            // rows when present, synthesize minimal ones otherwise.
+            const { ownerToken, securityNamespaceID, projectScopeKey } = yield* resolveReceiptAuthority(
+              tx,
+              now,
+            )
+
+            yield* tx.insert(SessionTable).values(newSession as never).run().pipe(Effect.orDie)
+            if (newMessages.length > 0)
+              yield* tx.insert(MessageTable).values(newMessages as never).run().pipe(Effect.orDie)
+            if (newParts.length > 0) yield* tx.insert(PartTable).values(newParts as never).run().pipe(Effect.orDie)
+
+            // Per-activity: insert active → synthesize receipt(s) → insert progress → terminalize.
+            // Sequential so the single-active-per-session unique index is never violated.
+            for (const activity of snap.activities) {
+              const newActivityID = activityMap.get(activity.activity_id)!
+              yield* tx
+                .insert(SessionLegacyActivityTable)
+                .values({
+                  activity_id: newActivityID,
+                  session_id: newSessionID,
+                  ordinal: activity.ordinal,
+                  trigger_admission_id: randomHex(16),
+                  owner_token: ownerToken,
+                  state: "active",
+                  terminal_reason: null,
+                  created_at: activity.created_at,
+                  settled_at: null,
+                } as never)
+                .run()
+                .pipe(Effect.orDie)
+
+              const rows = progressByActivity.get(activity.activity_id) ?? []
+              for (const row of rows) {
+                const assistantMessageID = messageMap.get(row.assistant_message_id) ?? row.assistant_message_id
+                const receiptID = randomHex(16)
+                // Synthetic receipt: satisfies the receipt BEFORE INSERT triggers (owner lease +
+                // released-knowledge authority) and the progress trigger's existence check; it
+                // carries no real execution data (attempt/selection left NULL).
+                yield* tx
+                  .insert(SessionToolRequestReceiptTable)
+                  .values({
+                    receipt_id: receiptID,
+                    request_ordinal: row.revision + 1,
+                    session_id: newSessionID,
+                    user_message_id: firstMessageID,
+                    assistant_message_id: assistantMessageID,
+                    provider_id: providerID,
+                    model_id: modelID,
+                    registry_tool_ids: [],
+                    permission_filtered_tool_ids: [],
+                    final_offered_tool_ids: [],
+                    call_ids: [],
+                    provider_state: "preparing",
+                    request_state: "prepared",
+                    owner_token: ownerToken,
+                    released_knowledge_security_namespace_id: securityNamespaceID,
+                    released_knowledge_project_scope_key: projectScopeKey,
+                    released_knowledge_binding_state: "unavailable",
+                    released_knowledge_exact_refs: [],
+                    released_knowledge_exact_refs_fingerprint: EMPTY_REFS_FINGERPRINT,
+                    created_at: row.created_at,
+                  } as never)
+                  .run()
+                  .pipe(Effect.orDie)
+                yield* tx
+                  .insert(SessionActivityProgressTable)
+                  .values({
+                    activity_id: newActivityID,
+                    revision: row.revision,
+                    assistant_message_id: assistantMessageID,
+                    text_part_id: row.text_part_id ? (partMap.get(row.text_part_id) ?? row.text_part_id) : null,
+                    provider_receipt_id: receiptID,
+                    input_membership_ordinal: row.input_membership_ordinal,
+                    state: row.state,
+                    finish_observed: row.finish_observed,
+                    response_fingerprint: row.response_fingerprint,
+                    created_at: row.created_at,
+                    settled_at: row.settled_at,
+                  } as never)
+                  .run()
+                  .pipe(Effect.orDie)
+              }
+
+              // Terminalize (legal_update allows only active → terminal with settled_at + reason).
+              // A source that was still active is terminalized to interrupted so the imported
+              // session has no active activity and is immediately continuable.
+              const wasActive = activity.state === "active"
+              yield* tx
+                .update(SessionLegacyActivityTable)
+                .set({
+                  state: wasActive ? "interrupted" : activity.state,
+                  settled_at: wasActive ? now : (activity.settled_at ?? now),
+                  terminal_reason: wasActive ? "imported_snapshot" : (activity.terminal_reason ?? "imported_snapshot"),
+                } as never)
+                .where(eq(SessionLegacyActivityTable.activity_id, newActivityID as never))
+                .run()
+                .pipe(Effect.orDie)
+            }
+            return { sessionID: newSessionID }
+          }),
+        { behavior: "immediate" },
+      ),
+    () => db.run("PRAGMA foreign_keys = ON").pipe(Effect.orDie),
+  ).pipe(Effect.orDie)
+
+  return { sessionID: newSessionID, messages: newMessages.length, parts: newParts.length }
+})
+
+/**
+ * Resolve the authority rows the receipt BEFORE INSERT triggers require. Reuses an existing
+ * unexpired owner lease and a non-retired project scope identity when present; synthesizes
+ * minimal ones otherwise (an implicit_local security namespace + registered_root scope identity).
+ */
+type SnapshotTx = Parameters<Parameters<Database.Interface["db"]["transaction"]>[0]>[0]
+const resolveReceiptAuthority = Effect.fn("Session.resolveReceiptAuthority")(function* (
+  tx: SnapshotTx,
+  now: number,
+) {
+  const lease = yield* tx
+    .select({
+      owner_token: SessionProviderOwnerLeaseTable.owner_token,
+      released_at: SessionProviderOwnerLeaseTable.released_at,
+      lease_expires_at: SessionProviderOwnerLeaseTable.lease_expires_at,
+    })
+    .from(SessionProviderOwnerLeaseTable)
+    .all()
+    .pipe(Effect.orDie)
+  const validLease = lease.find((row) => row.released_at === null && row.lease_expires_at > now)
+  let ownerToken: string
+  if (validLease) {
+    ownerToken = validLease.owner_token
+  } else {
+    ownerToken = `imported-owner-${randomHex(12)}`
+    // The lease insert clock guard requires registered_at/heartbeat_at to equal the DB-observed
+    // time within the same statement; compute them atomically from julianday('now').
+    const dbNowMs = sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`
+    yield* tx
+      .insert(SessionProviderOwnerLeaseTable)
+      .values({
+        owner_token: ownerToken,
+        registered_at: dbNowMs,
+        heartbeat_at: dbNowMs,
+        lease_expires_at: sql`${dbNowMs} + 3600000`,
+        released_at: null,
+      } as never)
+      .run()
+      .pipe(Effect.orDie)
+  }
+
+  const scope = yield* tx
+    .select({
+      security_namespace_id: ProjectScopeIdentityTable.security_namespace_id,
+      project_scope_key: ProjectScopeIdentityTable.project_scope_key,
+      retired_at: ProjectScopeIdentityTable.retired_at,
+    })
+    .from(ProjectScopeIdentityTable)
+    .all()
+    .pipe(Effect.orDie)
+  const validScope = scope.find((row) => row.retired_at === null)
+  if (validScope) return { ownerToken, securityNamespaceID: validScope.security_namespace_id, projectScopeKey: validScope.project_scope_key }
+
+  const securityNamespaceID = `imported-ns-${randomHex(12)}`
+  const projectScopeKey = `imported-scope-${randomHex(8)}`
+  yield* tx
+    .insert(SecurityNamespaceTable)
+    .values({
+      id: securityNamespaceID,
+      kind: "implicit_local",
+      binding_hash: randomHex(32),
+      created_at: now,
+      retired_at: null,
+    } as never)
+    .run()
+    .pipe(Effect.orDie)
+  yield* tx
+    .insert(ProjectScopeIdentityTable)
+    .values({
+      security_namespace_id: securityNamespaceID,
+      project_scope_key: projectScopeKey,
+      project_kind: "registered_root",
+      project_identity_hash: randomHex(32),
+      created_at: now,
+      retired_at: null,
+    } as never)
+    .run()
+    .pipe(Effect.orDie)
+  return { ownerToken, securityNamespaceID, projectScopeKey }
+})
diff --git a/packages/deepagent-code/src/session/steer.ts b/packages/deepagent-code/src/session/steer.ts
index 459a3654..54a87868 100644
--- a/packages/deepagent-code/src/session/steer.ts
+++ b/packages/deepagent-code/src/session/steer.ts
@@ -30,9 +30,9 @@ import { SessionActivityOwner } from "./activity-owner"
 // REUSE-VS-NEW: the core `SessionInput` model (packages/core/src/session/input.ts) already has a
 // steer data model (Delivery="steer", admit/promoteSteers). It is NOT reused directly because it is
 // fully EVENT-SOURCED: `admit` publishes a `PromptLifecycle.Admitted` event and rows only land via the
-// `SessionProjector` — a pipeline that is dormant in the live product (deepagent-code wires
-// `SessionExecution.noopLayer` and gates the V2 event system behind `experimentalEventSystem`, default
-// OFF). Worse, `promoteSteers` materializes into the V2 `session_message` store consumed by the
+// `SessionProjector` — a pipeline that is dormant in the live product (deepagent-code provides
+// `SessionV2.liveLayer` in the SessionPrompt layer, but gates the V2 event system behind
+// `experimentalEventSystem`, default OFF; the core default layer alone wires `SessionExecution.noopLayer`). Worse, `promoteSteers` materializes into the V2 `session_message` store consumed by the
 // dormant V2 runner's `entriesForRunner` — a DIFFERENT history store than the LIVE loop, which reads
 // the V1 `MessageTable` via `MessageV2.filterCompactedEffect`. Reusing it would force activating the
 // forbidden event system AND target the wrong history. So this is a clean, PLAIN durable buffer:
diff --git a/packages/deepagent-code/src/session/tool-request-receipt.sql.ts b/packages/deepagent-code/src/session/tool-request-receipt.sql.ts
index fa581586..36727ce3 100644
--- a/packages/deepagent-code/src/session/tool-request-receipt.sql.ts
+++ b/packages/deepagent-code/src/session/tool-request-receipt.sql.ts
@@ -30,6 +30,9 @@ export const SessionToolRequestReceiptTable = sqliteTable("session_tool_request_
   context_readiness: text({ mode: "json" }).$type<ContextFederationRollout.DerivedContextDataReadiness>(),
   context_activation: text({ mode: "json" }).$type<ContextActivationReceipt.Receipt>(),
   context_activation_fingerprint: text(),
+  // FEAT-007 attribution: active_pack_set snapshot locked for the run. NULL when the snapshot
+  // id is not exposed on the federation resolve result (see prompt.ts receipt write site).
+  context_active_pack_set_snapshot_id: text(),
   released_knowledge_security_namespace_id: text().$type<SecurityNamespaceID>(),
   released_knowledge_project_scope_key: text().$type<ProjectScopeKey>(),
   released_knowledge_binding_state: text().$type<StoredBindingState>(),
diff --git a/packages/deepagent-code/src/session/turn-deadline-watchdog.ts b/packages/deepagent-code/src/session/turn-deadline-watchdog.ts
new file mode 100644
index 00000000..2d183828
--- /dev/null
+++ b/packages/deepagent-code/src/session/turn-deadline-watchdog.ts
@@ -0,0 +1,144 @@
+// BUG-407-012 gap C (conservative §8.3-3/4): provider pre-dispatch deadline watchdog.
+// A turn stuck between "legacy activity claimed" and "provider receipt created" has no
+// durable receipt for the existing outcome-unknown recovery to act on. When the opt-in
+// flag is enabled, this sweep fails such stale activities through the EXISTING
+// terminalization path (SessionPromptIntent.finalizeActivityWithoutRevision) with a typed
+// terminal reason, so an exact retry remains possible. No new recovery states are
+// introduced. Activities that already have durable receipt/dispatch evidence are never
+// touched — the existing outcome-unknown recovery stays authoritative for those.
+import { and, eq, gte, lte } from "drizzle-orm"
+import { Effect } from "effect"
+import { Database } from "@deepagent-code/core/database/database"
+import { SessionLegacyActivityRunTable, SessionLegacyActivityTable } from "./activity-sql"
+import { SessionToolRequestReceiptTable } from "./tool-request-receipt.sql"
+import { SessionPromptIntent } from "./prompt-intent"
+import { TurnStageEvidence } from "./turn-stage-evidence"
+
+export namespace TurnDeadlineWatchdog {
+  export const ReasonCode = "provider_pre_dispatch_deadline_exceeded"
+
+  export type Outcome =
+    | { readonly kind: "failed"; readonly activityID: string; readonly runID: string }
+    | { readonly kind: "skipped"; readonly activityID: string; readonly reason: string }
+
+  export interface SweepInput {
+    readonly database: Database.Interface
+    readonly deadlineMs: number
+    readonly now?: number
+  }
+
+  // Stages that prove the turn already reached request preparation or beyond — their
+  // presence means durable dispatch-side evidence exists (or existed), so the watchdog
+  // must leave the activity to the outcome-unknown recovery path.
+  const dispatchEvidenceStages = new Set<string>([
+    "request_prepared",
+    "provider_dispatch_started",
+    "terminal_settled",
+  ])
+
+  const settleOne = (
+    input: SweepInput,
+    activity: typeof SessionLegacyActivityTable.$inferSelect,
+  ) =>
+    Effect.gen(function* () {
+      const db = input.database.db
+      const run = yield* db
+        .select()
+        .from(SessionLegacyActivityRunTable)
+        .where(
+          and(
+            eq(SessionLegacyActivityRunTable.activity_id, activity.activity_id),
+            lte(SessionLegacyActivityRunTable.started_at, input.now ?? Date.now()),
+          ),
+        )
+        .all()
+      const liveRun = run.find((candidate) => candidate.state === "running" || candidate.state === "finalizing")
+      if (!liveRun) return { kind: "skipped", activityID: activity.activity_id, reason: "no_live_run" }
+      const receipt = yield* db
+        .select({ receipt_id: SessionToolRequestReceiptTable.receipt_id })
+        .from(SessionToolRequestReceiptTable)
+        .where(
+          and(
+            eq(SessionToolRequestReceiptTable.session_id, activity.session_id),
+            gte(SessionToolRequestReceiptTable.created_at, activity.created_at),
+          ),
+        )
+        .get()
+      if (receipt) return { kind: "skipped", activityID: activity.activity_id, reason: "receipt_present" }
+      const stageEvidence = yield* TurnStageEvidence.latest(db, {
+        sessionID: activity.session_id,
+        activityID: activity.activity_id,
+      })
+      if (stageEvidence && dispatchEvidenceStages.has(stageEvidence.stage))
+        return { kind: "skipped", activityID: activity.activity_id, reason: "stage_evidence_present" }
+      const runIdentity: SessionPromptIntent.RunIdentity = {
+        runID: liveRun.run_id,
+        activityID: activity.activity_id,
+        sessionID: liveRun.session_id as SessionPromptIntent.RunIdentity["sessionID"],
+        mutationEpoch: liveRun.mutation_epoch,
+        generation: liveRun.generation,
+        ownerToken: liveRun.owner_token,
+      }
+      // Reuse the existing boundary freeze: it refuses to settle while a steer is still
+      // pending for this activity (kind: "pending_steer" -> leave it to the live loop).
+      const boundary = yield* SessionPromptIntent.freezeProviderInputBoundary(runIdentity).pipe(
+        Effect.provideService(Database.Service, input.database),
+        Effect.catchTag("SessionPromptIntent.Conflict", () =>
+          Effect.succeed({ kind: "pending_steer" } as const),
+        ),
+      )
+      if (boundary.kind !== "ready")
+        return { kind: "skipped", activityID: activity.activity_id, reason: boundary.kind }
+      const result = yield* SessionPromptIntent.finalizeActivityWithoutRevision({
+        run: runIdentity,
+        membershipOrdinal: boundary.boundary.membershipOrdinal,
+        decision: {
+          state: "failed",
+          reasonCode: ReasonCode,
+          source: "same_process_recovery",
+          operationID: `${liveRun.run_id}:${ReasonCode}`,
+          ownerToken: liveRun.owner_token,
+        },
+      }).pipe(
+        Effect.provideService(Database.Service, input.database),
+        Effect.catchTag("SessionPromptIntent.Conflict", () => Effect.succeed(undefined)),
+      )
+      if (!result) return { kind: "skipped", activityID: activity.activity_id, reason: "terminal_conflict" }
+      if (result.kind === "follow_up_required")
+        return { kind: "skipped", activityID: activity.activity_id, reason: "follow_up_required" }
+      // Record-only evidence so diagnostics show the watchdog settled the turn.
+      yield* TurnStageEvidence.record(db, {
+        sessionID: activity.session_id,
+        activityID: activity.activity_id,
+        stage: "terminal_settled",
+        details: { reasonCode: ReasonCode, via: "pre_dispatch_deadline_watchdog" },
+      })
+      return { kind: "failed", activityID: activity.activity_id, runID: liveRun.run_id }
+    })
+
+  // One sweep pass. Never throws: per-activity failures degrade to a skipped outcome.
+  export const sweep = (input: SweepInput) =>
+    Effect.gen(function* () {
+      const db = input.database.db
+      const now = input.now ?? Date.now()
+      const stale = yield* db
+        .select()
+        .from(SessionLegacyActivityTable)
+        .where(and(eq(SessionLegacyActivityTable.state, "active"), lte(SessionLegacyActivityTable.created_at, now - input.deadlineMs)))
+        .all()
+      return yield* Effect.forEach(
+        stale,
+        (activity) =>
+          settleOne(input, activity).pipe(
+            Effect.catchCause((cause) =>
+              Effect.succeed({
+                kind: "skipped",
+                activityID: activity.activity_id,
+                reason: `sweep_error: ${String(cause)}`,
+              } satisfies Outcome),
+            ),
+          ),
+        { concurrency: 1 },
+      )
+    })
+}
diff --git a/packages/deepagent-code/src/session/turn-stage-evidence.sql.ts b/packages/deepagent-code/src/session/turn-stage-evidence.sql.ts
new file mode 100644
index 00000000..e00c0b8c
--- /dev/null
+++ b/packages/deepagent-code/src/session/turn-stage-evidence.sql.ts
@@ -0,0 +1,27 @@
+// BUG-407-012 gap C: drizzle-orm type bindings for session_turn_stage_evidence.
+// One row per (session_id, activity_id), upserted forward-only as the provider turn
+// crosses each boundary. Observability evidence only — never an authority.
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core"
+
+export type TurnStage =
+  | "activity_claimed"
+  | "snapshot_started"
+  | "snapshot_finished"
+  | "snapshot_degraded"
+  | "history_loaded"
+  | "request_prepared"
+  | "provider_dispatch_started"
+  | "terminal_settled"
+
+export const SessionTurnStageEvidenceTable = sqliteTable(
+  "session_turn_stage_evidence",
+  {
+    session_id: text().notNull(),
+    activity_id: text().notNull(),
+    stage: text().$type<TurnStage>().notNull(),
+    details: text({ mode: "json" }).$type<Record<string, unknown>>(),
+    stage_at: integer().notNull(),
+    updated_at: integer().notNull(),
+  },
+  (table) => [primaryKey({ columns: [table.session_id, table.activity_id] })],
+)
diff --git a/packages/deepagent-code/src/session/turn-stage-evidence.ts b/packages/deepagent-code/src/session/turn-stage-evidence.ts
new file mode 100644
index 00000000..1f9ce421
--- /dev/null
+++ b/packages/deepagent-code/src/session/turn-stage-evidence.ts
@@ -0,0 +1,111 @@
+// BUG-407-012 gap C: durable provider-turn stage evidence.
+// One row per (session_id, activity_id) records the furthest stage a provider turn
+// reached (claim -> snapshot -> history -> request -> dispatch -> settle), so a turn
+// stuck between "legacy activity claimed" and "provider receipt created" can be
+// attributed post-hoc. This is observability evidence, NOT an authority:
+//  - every write is a single forward-only upsert (stage order never regresses),
+//  - every write swallows its own failure — a turn must never die for evidence.
+import { and, desc, eq, sql } from "drizzle-orm"
+import { Cause, Effect } from "effect"
+import { Database } from "@deepagent-code/core/database/database"
+import { SessionTurnStageEvidenceTable, type TurnStage } from "./turn-stage-evidence.sql"
+
+export namespace TurnStageEvidence {
+  // Lifecycle order — index IS the forward-only ordering used by the upsert guard.
+  export const Stages = [
+    "activity_claimed",
+    "snapshot_started",
+    "snapshot_finished",
+    "snapshot_degraded",
+    "history_loaded",
+    "request_prepared",
+    "provider_dispatch_started",
+    "terminal_settled",
+  ] as const satisfies readonly TurnStage[]
+  export type Stage = (typeof Stages)[number]
+
+  export type Db = Database.Interface["db"]
+  export type Tx = Parameters<Parameters<Db["transaction"]>[0]>[0]
+
+  export interface RecordInput {
+    readonly sessionID: string
+    readonly activityID: string
+    readonly stage: Stage
+    readonly details?: Record<string, unknown>
+    readonly now?: number
+  }
+
+  export type Row = typeof SessionTurnStageEvidenceTable.$inferSelect
+
+  const stageOrderCase = (column: string) =>
+    `CASE ${column}` + Stages.map((stage, index) => ` WHEN '${stage}' THEN ${index}`).join("") + " ELSE -1 END"
+
+  const upsertSql = (input: RecordInput, now: number) => {
+    const details = input.details ? JSON.stringify(input.details) : null
+    const stageAt = input.now ?? now
+    return sql`
+      INSERT INTO session_turn_stage_evidence (session_id, activity_id, stage, details, stage_at, updated_at)
+      VALUES (${input.sessionID}, ${input.activityID}, ${input.stage}, ${details}, ${stageAt}, ${now})
+      ON CONFLICT(session_id, activity_id) DO UPDATE SET
+        stage = excluded.stage,
+        details = excluded.details,
+        stage_at = excluded.stage_at,
+        updated_at = excluded.updated_at
+      WHERE ${sql.raw(stageOrderCase("excluded.stage"))} >=
+            ${sql.raw(stageOrderCase("session_turn_stage_evidence.stage"))}
+    `
+  }
+
+  const logFailure = (input: RecordInput) => (cause: Cause.Cause<unknown>) =>
+    Effect.logWarning(`turn stage evidence write failed (${input.stage}, ${input.sessionID}): ${Cause.pretty(cause)}`)
+
+  // Reuse the caller's transaction when one is already open at the boundary.
+  export const recordInTransaction = (tx: Tx, input: RecordInput): Effect.Effect<void> =>
+    Effect.gen(function* () {
+      yield* tx.run(upsertSql(input, input.now ?? Date.now()))
+    }).pipe(Effect.catchCause(logFailure(input)))
+
+  // Standalone boundary (no enclosing transaction): one small independent write.
+  export const record = (db: Db, input: RecordInput): Effect.Effect<void> =>
+    Effect.gen(function* () {
+      yield* db.run(upsertSql(input, input.now ?? Date.now()))
+    }).pipe(Effect.catchCause(logFailure(input)))
+
+  // Read paths (diagnostics) — errors propagate to the caller on purpose.
+  export const latest = (
+    db: Db,
+    input: { readonly sessionID: string; readonly activityID?: string },
+  ) =>
+    db
+      .select()
+      .from(SessionTurnStageEvidenceTable)
+      .where(
+        input.activityID
+          ? and(
+              eq(SessionTurnStageEvidenceTable.session_id, input.sessionID),
+              eq(SessionTurnStageEvidenceTable.activity_id, input.activityID),
+            )
+          : eq(SessionTurnStageEvidenceTable.session_id, input.sessionID),
+      )
+      .orderBy(desc(SessionTurnStageEvidenceTable.updated_at))
+      .get()
+
+  export const recent = (
+    db: Db,
+    input: { readonly sessionID: string; readonly activityID?: string; readonly limit?: number },
+  ) =>
+    db
+      .select()
+      .from(SessionTurnStageEvidenceTable)
+      .where(
+        input.activityID
+          ? and(
+              eq(SessionTurnStageEvidenceTable.session_id, input.sessionID),
+              eq(SessionTurnStageEvidenceTable.activity_id, input.activityID),
+            )
+          : eq(SessionTurnStageEvidenceTable.session_id, input.sessionID),
+      )
+      .orderBy(desc(SessionTurnStageEvidenceTable.updated_at))
+      .limit(input.limit ?? 20)
+      .all()
+}
diff --git a/packages/deepagent-code/src/session/v4-event-runtime.ts b/packages/deepagent-code/src/session/v4-event-runtime.ts
index 7359b734..96097e6f 100644
--- a/packages/deepagent-code/src/session/v4-event-runtime.ts
+++ b/packages/deepagent-code/src/session/v4-event-runtime.ts
@@ -25,6 +25,7 @@ import { RuntimeFlags } from "@/effect/runtime-flags"
 import { MultiAgentRuntime } from "./multi-agent-runtime"
 import { EventDispatcher, DISPATCH_GROUP } from "./event-dispatcher"
 import { AgentHandoffConsumer, HANDOFF_GROUP } from "./agent-handoff-consumer"
+import { HandoffAdmission } from "@deepagent-code/core/deepagent/handoff-admission"
 import type { SubagentTurnRunner, SubagentTurnResult } from "./goal-loop-wiring"
 import { MessageID, SessionID } from "./schema"
 import { SessionCompletedPublisher } from "./session-completed-publisher"
@@ -660,6 +661,9 @@ const handoffConsumerLayer = Layer.effectDiscard(
 
 const executionRuntimeLayer = Layer.mergeAll(runtimeLayer, handoffConsumerLayer).pipe(
   Layer.provide(AgentExecution.layer),
+  // FEAT-008: durable handoff admission receipts (processing → accepted/rejected) consumed by the
+  // handoff consumer above.
+  Layer.provide(HandoffAdmission.layer),
 )
 
 // EventV2 is written by every Session, independently of the V4 feature flags. Keep retention running
diff --git a/packages/deepagent-code/src/snapshot/index.ts b/packages/deepagent-code/src/snapshot/index.ts
index d931a565..3952f3e3 100644
--- a/packages/deepagent-code/src/snapshot/index.ts
+++ b/packages/deepagent-code/src/snapshot/index.ts
@@ -98,10 +98,24 @@ type DiffRow = {
 
 type State = Omit<Interface, "init">
 
+// BUG-407-012 gap C: optional session attribution threaded into capture budget
+// warnings + the degraded outcome, so an over-budget snapshot can be attributed
+// to the session/activity that triggered it.
+export interface Attribution {
+  readonly sessionId?: string
+  readonly activityId?: string
+}
+
+export interface TrackOutcome {
+  readonly hash?: string
+  readonly degraded?: { readonly reason: string } & Record<string, unknown>
+}
+
 export interface Interface {
   readonly init: () => Effect.Effect<void>
   readonly cleanup: () => Effect.Effect<void>
-  readonly track: () => Effect.Effect<string | undefined>
+  readonly track: (attribution?: Attribution) => Effect.Effect<string | undefined>
+  readonly trackOutcome: (attribution?: Attribution) => Effect.Effect<TrackOutcome>
   readonly patch: (hash: string) => Effect.Effect<Patch>
   readonly restore: (snapshot: string) => Effect.Effect<void>
   readonly revert: (patches: Patch[]) => Effect.Effect<void>
@@ -284,7 +298,10 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
           yield* fs.writeFileString(target, text ? `${text}\n` : "").pipe(Effect.orDie)
         })
 
-        const add = Effect.fnUntraced(function* () {
+        // BUG-407-012 gap C: budget failures return a typed degraded attribution
+        // (reason + budget numbers) instead of a bare `false`, and budget warnings
+        // carry the session/activity attribution of the triggering turn.
+        const add = Effect.fnUntraced(function* (attribution?: Attribution) {
           yield* sync()
           const [diff, other] = yield* Effect.all(
             [
@@ -314,20 +331,30 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
               diffStderr: diff.stderr,
               otherCode: other.code,
               otherStderr: other.stderr,
+              ...attribution,
             })
-            return false
+            return { ok: false, degraded: { reason: "snapshot_discovery_failed", ...attribution } }
           }
 
           const tracked = diff.text.split("\0").filter(Boolean)
           const untracked = other.text.split("\0").filter(Boolean)
           const all = Array.from(new Set([...tracked, ...untracked]))
-          if (!all.length) return true
+          if (!all.length) return { ok: true }
           if (all.length > DiffLimits.captureCandidateFiles) {
             log.warn("snapshot capture exceeded candidate budget", {
               files: all.length,
               limit: DiffLimits.captureCandidateFiles,
+              ...attribution,
             })
-            return false
+            return {
+              ok: false,
+              degraded: {
+                reason: "snapshot_candidate_budget_exceeded",
+                files: all.length,
+                limit: DiffLimits.captureCandidateFiles,
+                ...attribution,
+              },
+            }
           }
 
           // Resolve source-repo ignore rules against the exact candidate set.
@@ -337,19 +364,21 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
             log.warn("failed to resolve snapshot ignore rules", {
               timedOut: ignored.timedOut,
               outputLimited: ignored.outputLimited,
+              ...attribution,
             })
-            return false
+            return { ok: false, degraded: { reason: "snapshot_ignore_resolution_failed", ...attribution } }
           }
 
           // Remove newly-ignored files from snapshot index to prevent re-adding
           if (ignored.files.size > 0) {
             const ignoredFiles = Array.from(ignored.files)
             log.info("removing gitignored files from snapshot", { count: ignoredFiles.length })
-            if (!(yield* drop(ignoredFiles))) return false
+            if (!(yield* drop(ignoredFiles)))
+              return { ok: false, degraded: { reason: "snapshot_index_drop_failed", ...attribution } }
           }
 
           const allow = all.filter((item) => !ignored.files.has(item))
-          if (!allow.length) return true
+          if (!allow.length) return { ok: true }
 
           const sizes = (yield* Effect.all(
             allow.map((item) =>
@@ -380,22 +409,49 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
               totalLimit: DiffLimits.captureTotalBytes,
               oversizedFile: oversized?.item,
               fileLimit: DiffLimits.captureFileBytes,
+              ...attribution,
             })
-            return false
+            return {
+              ok: false,
+              degraded: {
+                reason: "snapshot_source_budget_exceeded",
+                files: staged.length,
+                totalBytes,
+                totalLimit: DiffLimits.captureTotalBytes,
+                oversizedFile: oversized?.item,
+                fileLimit: DiffLimits.captureFileBytes,
+                ...attribution,
+              },
+            }
           }
           // Stage only the allowed candidate paths so snapshot updates stay scoped.
-          return yield* stage(staged)
+          return yield* stage(staged).pipe(
+            Effect.map((ok) => (ok ? { ok: true } : { ok: false, degraded: { reason: "snapshot_stage_failed", ...attribution } })),
+          )
         })
 
-        const capture = () =>
-          add().pipe(
+        const captureOutcome = (attribution?: Attribution): Effect.Effect<TrackOutcome> =>
+          add(attribution).pipe(
+            Effect.map((result) => (result.ok ? {} : { degraded: result.degraded })),
             Effect.timeoutOrElse({
               duration: DiffLimits.wallTime,
               orElse: () =>
-                Effect.logWarning("snapshot capture exceeded wall-time budget").pipe(Effect.as(false)),
+                Effect.logWarning("snapshot capture exceeded wall-time budget", attribution ?? {}).pipe(
+                  Effect.as({
+                    degraded: {
+                      reason: "snapshot_wall_time_budget_exceeded",
+                      wallTimeMs: Duration.toMillis(DiffLimits.wallTime),
+                      ...attribution,
+                    },
+                  }),
+                ),
             }),
           )
 
+        // Boolean shape for non-turn callers (patch/diff/revert).
+        const capture = (attribution?: Attribution) =>
+          captureOutcome(attribution).pipe(Effect.map((outcome) => !outcome.degraded))
+
         const cleanup = Effect.fnUntraced(function* () {
           return yield* locked(
             Effect.gen(function* () {
@@ -414,10 +470,10 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
           )
         })
 
-        const track = Effect.fnUntraced(function* () {
+        const trackOutcome = Effect.fnUntraced(function* (attribution?: Attribution) {
           return yield* locked(
             Effect.gen(function* () {
-              if (!(yield* enabled())) return
+              if (!(yield* enabled())) return {}
               const existed = yield* exists(state.gitdir)
               yield* fs.ensureDir(state.gitdir).pipe(Effect.orDie)
               if (!existed) {
@@ -430,16 +486,29 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
                 yield* git(["--git-dir", state.gitdir, "config", "core.fsmonitor", "false"])
                 log.info("initialized")
               }
-              if (!(yield* capture())) return
+              const captured = yield* captureOutcome(attribution)
+              if (captured.degraded) return captured
               const result = yield* git(args(["write-tree"]), { cwd: state.directory })
-              if (result.code !== 0 || result.timedOut) return
+              if (result.code !== 0 || result.timedOut)
+                return {
+                  degraded: {
+                    reason: "snapshot_write_tree_failed",
+                    exitCode: result.code,
+                    timedOut: result.timedOut,
+                    ...attribution,
+                  },
+                }
               const hash = result.text.trim()
               log.info("tracking", { hash, cwd: state.directory, git: state.gitdir })
-              return hash
+              return { hash }
             }),
           )
         })
 
+        const track = Effect.fnUntraced(function* (attribution?: Attribution) {
+          return (yield* trackOutcome(attribution)).hash
+        })
+
         const patch = Effect.fnUntraced(function* (hash: string) {
           return yield* locked(
             Effect.gen(function* () {
@@ -1038,7 +1107,7 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
           Effect.forkScoped,
         )
 
-        return { cleanup, track, patch, restore, revert, diff, diffManifest, diffFullManifest, diffFull }
+        return { cleanup, track, trackOutcome, patch, restore, revert, diff, diffManifest, diffFullManifest, diffFull }
       }),
     )
 
@@ -1049,8 +1118,11 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | AppProcess.Serv
       cleanup: Effect.fn("Snapshot.cleanup")(function* () {
         return yield* InstanceState.useEffect(state, (s) => s.cleanup())
       }),
-      track: Effect.fn("Snapshot.track")(function* () {
-        return yield* InstanceState.useEffect(state, (s) => s.track())
+      track: Effect.fn("Snapshot.track")(function* (attribution?: Attribution) {
+        return yield* InstanceState.useEffect(state, (s) => s.track(attribution))
+      }),
+      trackOutcome: Effect.fn("Snapshot.trackOutcome")(function* (attribution?: Attribution) {
+        return yield* InstanceState.useEffect(state, (s) => s.trackOutcome(attribution))
       }),
       patch: Effect.fn("Snapshot.patch")(function* (hash: string) {
         return yield* InstanceState.useEffect(state, (s) => s.patch(hash))
diff --git a/packages/deepagent-code/src/tool/activity_facade.ts b/packages/deepagent-code/src/tool/activity_facade.ts
new file mode 100644
index 00000000..0d37757a
--- /dev/null
+++ b/packages/deepagent-code/src/tool/activity_facade.ts
@@ -0,0 +1,292 @@
+/**
+ * FEAT-011 T4 — the four model-facing activity facade tools:
+ *   activity_start / activity_status / activity_result / activity_control
+ *
+ * T6 (有界结果面) is enforced here and in the dispatcher: status lists are capped at 20 entries,
+ * result projections carry only the TERMINAL view (terminalState/reason/bounded summary/structured
+ * receipt/verdict), and every free-text field passes applyResultBound + the registry's Truncate
+ * wrapper. Non-terminal result queries return the live state hint instead of partial transcripts.
+ *
+ * Permission governance: activity_start and activity_control are MUTATING — they ask under the
+ * "task" permission name (already in core MUTATING_PERMISSIONS). activity_status/activity_result
+ * are read-only and never ask. Visibility: gated by DEEPAGENT_CODE_ACTIVITY_FACADE (staged off)
+ * and primary-agent-only in the registry projection (mirrors pr_finalize).
+ */
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+import { FacadeActivity } from "@/session/facade-activity"
+
+const FacadeSubkind = Schema.Literals(["task", "goal", "panel"])
+
+const FacadeBudgetSchema = Schema.Struct({
+  maxTicks: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))).annotate({
+    description: "Max goal-loop ticks (clamped to the host policy ceiling).",
+  }),
+  maxTokens: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))).annotate({
+    description: "Max tokens across the activity (clamped to the host policy ceiling).",
+  }),
+  maxWallclockMs: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))).annotate({
+    description: "Max wall-clock milliseconds (clamped to the host policy ceiling).",
+  }),
+})
+
+// ── activity_start ────────────────────────────────────────────────────────────────────────────
+
+const StartParameters = Schema.Struct({
+  subkind: FacadeSubkind.annotate({
+    description: "Which runner backs this activity: task (durable subagent queue), goal (long-run goal loop), panel (expert panel consult).",
+  }),
+  objective: Schema.String.annotate({
+    description:
+      "The frozen objective: task description, goal objective, or the panel question. Bounded; keep it self-contained.",
+  }),
+  budget: Schema.optional(FacadeBudgetSchema).annotate({
+    description: "Optional model-requested limits; the host clamps them with min against policy ceilings.",
+  }),
+  prompt: Schema.optional(Schema.String).annotate({
+    description: "task only: the full task prompt (defaults to the objective).",
+  }),
+  subagent_type: Schema.optional(Schema.String).annotate({
+    description: "task only: the subagent type to dispatch (defaults to explore).",
+  }),
+})
+
+export const ActivityStartTool = Tool.define(
+  "activity_start",
+  Effect.gen(function* () {
+    const facade = yield* FacadeActivity.Service
+
+    const run = Effect.fn("ActivityStartTool.execute")(function* (
+      params: Schema.Schema.Type<typeof StartParameters>,
+      ctx: Tool.Context,
+    ) {
+      // MUTATING: governed under the "task" permission (in core MUTATING_PERMISSIONS).
+      yield* ctx.ask({
+        permission: "task",
+        patterns: [params.subkind],
+        always: ["*"],
+        metadata: { subkind: params.subkind, objective: params.objective.slice(0, 200) },
+      })
+      const started = yield* facade
+        .start({
+          sessionID: ctx.sessionID,
+          subkind: params.subkind,
+          objective: params.objective,
+          spawnToolCallID: ctx.callID,
+          parentMessageID: ctx.messageID,
+          budget: params.budget,
+          ...(params.prompt !== undefined ? { prompt: params.prompt } : {}),
+          ...(params.subagent_type !== undefined ? { subagentType: params.subagent_type } : {}),
+        })
+        .pipe(Effect.mapError((error) => new Error(`${error._tag}: ${("reason" in error && error.reason) || "start failed"}`)))
+      const refs = Object.entries(started.ref)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(" ")
+      return {
+        title: `Activity start (${params.subkind})`,
+        metadata: { activityID: started.activityID, subkind: started.subkind },
+        output:
+          `Activity ${started.activityID} admitted (subkind=${started.subkind}, state=active). ${refs}\n` +
+          `Budget applied: maxTicks=${started.budget.maxTicks}, maxTokens=${started.budget.maxTokens}, ` +
+          `maxWallclockMs=${started.budget.maxWallclockMs}. Admission does not mean the child provider has started. ` +
+          `Use activity_status to monitor and activity_result for the bounded terminal result.`,
+      }
+    })
+
+    return {
+      description:
+        "Start one supervised background activity (task / goal / panel) through the unified activity facade. " +
+        "Only ONE active activity per subkind is allowed per session (fail-closed). Budgets are clamped by host policy. " +
+        "Returns an admission receipt; lifecycle stays with the underlying runner.",
+      parameters: StartParameters,
+      execute: (params: Schema.Schema.Type<typeof StartParameters>, ctx: Tool.Context) => run(params, ctx).pipe(Effect.orDie),
+    }
+  }),
+)
+
+// ── activity_status ───────────────────────────────────────────────────────────────────────────
+
+const StatusParameters = Schema.Struct({
+  subkind: Schema.optional(FacadeSubkind).annotate({
+    description: "Filter to one subkind; omit to list all facade activities for this session.",
+  }),
+  limit: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(20))).annotate({
+    description: "Max entries to return (hard ceiling 20, newest first).",
+  }),
+})
+
+export const ActivityStatusTool = Tool.define(
+  "activity_status",
+  Effect.gen(function* () {
+    const facade = yield* FacadeActivity.Service
+
+    const run = Effect.fn("ActivityStatusTool.execute")(function* (
+      params: Schema.Schema.Type<typeof StatusParameters>,
+      ctx: Tool.Context,
+    ) {
+      // READ-ONLY: no permission ask.
+      const entries = yield* facade.status({
+        sessionID: ctx.sessionID,
+        ...(params.subkind !== undefined ? { subkind: params.subkind } : {}),
+        ...(params.limit !== undefined ? { limit: params.limit } : {}),
+      })
+      if (!entries.length) {
+        return {
+          title: "Activity status",
+          metadata: { count: 0 },
+          output: "No facade activities recorded for this session.",
+        }
+      }
+      const lines = entries.map((entry) => {
+        const refs = Object.entries(entry.ref)
+          .map(([key, value]) => `${key}=${value}`)
+          .join(" ")
+        return (
+          `- ${entry.activityID} [${entry.subkind}] state=${entry.state}` +
+          (entry.reason ? ` reason=${entry.reason}` : "") +
+          (entry.objective ? ` objective="${entry.objective}"` : "") +
+          (refs ? ` (${refs})` : "")
+        )
+      })
+      return {
+        title: "Activity status",
+        metadata: { count: entries.length },
+        output: `${entries.length} facade activit${entries.length === 1 ? "y" : "ies"} (newest first):\n${lines.join("\n")}`,
+      }
+    })
+
+    return {
+      description:
+        "List bounded status for this session's facade activities (task/goal/panel). Returns refs/state/reason only — " +
+        "never full child transcripts. A recovery_required state is not auto-retryable.",
+      parameters: StatusParameters,
+      execute: (params: Schema.Schema.Type<typeof StatusParameters>, ctx: Tool.Context) => run(params, ctx).pipe(Effect.orDie),
+    }
+  }),
+)
+
+// ── activity_result (T6 bounded result surface) ───────────────────────────────────────────────
+
+const ResultParameters = Schema.Struct({
+  subkind: FacadeSubkind.annotate({
+    description: "Which subkind's most recent facade activity to fetch the result for.",
+  }),
+})
+
+export const ActivityResultTool = Tool.define(
+  "activity_result",
+  Effect.gen(function* () {
+    const facade = yield* FacadeActivity.Service
+
+    const run = Effect.fn("ActivityResultTool.execute")(function* (
+      params: Schema.Schema.Type<typeof ResultParameters>,
+      ctx: Tool.Context,
+    ) {
+      // READ-ONLY: no permission ask.
+      const projection = yield* facade
+        .result({ sessionID: ctx.sessionID, subkind: params.subkind })
+        .pipe(
+          Effect.mapError(
+            (error) => new Error(`${error._tag}: no ${params.subkind} facade activity recorded for this session`),
+          ),
+        )
+      if (!projection.terminal) {
+        return {
+          title: `Activity result (${params.subkind})`,
+          metadata: { activityID: projection.activityID, terminal: false, truncated: false },
+          output:
+            `Activity ${projection.activityID} is still ${projection.state}. ` +
+            `Results are only projected once the activity reaches a terminal state. Use activity_status to monitor.`,
+        }
+      }
+      const lines: string[] = [
+        `Activity ${projection.activityID} (${projection.subkind}) terminal: state=${projection.state}` +
+          (projection.reason ? ` reason=${projection.reason}` : ""),
+      ]
+      if (projection.summary) lines.push(`Objective: ${projection.summary}`)
+      if (projection.receipt) lines.push(`Receipt: ${JSON.stringify(projection.receipt)}`)
+      if (projection.verdict !== undefined) lines.push(`Verdict: ${JSON.stringify(projection.verdict)}`)
+      if (projection.phase !== undefined) lines.push(`Goal phase: ${projection.phase}`)
+      if (projection.truncated)
+        lines.push("(result bounded by host output cap; consult the child session for the full transcript)")
+      return {
+        title: `Activity result (${params.subkind})`,
+        metadata: { activityID: projection.activityID, terminal: true, truncated: projection.truncated },
+        output: lines.join("\n"),
+      }
+    })
+
+    return {
+      description:
+        "Fetch the BOUNDED terminal result of this session's most recent facade activity of the given subkind. " +
+        "Returns only the terminal projection (state/reason/bounded summary/structured receipt or verdict) — " +
+        "never the full child transcript. Non-terminal activities return a state hint.",
+      parameters: ResultParameters,
+      execute: (params: Schema.Schema.Type<typeof ResultParameters>, ctx: Tool.Context) => run(params, ctx).pipe(Effect.orDie),
+    }
+  }),
+)
+
+// ── activity_control ──────────────────────────────────────────────────────────────────────────
+
+const ControlParameters = Schema.Struct({
+  subkind: FacadeSubkind.annotate({ description: "Which subkind's most recent facade activity to control." }),
+  action: Schema.Literals(["pause", "resume", "stop", "steer"]).annotate({
+    description:
+      "Control action. goal supports pause/resume/stop/steer; task and panel support only stop (pause/resume are not fabricated).",
+  }),
+  message: Schema.optional(Schema.String).annotate({
+    description: "steer only: guidance text delivered to the goal via the goal_steer channel.",
+  }),
+  reason: Schema.optional(Schema.String).annotate({ description: "Optional reason recorded in the audit trail." }),
+})
+
+export const ActivityControlTool = Tool.define(
+  "activity_control",
+  Effect.gen(function* () {
+    const facade = yield* FacadeActivity.Service
+
+    const run = Effect.fn("ActivityControlTool.execute")(function* (
+      params: Schema.Schema.Type<typeof ControlParameters>,
+      ctx: Tool.Context,
+    ) {
+      // MUTATING: governed under the "task" permission (in core MUTATING_PERMISSIONS).
+      yield* ctx.ask({
+        permission: "task",
+        patterns: [`${params.subkind}:${params.action}`],
+        always: ["*"],
+        metadata: { subkind: params.subkind, action: params.action },
+      })
+      const outcome = yield* facade
+        .control({
+          sessionID: ctx.sessionID,
+          subkind: params.subkind,
+          action: params.action,
+          ...(params.message !== undefined ? { message: params.message } : {}),
+          ...(params.reason !== undefined ? { reason: params.reason } : {}),
+        })
+        .pipe(Effect.mapError((error) => new Error(`${error._tag}: ${("reason" in error && error.reason) || "control failed"}`)))
+      return {
+        title: `Activity control (${params.subkind}/${params.action})`,
+        metadata: { subkind: params.subkind, action: params.action, applied: outcome.applied },
+        output: `${outcome.detail} (applied=${outcome.applied})`,
+      }
+    })
+
+    return {
+      description:
+        "Control this session's most recent facade activity of the given subkind. Delegates to each runner's existing " +
+        "control surface: goal pause/resume/stop/steer, task stop (durable close), panel stop. Unsupported combinations fail closed.",
+      parameters: ControlParameters,
+      execute: (params: Schema.Schema.Type<typeof ControlParameters>, ctx: Tool.Context) => run(params, ctx).pipe(Effect.orDie),
+    }
+  }),
+)
+
+/** Tool ids registered under the activity facade gate (used by the registry's primary-only filter). */
+export const ACTIVITY_FACADE_TOOL_IDS: ReadonlySet<string> = new Set([
+  ActivityStartTool.id,
+  ActivityStatusTool.id,
+  ActivityResultTool.id,
+  ActivityControlTool.id,
+])
diff --git a/packages/deepagent-code/src/tool/registry.ts b/packages/deepagent-code/src/tool/registry.ts
index b832b126..da4b735d 100644
--- a/packages/deepagent-code/src/tool/registry.ts
+++ b/packages/deepagent-code/src/tool/registry.ts
@@ -13,6 +13,14 @@ import { TaskReadTool } from "./task_read"
 import { TaskCloseTool } from "./task_close"
 import { TaskRecoveryTool } from "./task_recovery"
 import { PRFinalizeTool } from "./pr_finalize"
+import {
+  ActivityStartTool,
+  ActivityStatusTool,
+  ActivityResultTool,
+  ActivityControlTool,
+  ACTIVITY_FACADE_TOOL_IDS,
+} from "./activity_facade"
+import { FacadeActivity } from "@/session/facade-activity"
 import { DismissValidationTool } from "./dismiss_validation"
 import { Database } from "@deepagent-code/core/database/database"
 import { V2ProviderTurn } from "@deepagent-code/core/session/runner/v2-provider-turn"
@@ -199,6 +207,36 @@ const layerWithFacades: Layer.Layer<
     const querylog = yield* QueryLogTool
     const agent = yield* Agent.Service
 
+    // FEAT-011 T3/T4 — the unified activity facade (activity_start/status/result/control). Staged
+    // OFF by flag; the flag is the single visibility gate (flag off ⇒ zero tools even if an outer
+    // graph provides the dispatcher). When ON the dispatcher is resolved from the environment if
+    // an outer graph already provides it, otherwise built inline (hard requirements are only
+    // Database + RuntimeFlags — both already in this layer's requirement list — and every runner
+    // dependency resolves via serviceOption, so no caller of ToolRegistry.layer gains a new
+    // requirement).
+    const facadeActivityProvided = yield* Effect.serviceOption(FacadeActivity.Service)
+    const facadeActivity = !flags.activityFacade
+      ? undefined
+      : Option.isSome(facadeActivityProvided)
+        ? facadeActivityProvided.value
+        : yield* FacadeActivity.build
+    const activityFacadeTools = facadeActivity
+      ? yield* Effect.all({
+          activity_start: Tool.init(
+            yield* ActivityStartTool.pipe(Effect.provideService(FacadeActivity.Service, facadeActivity)),
+          ),
+          activity_status: Tool.init(
+            yield* ActivityStatusTool.pipe(Effect.provideService(FacadeActivity.Service, facadeActivity)),
+          ),
+          activity_result: Tool.init(
+            yield* ActivityResultTool.pipe(Effect.provideService(FacadeActivity.Service, facadeActivity)),
+          ),
+          activity_control: Tool.init(
+            yield* ActivityControlTool.pipe(Effect.provideService(FacadeActivity.Service, facadeActivity)),
+          ),
+        })
+      : undefined
+
     const state = yield* InstanceState.make<State>(
       Effect.fn("ToolRegistry.state")(function* (ctx) {
         const custom: Tool.Def[] = []
@@ -375,6 +413,14 @@ const layerWithFacades: Layer.Layer<
             ...(flags.debugTool ? [tool.debug] : []),
             ...(flags.experimentalQueryLogTool ? [tool.query_log] : []),
             ...(flags.experimentalPlanMode && flags.client === "cli" ? [tool.plan] : []),
+            ...(activityFacadeTools
+              ? [
+                  activityFacadeTools.activity_start,
+                  activityFacadeTools.activity_status,
+                  activityFacadeTools.activity_result,
+                  activityFacadeTools.activity_control,
+                ]
+              : []),
           ],
           task: tool.task,
           read: tool.read,
@@ -424,6 +470,9 @@ const layerWithFacades: Layer.Layer<
         )
       const filtered = [...registryState.builtin, ...registryState.custom].flatMap((tool) => {
         if (tool.id === PRFinalizeTool.id && input.agent.mode !== "primary") return []
+        // FEAT-011 T4: the activity facade tools are a PRIMARY-agent control surface — subagents
+        // never spawn/control activities through the facade (mirrors the pr_finalize gate).
+        if (ACTIVITY_FACADE_TOOL_IDS.has(tool.id) && input.agent.mode !== "primary") return []
         if (tool.id === CodeIntelTool.id) {
           return [projectRollout.enabled.contextQueryToolsV2 ? registryState.codeIntelV2 : registryState.codeIntelV1]
         }
diff --git a/packages/deepagent-code/src/tool/task-run.ts b/packages/deepagent-code/src/tool/task-run.ts
index 5fdbcbbb..1d45ea8d 100644
--- a/packages/deepagent-code/src/tool/task-run.ts
+++ b/packages/deepagent-code/src/tool/task-run.ts
@@ -765,6 +765,136 @@ export function recoverExpiredTaskRuns(input: { directory: string; now?: number;
             candidates,
             (candidate) =>
               Effect.gen(function* () {
+                // QUAL-005 (BUG-405-011 residue): a finalizing run whose executor died after
+                // sealing its structured completion (persistDegradedStructuredOutput /
+                // persistStructuredFinalizerResponse + sealed evidence) already holds a durable,
+                // bounded result. Recover it into its terminal state — mirroring classifyOnStartup —
+                // instead of destroying it as execution_lease_expired. Recovery only re-reads
+                // persisted material; it never invokes the provider, so bounded-retry semantics
+                // (maxAttempts: 2 + allowTextFallback) are preserved.
+                const structuredOutput = candidate.run.execution_spec?.structuredOutput
+                const recoveredCompletion =
+                  candidate.run.state === "finalizing" &&
+                  candidate.run.control_state === "open" &&
+                  candidate.run.interrupt_requested_at === null &&
+                  candidate.run.execution_owner &&
+                  (candidate.run.workspace_owner !== "run" ||
+                    ["retained", "submitted"].includes(candidate.run.worktree_state ?? "none")) &&
+                  isStructuredOutputContract(structuredOutput)
+                    ? yield* recoverStructuredOutputCompletionInTransaction(tx, {
+                        runID: candidate.run.run_id,
+                        childSessionID: candidate.run.child_session_id,
+                        ownerToken: candidate.run.execution_owner,
+                        claimGeneration: candidate.run.claim_generation,
+                        expectedVersion: candidate.run.version,
+                        attempt: candidate.run.attempts,
+                        rawResultMessageID: candidate.run.raw_result_message_id ?? undefined,
+                        contract: structuredOutput,
+                        now,
+                      })
+                    : undefined
+                if (recoveredCompletion) {
+                  const settled = yield* tx
+                    .update(TaskRunTable)
+                    .set({
+                      state: "completed",
+                      phase: "settled",
+                      control_state: "closed",
+                      reason:
+                        recoveredCompletion.structuredOutputReceipt.transport === "structured"
+                          ? "structured_output_valid"
+                          : recoveredCompletion.structuredOutputReceipt.transport === "text_fallback"
+                            ? "structured_output_text_fallback"
+                            : "structured_output_degraded_text",
+                      output: recoveredCompletion.output,
+                      structured_result_message_id: recoveredCompletion.structuredResultMessageID
+                        ? MessageID.make(recoveredCompletion.structuredResultMessageID)
+                        : null,
+                      structured_output_receipt: recoveredCompletion.structuredOutputReceipt,
+                      execution_owner: null,
+                      lease_expires_at: null,
+                      version: candidate.run.version + 1,
+                      time_updated: now,
+                      time_settled: now,
+                    })
+                    .where(
+                      and(
+                        eq(TaskRunTable.run_id, candidate.run.run_id),
+                        eq(TaskRunTable.version, candidate.run.version),
+                        eq(TaskRunTable.state, "finalizing"),
+                        eq(TaskRunTable.execution_owner, candidate.run.execution_owner!),
+                        eq(TaskRunTable.claim_generation, candidate.run.claim_generation),
+                        eq(TaskRunTable.control_state, "open"),
+                        isNull(TaskRunTable.interrupt_requested_at),
+                      ),
+                    )
+                    .returning()
+                    .get()
+                    .pipe(Effect.orDie)
+                  if (settled) {
+                    yield* tx
+                      .insert(TaskRunEventTable)
+                      .values({
+                        event_id: Identifier.ascending("event"),
+                        run_id: candidate.run.run_id,
+                        version: settled.version,
+                        type: "structured_response_recovered",
+                        from_state: "finalizing",
+                        to_state: "completed",
+                        reason:
+                          recoveredCompletion.structuredOutputReceipt.transport === "degraded_text"
+                            ? "persisted_degraded_receipt"
+                            : "persisted_structured_response",
+                        data: recoveredCompletion.structuredResultMessageID
+                          ? { response_message_id: recoveredCompletion.structuredResultMessageID }
+                          : { raw_message_id: candidate.run.raw_result_message_id },
+                        time_created: now,
+                      })
+                      .run()
+                      .pipe(Effect.orDie)
+                    if (
+                      candidate.run.effective_delivery_mode === "background" ||
+                      candidate.run.delivery_mode === "background"
+                    ) {
+                      const outboxID = `task-notify:${candidate.run.run_id}`
+                      const payload = {
+                        agent:
+                          typeof candidate.run.execution_spec?.agent === "string"
+                            ? candidate.run.execution_spec.agent
+                            : "subagent",
+                        text: `Background task completed. Call task_read({ task_id: "${candidate.run.child_session_id}" }) to read the result.`,
+                      }
+                      yield* tx
+                        .insert(TaskNotificationOutboxTable)
+                        .values({
+                          id: outboxID,
+                          run_id: candidate.run.run_id,
+                          event_kind: "terminal",
+                          correlation_id: outboxID,
+                          message_id: MessageID.ascending(
+                            `msg_task_notify_${Hash.sha256(outboxID).slice(0, 24)}`,
+                          ),
+                          parent_session_id: candidate.run.parent_session_id,
+                          directory: input.directory,
+                          payload,
+                          payload_hash: Hash.sha256(JSON.stringify(payload)),
+                          status: "pending",
+                          attempts: 0,
+                          available_at: now,
+                          time_created: now,
+                          time_updated: now,
+                        })
+                        .onConflictDoNothing()
+                        .run()
+                        .pipe(Effect.orDie)
+                    }
+                  }
+                  // Excluded from the returned runs: the caller projects each returned run as an
+                  // expired-error child session metadata (projectRecoveredSubagentRun). A recovered
+                  // completion is not an error; its foreground metadata is reconciled idempotently
+                  // by repairDurableSettledRunProjections on the next durable control-plane start.
+                  return undefined
+                }
                 const updated = yield* tx
                   .update(TaskRunTable)
                   .set({
diff --git a/packages/deepagent-code/src/tool/task.ts b/packages/deepagent-code/src/tool/task.ts
index 44880470..dd9d83a4 100644
--- a/packages/deepagent-code/src/tool/task.ts
+++ b/packages/deepagent-code/src/tool/task.ts
@@ -1326,6 +1326,7 @@ interface AttemptBundle {
   readonly structuredSettlement: { reason: StructuredOutputTerminalReason; receipt?: StructuredOutputReceipt }
   readonly submitWorktree: () => Effect.Effect<SubmittedPR | undefined, unknown>
   readonly teardownWorktree: (force: boolean) => Effect.Effect<unknown, unknown>
+  readonly mergeAutomaticWorktree: () => Effect.Effect<unknown, unknown>
 }
 
 type AttemptResult = {
@@ -2375,6 +2376,29 @@ export const TaskTool = Tool.define(
             ).pipe(Effect.ignore)
           })
 
+          // RISK-002: merge-on-success for automatic write isolation — the worker branch is merged
+          // back into the parent checkout (committed, non-fast-forward) BEFORE safeRemove. A dirty
+          // parent or a conflict preserves the worktree (safeRemove refuses unmerged work) and is
+          // surfaced to the parent instead of silently dropping the changes. Merge failures never
+          // fail a successful task.
+          const mergeAutomaticWorktree = Effect.fn("TaskTool.mergeAutomaticWorktree")(function* () {
+            if (!a.worktreeInfo || !automaticWriteIsolation) return
+            const worktreeOpt = yield* Effect.serviceOption(Worktree.Service)
+            if (Option.isNone(worktreeOpt)) return
+            const result = yield* worktreeOpt.value
+              .mergeBackAutomatic({ directory: a.worktreeInfo.directory })
+              .pipe(
+                Effect.catch((error) =>
+                  Effect.succeed({ merged: false as const, conflicted: [] as readonly string[], message: String(error) }),
+                ),
+              )
+            if (!result.merged)
+              yield* inject(
+                "error",
+                `Worker changes were NOT merged into the parent: ${result.message} The worktree is preserved at ${a.worktreeInfo.directory}.`,
+              ).pipe(Effect.ignore)
+          })
+
           // Automatically isolated write agents submit a scoped commit to the durable PR queue.
           // Explicit isolation stays detached and never enters the automatic collaboration flow.
           const parentDir = parent.directory
@@ -2411,6 +2435,7 @@ export const TaskTool = Tool.define(
             inject,
             submitWorktree,
             teardownWorktree,
+            mergeAutomaticWorktree,
           }
 
           if (allowExtend && (yield* background.extend({ id: a.nextSession.id, run: runTask() }))) {
@@ -2510,7 +2535,10 @@ export const TaskTool = Tool.define(
                 resolvedOutputSchema ? b.structuredSettlement.reason : "text_output_valid",
                 { output },
               )
-              if (!pr) yield* b.teardownWorktree(b.automaticWriteIsolation)
+              if (!pr) {
+                yield* b.mergeAutomaticWorktree()
+                yield* b.teardownWorktree(b.automaticWriteIsolation)
+              }
               return {
                 title: params.description,
                 metadata: { ...b.metadata, ...(pr ? { prId: pr.id, workerCommit: pr.workerCommit } : {}) },
@@ -2615,7 +2643,10 @@ export const TaskTool = Tool.define(
                   }),
                 },
               )
-              if (!pr) yield* b.teardownWorktree(b.automaticWriteIsolation)
+              if (!pr) {
+                yield* b.mergeAutomaticWorktree()
+                yield* b.teardownWorktree(b.automaticWriteIsolation)
+              }
               yield* b.inject("completed", output)
               return
             }
@@ -2858,6 +2889,24 @@ export const TaskTool = Tool.define(
             : worktreeOpt.value.safeRemove({ directory: worktreeInfo.directory })
         ).pipe(Effect.ignore)
       })
+      // RISK-002: merge-on-success for automatic write isolation (background run path; same
+      // semantics as the foreground helper — conflicts/dirty parent preserve the worktree and are
+      // reported; merge failures never fail a successful task).
+      const mergeAutomaticWorktree = Effect.fn("TaskTool.mergeAutomaticWorktree")(function* () {
+        if (!worktreeInfo || !automaticWriteIsolation || Option.isNone(worktreeOpt)) return
+        const result = yield* worktreeOpt.value
+          .mergeBackAutomatic({ directory: worktreeInfo.directory })
+          .pipe(
+            Effect.catch((error) =>
+              Effect.succeed({ merged: false as const, conflicted: [] as readonly string[], message: String(error) }),
+            ),
+          )
+        if (!result.merged)
+          yield* inject(
+            "error",
+            `Worker changes were NOT merged into the parent: ${result.message} The worktree is preserved at ${worktreeInfo.directory}.`,
+          ).pipe(Effect.ignore)
+      })
       const submitWorktree = Effect.fn("TaskTool.submitWorktree")(function* () {
         if (!worktreeInfo || !automaticWriteIsolation) return undefined
         if (!parent.directory || !git || !queue) {
@@ -2920,7 +2969,10 @@ export const TaskTool = Tool.define(
               }
             : {}),
         })
-        if (!pr) yield* teardownWorktree(automaticWriteIsolation)
+        if (!pr) {
+          yield* mergeAutomaticWorktree()
+          yield* teardownWorktree(automaticWriteIsolation)
+        }
         if (notifyParent) yield* inject("completed", completedOutput)
         return pr
       })
diff --git a/packages/deepagent-code/src/tool/truncate.ts b/packages/deepagent-code/src/tool/truncate.ts
index 7a50ba2d..4022da0f 100644
--- a/packages/deepagent-code/src/tool/truncate.ts
+++ b/packages/deepagent-code/src/tool/truncate.ts
@@ -55,15 +55,13 @@ function makeLayer<R>(configEffect: Effect.Effect<Config.Interface | undefined,
       const config = yield* configEffect
 
       const cleanup = Effect.fn("Truncate.cleanup")(function* () {
-        const cutoff = Identifier.timestamp(
-          Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
-        )
+        const cutoff = Date.now() - Duration.toMillis(RETENTION)
         const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
           Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
           Effect.catch(() => Effect.succeed([])),
         )
         for (const entry of entries) {
-          if (Identifier.timestamp(entry) >= cutoff) continue
+          if (retainedTimestamp(entry) >= cutoff) continue
           yield* fs.remove(path.join(TRUNCATION_DIR, entry)).pipe(Effect.catch(() => Effect.void))
         }
       })
@@ -156,6 +154,18 @@ function makeLayer<R>(configEffect: Effect.Effect<Config.Interface | undefined,
   )
 }
 
+// Identifier timestamps pack epoch-ms into a 6-byte field, so they wrap every 2^36 ms (~795 days;
+// last wrap 2026-08-14). Unwrap relative to now so retention comparisons stay correct across wrap
+// boundaries — retention (7d) is far smaller than half a cycle, so the nearest-cycle lift is exact.
+function retainedTimestamp(entry: string) {
+  const cycle = 2 ** 36
+  const now = Date.now()
+  let ts = Identifier.timestamp(entry)
+  while (ts < now - cycle / 2) ts += cycle
+  while (ts > now + cycle / 2) ts -= cycle
+  return ts
+}
+
 export const layer = makeLayer(Effect.map(Config.Service, (config) => config))
 
 export const defaultLayer = makeLayer(Effect.succeed(undefined)).pipe(
diff --git a/packages/deepagent-code/src/wiki/event-driven-archiver.ts b/packages/deepagent-code/src/wiki/event-driven-archiver.ts
index 90c929e2..f1da8d59 100644
--- a/packages/deepagent-code/src/wiki/event-driven-archiver.ts
+++ b/packages/deepagent-code/src/wiki/event-driven-archiver.ts
@@ -18,6 +18,12 @@ import * as Log from "@deepagent-code/core/util/log"
 // only starts this consumer when the event-driven path is desired. It is idempotent and best-effort
 // (archiveSessionOnCompletion never throws), so double-delivery just re-projects the same archive.
 //
+// FEAT-006 SELF-LOOP GUARD (verified in tests): the archiver's archive writes now publish
+// wiki.page.changed, but this consumer keys ONLY on ARCHIVE_TRIGGER_TYPES (session.completed /
+// goal.completed) and wiki.page.changed is NOT one — the consumer-type filter isolates the loop by
+// construction, so archiver→event→archiver can never cascade (the persisted archive doc is also a
+// context_snapshot, outside EXECUTION_ARCHIVE_TYPES, so it can never be re-archived either).
+//
 // LAYERING: `deepagent-code`. Bridges the bus (core) to the archiver (deepagent-code).
 
 const log = Log.create({ service: "event-driven-archiver" })
@@ -88,7 +94,7 @@ export const layerWith = (options?: LayerOptions) =>
             yield* ack(event) // unarchivable, terminal — acking avoids an un-fixable retry loop.
             return false
           }
-          const outcome = yield* archiveSessionOnCompletion({ workspacePath, sessionID }).pipe(
+          const outcome = yield* archiveSessionOnCompletion({ workspacePath, sessionID, bus }).pipe(
             Effect.map((archive) => ({ ok: true as const, archive })),
             Effect.catchCause((cause) => Effect.succeed({ ok: false as const, cause })),
           )
diff --git a/packages/deepagent-code/src/wiki/session-archive.ts b/packages/deepagent-code/src/wiki/session-archive.ts
index d796daae..fa000d64 100644
--- a/packages/deepagent-code/src/wiki/session-archive.ts
+++ b/packages/deepagent-code/src/wiki/session-archive.ts
@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import { Effect, Option } from "effect"
 import { existsSync, readdirSync, statSync } from "node:fs"
 import path from "node:path"
 import { Global } from "@deepagent-code/core/global"
@@ -14,6 +14,7 @@ import {
   type WikiEditGate,
 } from "./wiki-service"
 import { WikiSearchIndex } from "./search-index"
+import * as WikiEvents from "./wiki-events"
 
 /**
  * V3.9 §B — production wiring for the Wiki projection.
@@ -96,12 +97,22 @@ export const openWikiGraph = (input: { workspacePath?: string; sessionID?: strin
  * editKnowledge — omitted, the WikiService falls back to its DEFAULT_WIKI_EDIT_GATE (the minimum
  * floor). Production passes `buildWikiEditGate(memoryDir)` so a human edit goes through the SAME
  * validation gate (§B.3) as knowledge promotion (dedupe vs RejectedBuffer + replay/regression).
+ *
+ * FEAT-006: `workspacePath` is threaded into the service's event ports (labels wiki.page.changed
+ * payloads) and `bus` optionally injects the publish port. The (unmodified) handler construction
+ * point passes neither — editKnowledge then falls back to the DeepAgentEventBus.Service from its
+ * Effect runtime environment, which the route runtime provides (same seam the packs handlers use).
  */
 export const openWikiService = (input: {
   workspacePath?: string
   sessionID?: string
   gate?: WikiEditGate
-}): WikiService => (input.gate ? new WikiService(openWikiGraph(input), input.gate) : new WikiService(openWikiGraph(input)))
+  bus?: WikiEvents.WikiEventPublisher
+}): WikiService =>
+  new WikiService(openWikiGraph(input), input.gate, {
+    ...(input.bus ? { bus: input.bus } : {}),
+    ...(input.workspacePath ? { workspacePath: input.workspacePath } : {}),
+  })
 
 // A knowledge doc's type maps to the learning-candidate type space (which has no bare "knowledge" —
 // it is memory/strategy/methodology/anti_pattern). knowledge/memory → "memory"; strategy/methodology
@@ -170,12 +181,22 @@ export const openWikiSearchIndex = (input: { workspacePath?: string; sessionID?:
  * §B.6 session-completion trigger. Aggregates the session's trajectory into an ExecutionArchive.
  * Default-safe: never throws, returns null on any failure or when the session has no trajectory.
  * The caller (prompt.ts persistSuggestion) gates this on flags.experimentalWiki.
+ *
+ * FEAT-006: after the archive page is DURABLY persisted, publishes wiki.page.changed with the
+ * `archive` marker (idempotency key `wiki.page.changed:archive:<docId>:<version>`). `bus` may be
+ * injected explicitly (the event-driven archiver passes its own bus); otherwise the Effect
+ * environment's DeepAgentEventBus.Service is tried; neither available → no event (degraded no-op,
+ * archival itself is unaffected). SELF-LOOP SAFETY: this event is NOT an archive trigger
+ * (ARCHIVE_TRIGGER_TYPES = session.completed/goal.completed only), and the persisted doc is a
+ * `context_snapshot` — outside EXECUTION_ARCHIVE_TYPES — so it can never be re-archived into a
+ * later archive of the same session. No archiver→event→archiver cascade exists by construction.
  */
 export const archiveSessionOnCompletion = (input: {
   workspacePath: string
   sessionID: string
+  bus?: WikiEvents.WikiEventPublisher
 }): Effect.Effect<ExecutionArchive | null, never> =>
-  Effect.sync(() => {
+  Effect.gen(function* () {
     const graph = openWikiGraph({ workspacePath: input.workspacePath, sessionID: input.sessionID })
     const archive = buildExecutionArchive(graph, input.sessionID)
     if (archive.entries.length === 0) return null
@@ -184,17 +205,35 @@ export const archiveSessionOnCompletion = (input: {
     // new source of truth), rebuildable from the graph; it makes the assembled Markdown durably
     // available (e.g. for a Repo view) without an event bus. Idempotent via idSlug; best-effort — a
     // persist failure degrades to just returning the in-memory archive (matchCauseEffect below).
-    persistArchiveDoc(input.sessionID, archive)
+    const persisted = persistArchiveDoc(input.sessionID, archive)
+    if (persisted) {
+      // FEAT-006 — emit ONLY for a real persist (no doc → nothing changed → no event). Best-effort:
+      // publishWikiPageChanged swallows bus failures, so this can never fail the archive.
+      const bus = yield* WikiEvents.resolveBus(input.bus)
+      if (Option.isSome(bus))
+        yield* WikiEvents.publishWikiPageChanged(bus.value, {
+          workspacePath: input.workspacePath,
+          docId: persisted.id,
+          type: persisted.type,
+          version: persisted.version,
+          editor: "system:archiver",
+          archive: { sessionID: input.sessionID },
+        })
+    }
     return archive
   }).pipe(Effect.matchCauseEffect({ onFailure: () => Effect.succeed(null), onSuccess: Effect.succeed }))
 
 // Best-effort persistence of the rendered execution archive into the session's run-scoped context
 // store. Reuses the SAME context store root openWikiGraph reads, so a subsequent open projects it.
-const persistArchiveDoc = (sessionID: string, archive: ExecutionArchive): void => {
+// Returns the persisted Doc (needed by FEAT-006 to derive docId/version for the event's idempotency
+// key) or null when the session has no context store yet. DocumentStore.upsert is fingerprint-
+// idempotent: re-persisting an UNCHANGED archive returns the SAME doc at the SAME version, so the
+// wiki.page.changed idempotency key (docId+version) is stable across redelivered triggers.
+const persistArchiveDoc = (sessionID: string, archive: ExecutionArchive): Doc | null => {
   const ctxRoot = contextStoreRoot(sessionID)
-  if (!existsSync(ctxRoot)) return // no session context store yet → nothing to attach to; skip
+  if (!existsSync(ctxRoot)) return null // no session context store yet → nothing to attach to; skip
   const store = new DocumentStore(ctxRoot)
-  store.upsert({
+  return store.upsert({
     type: "context_snapshot",
     scope: `run:${sessionID}`,
     description: `execution archive ${sessionID}`,
diff --git a/packages/deepagent-code/src/wiki/wiki-events.ts b/packages/deepagent-code/src/wiki/wiki-events.ts
new file mode 100644
index 00000000..4ca5bb0b
--- /dev/null
+++ b/packages/deepagent-code/src/wiki/wiki-events.ts
@@ -0,0 +1,103 @@
+import { Effect, Option } from "effect"
+import { DeepAgentEvent } from "@deepagent-code/core/deepagent/deepagent-event"
+import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
+import { LMNEvents } from "@deepagent-code/core/deepagent/lmn-events"
+import type { DocType } from "@deepagent-code/core/deepagent/document-store"
+import * as Log from "@deepagent-code/core/util/log"
+
+/**
+ * FEAT-006 — wiki/knowledge change eventing (LMNEvents.WIKI_PAGE_CHANGED).
+ *
+ * The wiki domain was a pure event CONSUMER (the §L event-driven archiver) that never emitted
+ * anything; this module adds the producer side: a MINIMAL bus port + the best-effort publisher for
+ * `wiki.page.changed`, shared by both producers — WikiService.editKnowledge (governed human edit)
+ * and archiveSessionOnCompletion (execution-archive page persist).
+ *
+ * BUS PORT: `WikiEventPublisher` is the structural subset of the core bus the wiki needs (just
+ * `publish`) so the pure WikiService class never depends on the full bus service — tests wire an
+ * in-memory bus through the same port. `DeepAgentEventBus.Interface` satisfies it structurally.
+ *
+ * BENEFIT BOUNDARY (see the LMNEvents.WIKI_PAGE_CHANGED contract): federation knowledge graphs only
+ * ever consume released snapshots — this event is audit / UI notification / future cache
+ * invalidation only; no federation-side reaction is expected.
+ *
+ * LAYERING: `deepagent-code` (bridges the core bus vocabulary to the wiki producers).
+ */
+
+const log = Log.create({ service: "wiki-events" })
+
+// The minimal bus port the wiki producers need. Structurally satisfied by DeepAgentEventBus.Interface
+// (same port shape tests use with the in-memory bus layer).
+export type WikiEventPublisher = {
+  readonly publish: (input: DeepAgentEvent.PublishInput) => Effect.Effect<DeepAgentEvent.Event>
+}
+
+// One committed wiki page mutation. `archive` is present ONLY for execution-archive persists (the §L
+// archiver path) — it folds an archive marker into the idempotency key and labels the payload.
+export type WikiPageChange = {
+  readonly workspacePath?: string
+  readonly docId: string
+  readonly type: DocType
+  readonly version: number
+  readonly editor: string
+  readonly archive?: { readonly sessionID: string }
+}
+
+// FEAT-003 idempotency pattern: the idempotency key IS the write's natural dedup identity —
+// docId+version — so a redelivered write never double-publishes (the bus dedupes on the key).
+// Archive persists prefix `archive:` so an archive page can never collide with a human edit of the
+// same doc, and callers can tell the origin from the key alone. (Takes only the key-relevant slice
+// of WikiPageChange so tests/callers can derive a key without materializing the full payload.)
+export const wikiPageChangedIdempotencyKey = (change: {
+  readonly docId: string
+  readonly version: number
+  readonly archive?: { readonly sessionID: string }
+}): string =>
+  `wiki.page.changed:${change.archive ? "archive:" : ""}${change.docId}:${change.version}`
+
+// Publish wiki.page.changed for a COMMITTED page write. BEST-EFFORT by contract (mirrors FEAT-003's
+// publishPackChanged): the DocumentStore write already succeeded and stays authoritative — a bus
+// failure logs and is swallowed, never fails the edit/archive. `priority: "normal"` — a sheddable
+// observation, never a driver.
+export const publishWikiPageChanged = (bus: WikiEventPublisher, change: WikiPageChange): Effect.Effect<void> =>
+  bus
+    .publish({
+      type: LMNEvents.WIKI_PAGE_CHANGED,
+      source: "system",
+      workspaceID: change.workspacePath ?? "unknown",
+      actorID: change.editor,
+      idempotencyKey: wikiPageChangedIdempotencyKey(change),
+      priority: "normal",
+      payload: {
+        workspacePath: change.workspacePath,
+        docId: change.docId,
+        type: change.type,
+        version: change.version,
+        editor: change.editor,
+        ...(change.archive ? { archive: true, sessionID: change.archive.sessionID } : {}),
+      },
+    })
+    .pipe(
+      Effect.asVoid,
+      Effect.catchCause((cause) =>
+        Effect.sync(() =>
+          log.error("wiki.page.changed publish failed (page write already committed)", {
+            cause: String(cause),
+            docId: change.docId,
+            version: change.version,
+          }),
+        ),
+      ),
+    )
+
+// Resolve the bus port: an EXPLICITLY injected publisher wins (constructor/test wiring); otherwise
+// fall back to the DeepAgentEventBus.Service from the Effect environment when the surrounding
+// runtime provides it (the HTTP route runtime provides DeepAgentEventBus.defaultLayer — the same
+// seam the packs handlers use — so the unmodified wikiEdit handler gets eventing for free). No bus
+// anywhere → None → the producer silently degrades to the pre-FEAT-006 behavior (no event).
+export const resolveBus = (explicit?: WikiEventPublisher): Effect.Effect<Option.Option<WikiEventPublisher>> =>
+  explicit
+    ? Effect.succeed(Option.some(explicit))
+    : Effect.serviceOption(DeepAgentEventBus.Service).pipe(
+        Effect.map(Option.map((bus): WikiEventPublisher => bus)),
+      )
diff --git a/packages/deepagent-code/src/wiki/wiki-service.ts b/packages/deepagent-code/src/wiki/wiki-service.ts
index d4ebdad6..b4008948 100644
--- a/packages/deepagent-code/src/wiki/wiki-service.ts
+++ b/packages/deepagent-code/src/wiki/wiki-service.ts
@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect"
+import { Effect, Option, Schema } from "effect"
 import type {
   Confidence,
   Doc,
@@ -7,6 +7,7 @@ import type {
   DocumentStore,
   LinkRel,
 } from "@deepagent-code/core/deepagent/document-store"
+import * as WikiEvents from "./wiki-events"
 
 /**
  * V3.9 §B — Repo & Wiki（人向监督层）: the WikiService.
@@ -335,9 +336,21 @@ const renderMarkdown = (doc: Doc, editable: boolean): string => {
 export class WikiService {
   private readonly gate: WikiEditGate
 
+  /**
+   * FEAT-006 event ports (both optional — the service degrades to its pre-FEAT-006 behavior without
+   * them): `bus` is the wiki-events port a committed editKnowledge publishes wiki.page.changed
+   * through; `workspacePath` labels the event payload (openWikiService threads it from its input).
+   * When `bus` is absent the editKnowledge Effect still tries the DeepAgentEventBus.Service from
+   * its runtime environment (the HTTP route runtime provides it — same seam the packs handlers
+   * use), so the unmodified handler construction point gets eventing without signature changes.
+   */
   constructor(
     private readonly graph: WikiGraph,
     gate: WikiEditGate = DEFAULT_WIKI_EDIT_GATE,
+    private readonly ports: {
+      readonly bus?: WikiEvents.WikiEventPublisher
+      readonly workspacePath?: string
+    } = {},
   ) {
     this.gate = gate
   }
@@ -395,10 +408,46 @@ export class WikiService {
         source: "human",
         evidence_refs: [`human:${input.editor.id}${input.editor.name ? `:${input.editor.name}` : ""}`],
       })
-      return this.crossLinks(updated.id).pipe(Effect.map((crossLinks) => this.pageOf(updated, crossLinks)))
+      // FEAT-006 — AFTER the write commits, publish wiki.page.changed (best-effort, never fails the
+      // edit). Idempotency key = docId+version (wiki-events), so a redelivered edit never
+      // double-publishes. Self-loop note: the event-driven archiver consumes ONLY archive triggers
+      // (session.completed/goal.completed), and wiki.page.changed is not one — no consumer of this
+      // event writes back into the wiki, so there is no producer→event→archiver cascade.
+      return this.emitPageChanged({
+        docId: updated.id,
+        type: updated.type,
+        version: updated.version,
+        editor: input.editor.id,
+      }).pipe(
+        Effect.flatMap(() => this.crossLinks(updated.id)),
+        Effect.map((crossLinks) => this.pageOf(updated, crossLinks)),
+      )
     })
   }
 
+  // FEAT-006 — resolve the bus port (injected > Effect environment) and emit wiki.page.changed for
+  // a committed edit. Never fails: no bus wired → silent skip; publish error → logged + swallowed.
+  private emitPageChanged(change: {
+    readonly docId: string
+    readonly type: DocType
+    readonly version: number
+    readonly editor: string
+  }): Effect.Effect<void> {
+    return WikiEvents.resolveBus(this.ports.bus).pipe(
+      Effect.flatMap((bus) =>
+        Option.isNone(bus)
+          ? Effect.void
+          : WikiEvents.publishWikiPageChanged(bus.value, {
+              workspacePath: this.ports.workspacePath,
+              docId: change.docId,
+              type: change.type,
+              version: change.version,
+              editor: change.editor,
+            }),
+      ),
+    )
+  }
+
   // §B.5 crossLinks: docs↔code from graph edges. A code_symbol edge whose target no longer resolves
   // is marked stale (NOT dropped). Never fails.
   crossLinks(docId: string): Effect.Effect<WikiCrossLinks, never> {
diff --git a/packages/deepagent-code/src/worktree/index.ts b/packages/deepagent-code/src/worktree/index.ts
index 54ab1a8e..e89da88e 100644
--- a/packages/deepagent-code/src/worktree/index.ts
+++ b/packages/deepagent-code/src/worktree/index.ts
@@ -231,6 +231,12 @@ export interface Interface {
   readonly branchSummary: (input: RemoveInput) => Effect.Effect<BranchSummary, Error>
   // U3: merge the worktree branch back to the default branch (preflight + no auto-commit).
   readonly mergeBack: (input: RemoveInput) => Effect.Effect<MergeResult, Error>
+  /**
+   * RISK-002: automatic (no user confirmation) merge for the task tool's automatic write
+   * isolation success path. Unlike the interactive mergeBack it refuses a dirty parent checkout,
+   * commits the merge instead of staging it, and surfaces a failed abort as an error.
+   */
+  readonly mergeBackAutomatic: (input: RemoveInput) => Effect.Effect<MergeResult, Error>
   // L3c (subagent-control-plane-design.zh-CN.md §3.2.2)
   // Resolve an exact worktree identity without creating files, branches, or registrations. Callers
   // persist this plan before invoking ensureExact so crash recovery can adopt only the same resource.
@@ -921,6 +927,61 @@ export const layer: Layer.Layer<
       } satisfies MergeResult
     })
 
+    // RISK-002: merge-on-success for automatic task isolation. Safety rules (audit-mandated):
+    //  - parent checkout must be clean, otherwise the merge commit would swallow unrelated edits;
+    //  - the merge is committed (--no-ff) so success leaves a durable merge commit;
+    //  - on conflict the merge aborts and a FAILED abort is an error, never silently ignored;
+    //  - failure keeps the worktree (the caller's safeRemove refuses to delete unmerged work).
+    const mergeBackAutomatic = Effect.fn("Worktree.mergeBackAutomatic")(function* (input: RemoveInput) {
+      const ctx = yield* InstanceState.context
+      if (ctx.project.vcs !== "git")
+        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
+      const entry = yield* resolveEntry(input.directory)
+      if (!entry?.branch) return yield* new MergeFailedError({ message: "Worktree has no branch to merge" })
+
+      const parentStatus = yield* safeGit(["status", "--porcelain"], ctx.worktree)
+      if (parentStatus.code !== 0 || parentStatus.text.split("\n").some((line) => line.trim()))
+        return {
+          merged: false,
+          conflicted: [],
+          message: "parent checkout has uncommitted changes; automatic merge skipped",
+        } satisfies MergeResult
+
+      const base = yield* gitSvc.defaultBranch(ctx.worktree).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      if (!base) return yield* new MergeFailedError({ message: "Default branch not found" })
+
+      const merge = yield* git(["merge", "--no-ff", entry.branch, "-m", `Merge ${entry.branch} (task worktree)`], {
+        cwd: ctx.worktree,
+      })
+      if (merge.code !== 0) {
+        const conflicts = yield* safeGit(["diff", "--name-only", "--diff-filter=U"], ctx.worktree)
+        const files =
+          conflicts.code === 0
+            ? conflicts.text
+                .split("\n")
+                .map((l) => l.trim())
+                .filter(Boolean)
+            : []
+        const abort = yield* safeGit(["merge", "--abort"], ctx.worktree)
+        if (abort.code !== 0)
+          return yield* new MergeFailedError({
+            message: `Merge failed and merge --abort also failed; parent may be mid-merge: ${abort.stderr || abort.text}`,
+          })
+        return {
+          merged: false,
+          conflicted: files,
+          message: files.length
+            ? `Merge has conflicts in ${files.length} file(s); merge aborted, worktree preserved.`
+            : merge.stderr || merge.text || "Merge failed.",
+        } satisfies MergeResult
+      }
+      return {
+        merged: true,
+        conflicted: [],
+        message: `Merged ${entry.branch} into ${base.name}.`,
+      } satisfies MergeResult
+    })
+
     const planExact: Interface["planExact"] = Effect.fn("Worktree.planExact")(function* (input) {
       const ctx = yield* InstanceState.context
       if (ctx.project.vcs !== "git")
@@ -954,6 +1015,7 @@ export const layer: Layer.Layer<
       diff,
       branchSummary,
       mergeBack,
+      mergeBackAutomatic,
       planExact,
       // L3c: exact-match creation — no random-suffix fallback, caller holds receipt in task_run
       ensureExact: Effect.fn("Worktree.ensureExact")(function* (input: WorktreeExactInput) {
diff --git a/packages/deepagent-code/test/agent/pr-collaboration.test.ts b/packages/deepagent-code/test/agent/pr-collaboration.test.ts
index b61e6e3b..e8e32878 100644
--- a/packages/deepagent-code/test/agent/pr-collaboration.test.ts
+++ b/packages/deepagent-code/test/agent/pr-collaboration.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { afterEach, describe, expect } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import { Effect, Layer } from "effect"
@@ -8,7 +8,13 @@ import { PRQueue } from "@/agent/pr-queue"
 import { coordinator, ensureSessionBranch } from "@/agent/pr-collaboration"
 import { ReviewVerdictContract } from "@/collaboration/review-contract"
 import { testEffect } from "../lib/effect"
-import { TestInstance } from "../fixture/fixture"
+import { disposeAllInstances, TestInstance } from "../fixture/fixture"
+
+// Dispose any instances loaded into the process-wide AppRuntime instance
+// store so this file leaves no shared state for files that run after it.
+afterEach(async () => {
+  await disposeAllInstances()
+})
 
 const layer = Layer.mergeAll(Git.defaultLayer, Worktree.defaultLayer, PRQueue.layer).pipe(
   Layer.provideMerge(Worktree.defaultLayer),
diff --git a/packages/deepagent-code/test/cli/goal-worktree.test.ts b/packages/deepagent-code/test/cli/goal-worktree.test.ts
new file mode 100644
index 00000000..fd8a9fab
--- /dev/null
+++ b/packages/deepagent-code/test/cli/goal-worktree.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { cliIt } from "../lib/cli-process"
+
+// PARITY-004 long-tail: goal controls + worktree basics. All commands go
+// through the in-process instance httpapi (no attach needed), so a fresh
+// isolated home is enough.
+describe("deepagentCode goal (non-interactive subprocess)", () => {
+  cliIt.concurrent(
+    "goal status reports no active goal (table + json)",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const table = yield* deepagentCode.spawn(["goal", "status", "ses_parity000001"])
+        deepagentCode.expectExit(table, 0, "goal status")
+        expect(table.stderr + table.stdout).toContain("No active goal for session ses_parity000001")
+
+        const json = yield* deepagentCode.spawn(["goal", "status", "ses_parity000001", "--format", "json"])
+        deepagentCode.expectExit(json, 0, "goal status --format json")
+        const parsed = JSON.parse(json.stdout) as { sessionID: string; goal: unknown }
+        expect(parsed.sessionID).toBe("ses_parity000001")
+        expect(parsed.goal).toBeNull()
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "goal pause/resume/stop fail with a friendly error when no goal is active",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        for (const action of ["pause", "resume", "stop"]) {
+          const result = yield* deepagentCode.spawn(["goal", action, "ses_parity000002"])
+          expect(result.exitCode, `goal ${action} should fail`).not.toBe(0)
+          expect(result.stderr + result.stdout).toContain(`Could not ${action} the goal for session ses_parity000002`)
+        }
+      }),
+    90_000,
+  )
+})
+
+describe("deepagentCode worktree (non-interactive subprocess)", () => {
+  cliIt.concurrent(
+    "worktree list prints an empty set for a fresh non-git home",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const table = yield* deepagentCode.spawn(["worktree", "list"])
+        deepagentCode.expectExit(table, 0, "worktree list")
+        expect(table.stdout).toContain("(empty)")
+
+        const json = yield* deepagentCode.spawn(["worktree", "list", "--format", "json"])
+        deepagentCode.expectExit(json, 0, "worktree list --format json")
+        expect(JSON.parse(json.stdout)).toEqual([])
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "worktree remove fails with a clear error for an unknown directory",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const result = yield* deepagentCode.spawn(["worktree", "remove", "/tmp/not-a-worktree-parity"])
+        expect(result.exitCode).not.toBe(0)
+        expect(result.stderr + result.stdout).not.toBe("")
+      }),
+    60_000,
+  )
+})
diff --git a/packages/deepagent-code/test/cli/help/__snapshots__/help-snapshots.test.ts.snap b/packages/deepagent-code/test/cli/help/__snapshots__/help-snapshots.test.ts.snap
index 7a6e70ea..607fe076 100644
--- a/packages/deepagent-code/test/cli/help/__snapshots__/help-snapshots.test.ts.snap
+++ b/packages/deepagent-code/test/cli/help/__snapshots__/help-snapshots.test.ts.snap
@@ -28,7 +28,12 @@ manage MCP (Model Context Protocol) servers
 
 Commands:
   deepagent-code mcp add [name]     add an MCP server
+  deepagent-code mcp remove <name>  remove an MCP server from the project or global config
+                                                                                       [aliases: rm]
+  deepagent-code mcp edit <name>    edit an existing MCP server's configuration
+                                    (url/env/header/command)
   deepagent-code mcp list           list MCP servers and their status                  [aliases: ls]
+  deepagent-code mcp catalog        list preset MCP servers from the vetted catalog (metadata only)
   deepagent-code mcp auth [name]    authenticate with an OAuth-enabled MCP server
   deepagent-code mcp logout [name]  remove OAuth credentials for an MCP server
   deepagent-code mcp debug <name>   debug OAuth connection for an MCP server
@@ -112,8 +117,14 @@ Options:
                                                                                             [number]
   -i, --interactive                   run in direct interactive split-footer mode
                                                                           [boolean] [default: false]
-      --dangerously-skip-permissions  auto-approve permissions that are not explicitly denied
-                                      (dangerous!)                        [boolean] [default: false]
+      --dangerously-skip-permissions  alias for --permission-mode full-access: auto-approve
+                                      permissions not explicitly denied (dangerous!)
+                                                                          [boolean] [default: false]
+      --permission-mode               permission auto-response mode: request rejects every prompt,
+                                      read-only rejects mutating tools
+                                      (edit/write/patch/bash/task/external_directory) and approves
+                                      the rest, full-access approves everything (dangerous!)
+                                           [string] [choices: "request", "read-only", "full-access"]
       --question-answer               answer unattended Question prompts in order; repeat once per
                                       question (otherwise auto-reject)                       [array]
       --demo                          enable direct interactive demo slash commands; pass one as the
@@ -236,7 +247,9 @@ Options:
                                                                           [boolean] [default: false]
       --mdns-domain  custom domain name for mDNS service (default: deepagent-code.local)
                                                           [string] [default: "deepagent-code.local"]
-      --cors         additional domains to allow for CORS                      [array] [default: []]"
+      --cors         additional domains to allow for CORS                      [array] [default: []]
+      --register     register this server with the local CLI daemon (writes state/server.json)
+                                                                          [boolean] [default: false]"
 `;
 
 exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode web --help 1`] = `
@@ -367,8 +380,10 @@ exports[`deepagentCode CLI help-text snapshots every documented command emits st
 manage sessions
 
 Commands:
-  deepagent-code session list                list sessions
-  deepagent-code session delete <sessionID>  delete a session
+  deepagent-code session list                        list sessions
+  deepagent-code session delete <sessionID>          delete a session
+  deepagent-code session rename <sessionID> <title>  rename a session
+  deepagent-code session archive <sessionID>         archive a session (or restore it with --undo)
 
 Options:
   -h, --help        show help                                                              [boolean]
@@ -417,6 +432,126 @@ Options:
       --format      Output format                 [string] [choices: "json", "tsv"] [default: "tsv"]"
 `;
 
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode goal --help 1`] = `
+"deepagent-code goal
+
+inspect and control the goal loop of a session
+
+Commands:
+  deepagent-code goal status <sessionID>  show the active goal of a session
+  deepagent-code goal pause <sessionID>   pause the goal loop of a session
+  deepagent-code goal resume <sessionID>  resume the goal loop of a session
+  deepagent-code goal stop <sessionID>    stop the goal loop of a session
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode worktree --help 1`] = `
+"deepagent-code worktree
+
+manage git worktrees for the current project
+
+Commands:
+  deepagent-code worktree list                list worktrees of the current project    [aliases: ls]
+  deepagent-code worktree create              create a new worktree
+  deepagent-code worktree remove <directory>  remove a worktree (fail-closed unless --force)
+                                                                                       [aliases: rm]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode oversight --help 1`] = `
+"deepagent-code oversight
+
+inspect the agent oversight plane (approvals, metrics)
+
+Commands:
+  deepagent-code oversight list     list pending approval queue items                  [aliases: ls]
+  deepagent-code oversight metrics  show oversight metrics (DLQ, success rate, conflict rate)
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode panel --help 1`] = `
+"deepagent-code panel
+
+inspect the Expert Panel state
+
+Commands:
+  deepagent-code panel status <sessionID>  show the effective Expert Panel armed state for a session
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode review --help 1`] = `
+"deepagent-code review
+
+inspect DeepAgent run reviews
+
+Commands:
+  deepagent-code review list  list recent DeepAgent run reviews                        [aliases: ls]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode wiki --help 1`] = `
+"deepagent-code wiki
+
+browse and search the project Wiki
+
+Commands:
+  deepagent-code wiki list           list Wiki pages                                   [aliases: ls]
+  deepagent-code wiki search <text>  full-text search over the Wiki
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode packs --help 1`] = `
+"deepagent-code packs
+
+inspect domain packs
+
+Commands:
+  deepagent-code packs list  list active domain packs (or the full catalog with --all) [aliases: ls]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
 exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode mcp list --help 1`] = `
 "deepagent-code mcp list
 
@@ -595,6 +730,328 @@ Options:
       --pure        run without external plugins                                           [boolean]"
 `;
 
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode session rename --help 1`] = `
+"deepagent-code session rename <sessionID> <title>
+
+rename a session
+
+Positionals:
+  sessionID  session ID to rename                                                [string] [required]
+  title      new title for the session                                           [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode session archive --help 1`] = `
+"deepagent-code session archive <sessionID>
+
+archive a session (or restore it with --undo)
+
+Positionals:
+  sessionID  session ID to archive                                               [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --undo        restore an archived session                           [boolean] [default: false]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode mcp edit --help 1`] = `
+"deepagent-code mcp edit <name>
+
+edit an existing MCP server's configuration (url/env/header/command)
+
+Positionals:
+  name  name of the MCP server                                                   [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --url         new URL for a remote MCP server                                         [string]
+      --env         environment variable for a local MCP server (KEY=VALUE, merged)          [array]
+      --header      HTTP header for a remote MCP server (KEY=VALUE, merged)                  [array]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode goal status --help 1`] = `
+"deepagent-code goal status <sessionID>
+
+show the active goal of a session
+
+Positionals:
+  sessionID  session ID                                                          [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode goal pause --help 1`] = `
+"deepagent-code goal pause <sessionID>
+
+pause the goal loop of a session
+
+Positionals:
+  sessionID  session ID                                                          [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode goal resume --help 1`] = `
+"deepagent-code goal resume <sessionID>
+
+resume the goal loop of a session
+
+Positionals:
+  sessionID  session ID                                                          [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode goal stop --help 1`] = `
+"deepagent-code goal stop <sessionID>
+
+stop the goal loop of a session
+
+Positionals:
+  sessionID  session ID                                                          [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode worktree list --help 1`] = `
+"deepagent-code worktree list
+
+list worktrees of the current project
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode worktree create --help 1`] = `
+"deepagent-code worktree create
+
+create a new worktree
+
+Options:
+  -h, --help           show help                                                           [boolean]
+  -v, --version        show version number                                                 [boolean]
+      --print-logs     print logs to stderr                                                [boolean]
+      --log-level      log level                [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure           run without external plugins                                        [boolean]
+      --attach         attach to a running server (e.g. http://localhost:4096)              [string]
+      --password       password for the attached server                                     [string]
+      --username       username for the attached server                                     [string]
+      --format         output format          [string] [choices: "table", "json"] [default: "table"]
+      --name           worktree/branch name (default: auto-generated)                       [string]
+      --start-command  additional startup script to run after the project's start command   [string]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode worktree remove --help 1`] = `
+"deepagent-code worktree remove <directory>
+
+remove a worktree (fail-closed unless --force)
+
+Positionals:
+  directory  worktree directory to remove                                        [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --force       remove even if the worktree has uncommitted changes   [boolean] [default: false]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode oversight list --help 1`] = `
+"deepagent-code oversight list
+
+list pending approval queue items
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode oversight metrics --help 1`] = `
+"deepagent-code oversight metrics
+
+show oversight metrics (DLQ, success rate, conflict rate)
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]
+      --from        window start (epoch ms)                                                 [string]
+      --to          window end (epoch ms)                                                   [string]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode panel status --help 1`] = `
+"deepagent-code panel status <sessionID>
+
+show the effective Expert Panel armed state for a session
+
+Positionals:
+  sessionID  session ID                                                          [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode review list --help 1`] = `
+"deepagent-code review list
+
+list recent DeepAgent run reviews
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode wiki list --help 1`] = `
+"deepagent-code wiki list
+
+list Wiki pages
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]
+      --type        filter by page type                                                     [string]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode wiki search --help 1`] = `
+"deepagent-code wiki search <text>
+
+full-text search over the Wiki
+
+Positionals:
+  text  search text                                                              [string] [required]
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --type        filter by page type                                                     [string]
+      --scope       filter by scope                                                         [string]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]"
+`;
+
+exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode packs list --help 1`] = `
+"deepagent-code packs list
+
+list active domain packs (or the full catalog with --all)
+
+Options:
+  -h, --help        show help                                                              [boolean]
+  -v, --version     show version number                                                    [boolean]
+      --print-logs  print logs to stderr                                                   [boolean]
+      --log-level   log level                   [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure        run without external plugins                                           [boolean]
+      --attach      attach to a running server (e.g. http://localhost:4096)                 [string]
+      --password    password for the attached server                                        [string]
+      --username    username for the attached server                                        [string]
+      --format      output format             [string] [choices: "table", "json"] [default: "table"]
+      --all         show the full installed catalog instead of the active set
+                                                                          [boolean] [default: false]"
+`;
+
 exports[`deepagentCode CLI help-text snapshots every documented command emits stable help text: deepagentCode github install --help 1`] = `
 "deepagent-code github install
 
diff --git a/packages/deepagent-code/test/cli/help/help-snapshots.test.ts b/packages/deepagent-code/test/cli/help/help-snapshots.test.ts
index 6bee92d6..d9d727bd 100644
--- a/packages/deepagent-code/test/cli/help/help-snapshots.test.ts
+++ b/packages/deepagent-code/test/cli/help/help-snapshots.test.ts
@@ -64,6 +64,13 @@ const TOP_LEVEL = [
   "session",
   "plugin",
   "db",
+  "goal",
+  "worktree",
+  "oversight",
+  "panel",
+  "review",
+  "wiki",
+  "packs",
 ] as const
 
 // Subcommands worth pinning. Not exhaustive — the goal is one snapshot per
@@ -81,6 +88,23 @@ const SUBCOMMANDS = [
   ["agent", "list"],
   ["session", "list"],
   ["session", "delete"],
+  ["session", "rename"],
+  ["session", "archive"],
+  ["mcp", "edit"],
+  ["goal", "status"],
+  ["goal", "pause"],
+  ["goal", "resume"],
+  ["goal", "stop"],
+  ["worktree", "list"],
+  ["worktree", "create"],
+  ["worktree", "remove"],
+  ["oversight", "list"],
+  ["oversight", "metrics"],
+  ["panel", "status"],
+  ["review", "list"],
+  ["wiki", "list"],
+  ["wiki", "search"],
+  ["packs", "list"],
   ["github", "install"],
   ["github", "run"],
   ["db", "path"],
diff --git a/packages/deepagent-code/test/cli/mcp-catalog.test.ts b/packages/deepagent-code/test/cli/mcp-catalog.test.ts
new file mode 100644
index 00000000..e2c35012
--- /dev/null
+++ b/packages/deepagent-code/test/cli/mcp-catalog.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { cliIt } from "../lib/cli-process"
+
+// PARITY-004 quick-win regression: `mcp catalog` mirrors the GUI preset catalog
+// (groups/mcp.ts `catalog` endpoint consumed by dialog-add-mcp.tsx). Listing is
+// metadata only — nothing connects — so the fixture needs no LLM traffic.
+describe("deepagentCode mcp catalog (non-interactive subprocess)", () => {
+  cliIt.concurrent(
+    "lists the vetted preset catalog as JSON",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const result = yield* deepagentCode.spawn(["mcp", "catalog", "--format", "json"])
+        deepagentCode.expectExit(result, 0)
+
+        const entries = JSON.parse(result.stdout) as Array<{
+          id: string
+          title: string
+          transport: string
+          riskTier: string
+          credentials: Array<{ key: string }>
+        }>
+        const ids = entries.map((entry) => entry.id)
+        expect(ids).toContain("github")
+        expect(ids).toContain("filesystem")
+
+        for (const entry of entries) {
+          expect(["local", "remote"]).toContain(entry.transport)
+          expect(["read_only", "write_guarded", "external_fetch"]).toContain(entry.riskTier)
+          expect(entry.title.length).toBeGreaterThan(0)
+        }
+
+        const github = entries.find((entry) => entry.id === "github")!
+        expect(github.credentials.some((credential) => credential.key.length > 0)).toBe(true)
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "prints a human-readable table by default",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const result = yield* deepagentCode.spawn(["mcp", "catalog"])
+        deepagentCode.expectExit(result, 0)
+        const output = result.stdout + result.stderr
+        expect(output).toContain("github")
+        expect(output).toContain("GitHub")
+      }),
+    60_000,
+  )
+})
diff --git a/packages/deepagent-code/test/cli/mcp-edit.test.ts b/packages/deepagent-code/test/cli/mcp-edit.test.ts
new file mode 100644
index 00000000..6480de86
--- /dev/null
+++ b/packages/deepagent-code/test/cli/mcp-edit.test.ts
@@ -0,0 +1,137 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { parse } from "jsonc-parser"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import path from "path"
+import { cliIt } from "../lib/cli-process"
+
+// PARITY-004 long-tail: `mcp edit` rewrites an EXISTING server entry in place
+// (updateMcpConfig semantics). Like add/remove, edits must preserve comments
+// and sibling keys (jsonc-parser field-level modify).
+describe("deepagentCode mcp edit (non-interactive subprocess)", () => {
+  cliIt.concurrent(
+    "updates a remote server url/header while preserving comments and siblings",
+    ({ home, deepagentCode }) =>
+      Effect.gen(function* () {
+        const configPath = path.join(home, ".deepagent", "code", "config.jsonc")
+        const seeded = [
+          "{",
+          "  // user comment must survive the edit",
+          '  "theme": "dark",',
+          '  "mcp": {',
+          '    "github": {',
+          '      "type": "remote",',
+          '      "url": "https://old.example.com/mcp",',
+          '      "headers": { "x-token": "keep-me" }',
+          "    },",
+          '    "keeper": {',
+          '      "type": "local",',
+          '      "command": ["echo", "hi"]',
+          "    }",
+          "  }",
+          "}",
+        ].join("\n")
+        yield* Effect.promise(async () => {
+          await mkdir(path.dirname(configPath), { recursive: true })
+          await writeFile(configPath, seeded, "utf8")
+        })
+
+        const result = yield* deepagentCode.spawn([
+          "mcp",
+          "edit",
+          "github",
+          "--url",
+          "https://new.example.com/mcp",
+          "--header",
+          "Authorization=Bearer abc",
+        ])
+        deepagentCode.expectExit(result, 0)
+
+        const text = yield* Effect.promise(() => readFile(configPath, "utf8"))
+        expect(text).toContain("// user comment must survive the edit")
+        const config = parse(text)
+        expect(config.theme).toBe("dark")
+        expect(config.mcp.github).toEqual({
+          type: "remote",
+          url: "https://new.example.com/mcp",
+          headers: { "x-token": "keep-me", Authorization: "Bearer abc" },
+        })
+        expect(config.mcp.keeper).toEqual({ type: "local", command: ["echo", "hi"] })
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "merges environment into a local server defined in the project config",
+    ({ home, deepagentCode }) =>
+      Effect.gen(function* () {
+        const configPath = path.join(home, "deepagent-code.json")
+        const seeded = [
+          "{",
+          '  "mcp": {',
+          '    "fs-server": {',
+          '      "type": "local",',
+          '      "command": ["echo", "hi"],',
+          '      "environment": { "EXISTING": "1" }',
+          "    }",
+          "  }",
+          "}",
+        ].join("\n")
+        yield* Effect.promise(() => writeFile(configPath, seeded, "utf8"))
+
+        const result = yield* deepagentCode.spawn(["mcp", "edit", "fs-server", "--env", "DEBUG=true"])
+        deepagentCode.expectExit(result, 0)
+
+        const config = parse(yield* Effect.promise(() => readFile(configPath, "utf8")))
+        expect(config.mcp["fs-server"]).toEqual({
+          type: "local",
+          command: ["echo", "hi"],
+          environment: { EXISTING: "1", DEBUG: "true" },
+        })
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "rejects edits that do not match the server type",
+    ({ home, deepagentCode }) =>
+      Effect.gen(function* () {
+        const configPath = path.join(home, "deepagent-code.json")
+        const seeded = [
+          "{",
+          '  "mcp": {',
+          '    "local-only": {',
+          '      "type": "local",',
+          '      "command": ["echo", "hi"]',
+          "    }",
+          "  }",
+          "}",
+        ].join("\n")
+        yield* Effect.promise(() => writeFile(configPath, seeded, "utf8"))
+
+        const result = yield* deepagentCode.spawn(["mcp", "edit", "local-only", "--url", "https://example.com/mcp"])
+        expect(result.exitCode).not.toBe(0)
+        expect(result.stderr + result.stdout).toContain("--url/--header only apply to remote servers")
+
+        // The file must be untouched.
+        const config = parse(yield* Effect.promise(() => readFile(configPath, "utf8")))
+        expect(config.mcp["local-only"]).toEqual({ type: "local", command: ["echo", "hi"] })
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "fails with a clear error when the server is not configured anywhere",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const result = yield* deepagentCode.spawn(["mcp", "edit", "ghost", "--url", "https://example.com/mcp"])
+        expect(result.exitCode).not.toBe(0)
+        expect(result.stderr + result.stdout).toContain("MCP server not found: ghost")
+
+        const noChanges = yield* deepagentCode.spawn(["mcp", "edit", "ghost"])
+        expect(noChanges.exitCode).not.toBe(0)
+        expect(noChanges.stderr + noChanges.stdout).toContain("No changes provided")
+      }),
+    60_000,
+  )
+})
diff --git a/packages/deepagent-code/test/cli/mcp-remove.test.ts b/packages/deepagent-code/test/cli/mcp-remove.test.ts
new file mode 100644
index 00000000..e0c8bdfb
--- /dev/null
+++ b/packages/deepagent-code/test/cli/mcp-remove.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { parse } from "jsonc-parser"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import path from "path"
+import { cliIt } from "../lib/cli-process"
+
+// PARITY-004 quick-win regression: `mcp remove` mirrors the GUI delete button
+// (dialog-select-mcp.tsx → server-sync removeMcpConfig). The server definition
+// lives in a jsonc config file, so removal must preserve comments + siblings.
+describe("deepagentCode mcp remove (non-interactive subprocess)", () => {
+  cliIt.concurrent(
+    "removes a server from the global config while preserving comments and siblings",
+    ({ home, deepagentCode }) =>
+      Effect.gen(function* () {
+        const configPath = path.join(home, ".deepagent", "code", "config.jsonc")
+        const seeded = [
+          "{",
+          "  // user comment must survive the removal",
+          '  "theme": "dark",',
+          '  "mcp": {',
+          '    "github": {',
+          '      "type": "remote",',
+          '      "url": "https://example.com/mcp"',
+          "    },",
+          '    "keeper": {',
+          '      "type": "local",',
+          '      "command": ["echo", "hi"]',
+          "    }",
+          "  }",
+          "}",
+        ].join("\n")
+        yield* Effect.promise(async () => {
+          await mkdir(path.dirname(configPath), { recursive: true })
+          await writeFile(configPath, seeded, "utf8")
+        })
+
+        const result = yield* deepagentCode.spawn(["mcp", "remove", "github"])
+        deepagentCode.expectExit(result, 0)
+
+        const text = yield* Effect.promise(() => readFile(configPath, "utf8"))
+        expect(text).toContain("// user comment must survive the removal")
+        const config = parse(text)
+        expect(config.theme).toBe("dark")
+        expect(config.mcp.github).toBeUndefined()
+        expect(config.mcp.keeper).toEqual({ type: "local", command: ["echo", "hi"] })
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "removes a server defined in the project config",
+    ({ home, deepagentCode }) =>
+      Effect.gen(function* () {
+        // spawn() runs with cwd=home, so the project candidates resolve under home.
+        const configPath = path.join(home, "deepagent-code.json")
+        const seeded = [
+          "{",
+          '  "mcp": {',
+          '    "project-server": {',
+          '      "type": "remote",',
+          '      "url": "https://project.example.com/mcp"',
+          "    }",
+          "  }",
+          "}",
+        ].join("\n")
+        yield* Effect.promise(() => writeFile(configPath, seeded, "utf8"))
+
+        const result = yield* deepagentCode.spawn(["mcp", "remove", "project-server"])
+        deepagentCode.expectExit(result, 0)
+
+        const config = parse(yield* Effect.promise(() => readFile(configPath, "utf8")))
+        expect(config.mcp ?? {}).toEqual({})
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "fails with a clear error when the server is not configured anywhere",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const result = yield* deepagentCode.spawn(["mcp", "remove", "ghost"])
+        expect(result.exitCode).not.toBe(0)
+        expect(result.stderr + result.stdout).toContain("MCP server not found: ghost")
+      }),
+    60_000,
+  )
+})
diff --git a/packages/deepagent-code/test/cli/query-commands.test.ts b/packages/deepagent-code/test/cli/query-commands.test.ts
new file mode 100644
index 00000000..6d50a132
--- /dev/null
+++ b/packages/deepagent-code/test/cli/query-commands.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { cliIt } from "../lib/cli-process"
+
+// PARITY-004 long-tail: the unified "query command" template — instance SDK
+// client + table/json output. Each command gets at least one subprocess test
+// against a fresh isolated home (in-process httpapi, no server needed).
+describe("deepagentCode query commands (non-interactive subprocess)", () => {
+  cliIt.concurrent(
+    "oversight list returns an empty approval queue on a fresh home",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const table = yield* deepagentCode.spawn(["oversight", "list"])
+        deepagentCode.expectExit(table, 0, "oversight list")
+        expect(table.stdout).toContain("(empty)")
+
+        const json = yield* deepagentCode.spawn(["oversight", "list", "--format", "json"])
+        deepagentCode.expectExit(json, 0, "oversight list --format json")
+        expect(JSON.parse(json.stdout)).toEqual([])
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "panel status resolves the global default for any session",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const json = yield* deepagentCode.spawn(["panel", "status", "ses_parity000003", "--format", "json"])
+        deepagentCode.expectExit(json, 0, "panel status --format json")
+        const parsed = JSON.parse(json.stdout) as { sessionID: string; armed: boolean; explicit: boolean; rounds: string }
+        expect(parsed.sessionID).toBe("ses_parity000003")
+        expect(typeof parsed.armed).toBe("boolean")
+        expect(parsed.explicit).toBe(false)
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "review list returns an empty set on a fresh home",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const json = yield* deepagentCode.spawn(["review", "list", "--format", "json"])
+        deepagentCode.expectExit(json, 0, "review list --format json")
+        expect(JSON.parse(json.stdout)).toEqual([])
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "wiki list/search return well-formed results (wiki flag on by default)",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const list = yield* deepagentCode.spawn(["wiki", "list", "--format", "json"])
+        deepagentCode.expectExit(list, 0, "wiki list --format json")
+        const pages = JSON.parse(list.stdout) as Array<{ docId: string; type: string; title: string }>
+        expect(Array.isArray(pages)).toBe(true)
+        // The builtin skill pack projects durable skill pages even on a fresh home.
+        expect(pages.length).toBeGreaterThan(0)
+        expect(pages[0]!.docId).toBeString()
+
+        const search = yield* deepagentCode.spawn(["wiki", "search", "query", "--format", "json"])
+        deepagentCode.expectExit(search, 0, "wiki search --format json")
+        const hits = JSON.parse(search.stdout) as Array<{ docId: string; score: number }>
+        expect(Array.isArray(hits)).toBe(true)
+      }),
+    90_000,
+  )
+
+  cliIt.concurrent(
+    "packs list shows the active set with a snapshot id",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const json = yield* deepagentCode.spawn(["packs", "list", "--format", "json"])
+        deepagentCode.expectExit(json, 0, "packs list --format json")
+        const parsed = JSON.parse(json.stdout) as { packs: Array<{ id: string }>; snapshotId: string }
+        expect(Array.isArray(parsed.packs)).toBe(true)
+        expect(parsed.snapshotId).toBeString()
+
+        const all = yield* deepagentCode.spawn(["packs", "list", "--all", "--format", "json"])
+        deepagentCode.expectExit(all, 0, "packs list --all --format json")
+        const catalog = JSON.parse(all.stdout) as { packs: Array<{ id: string; builtin: boolean }> }
+        expect(catalog.packs.length).toBeGreaterThan(0)
+      }),
+    60_000,
+  )
+})
diff --git a/packages/deepagent-code/test/cli/run/permission-mode.test.ts b/packages/deepagent-code/test/cli/run/permission-mode.test.ts
new file mode 100644
index 00000000..6a025255
--- /dev/null
+++ b/packages/deepagent-code/test/cli/run/permission-mode.test.ts
@@ -0,0 +1,83 @@
+// Unit tests for the CLI permission tri-state auto-responder (PARITY-002).
+// The interactive path keeps the manual prompt UI; these cover the
+// non-interactive `deepagent-code run` auto-reply policy.
+import { describe, expect, test } from "bun:test"
+import { MUTATING_PERMISSIONS } from "@deepagent-code/core/permission/mutating"
+import {
+  PERMISSION_MODES,
+  permissionReplyFor,
+  resolvePermissionMode,
+} from "@/cli/cmd/run/permission-mode"
+
+const READ_PERMISSIONS = ["read", "glob", "grep", "list", "lsp", "webfetch", "websearch", "todowrite"]
+
+describe("run --permission-mode resolution", () => {
+  test("defaults to request mode (legacy reject-everything behavior)", () => {
+    expect(resolvePermissionMode({})).toBe("request")
+    expect(resolvePermissionMode({ "permission-mode": "request" })).toBe("request")
+  })
+
+  test("accepts every documented mode", () => {
+    for (const mode of PERMISSION_MODES) {
+      expect(resolvePermissionMode({ "permission-mode": mode })).toBe(mode)
+    }
+  })
+
+  test("--dangerously-skip-permissions resolves to full-access (alias)", () => {
+    expect(resolvePermissionMode({ "dangerously-skip-permissions": true })).toBe("full-access")
+    expect(
+      resolvePermissionMode({ "dangerously-skip-permissions": true, "permission-mode": "full-access" }),
+    ).toBe("full-access")
+  })
+
+  test("rejects contradictory flag combinations and unknown modes", () => {
+    expect(() =>
+      resolvePermissionMode({ "dangerously-skip-permissions": true, "permission-mode": "request" }),
+    ).toThrow("alias for --permission-mode full-access")
+    expect(() =>
+      resolvePermissionMode({ "dangerously-skip-permissions": true, "permission-mode": "read-only" }),
+    ).toThrow("alias for --permission-mode full-access")
+    expect(() => resolvePermissionMode({ "permission-mode": "yolo" })).toThrow(
+      "--permission-mode must be one of: request, read-only, full-access",
+    )
+  })
+})
+
+describe("run --permission-mode auto-replies", () => {
+  test("request mode rejects every permission (backwards-compatible default)", () => {
+    for (const permission of [...MUTATING_PERMISSIONS, ...READ_PERMISSIONS]) {
+      expect(permissionReplyFor("request", permission)).toBe("reject")
+    }
+  })
+
+  test("read-only mode rejects exactly the mutating set and approves read-style tools", () => {
+    expect([...MUTATING_PERMISSIONS]).toEqual(
+      expect.arrayContaining(["edit", "write", "patch", "bash", "task", "external_directory"]),
+    )
+    for (const permission of MUTATING_PERMISSIONS) {
+      expect(permissionReplyFor("read-only", permission)).toBe("reject")
+    }
+    for (const permission of READ_PERMISSIONS) {
+      expect(permissionReplyFor("read-only", permission)).toBe("once")
+    }
+  })
+
+  test("full-access mode approves every permission once (skip semantics)", () => {
+    for (const permission of [...MUTATING_PERMISSIONS, ...READ_PERMISSIONS]) {
+      expect(permissionReplyFor("full-access", permission)).toBe("once")
+    }
+  })
+})
+
+describe("mutating set consistency across consumers", () => {
+  test("app read-only guard and CLI read-only mode share the same core constant", async () => {
+    // packages/app re-exports the shared constant; a divergence here would
+    // mean the GUI and CLI read-only modes disagree on what is denied.
+    const app = await import("../../../../app/src/context/permission-auto-respond")
+    expect(app.MUTATING_PERMISSIONS).toBe(MUTATING_PERMISSIONS)
+    for (const permission of MUTATING_PERMISSIONS) {
+      expect(app.isMutatingPermission(permission)).toBe(true)
+      expect(permissionReplyFor("read-only", permission)).toBe("reject")
+    }
+  })
+})
diff --git a/packages/deepagent-code/test/cli/run/run-process.test.ts b/packages/deepagent-code/test/cli/run/run-process.test.ts
index 87811b5e..833a39c1 100644
--- a/packages/deepagent-code/test/cli/run/run-process.test.ts
+++ b/packages/deepagent-code/test/cli/run/run-process.test.ts
@@ -84,6 +84,43 @@ describe("deepagentCode run (non-interactive subprocess)", () => {
     60_000,
   )
 
+  // PARITY-002: --permission-mode read-only mirrors the GUI read-only
+  // directory mode — mutating permissions are auto-rejected. In this harness
+  // the session root differs from the tmp home, so file tools surface the
+  // external_directory permission, which is part of the shared mutating set.
+  cliIt.concurrent(
+    "read-only permission mode rejects mutating permissions",
+    ({ llm, home, deepagentCode }) =>
+      Effect.gen(function* () {
+        yield* llm.tool("write", { filePath: path.join(home, "mutated.txt"), content: "nope\n" })
+        yield* llm.text("read-only flow completed")
+
+        const result = yield* deepagentCode.run("try to mutate", {
+          format: "json",
+          extraArgs: ["--permission-mode", "read-only"],
+        })
+        deepagentCode.expectExit(result, 0)
+
+        const events = deepagentCode.parseJsonEvents(result.stdout)
+        const permissions = events.filter((event) => event.type === "permission")
+        expect(permissions.length).toBeGreaterThan(0)
+        for (const event of permissions) {
+          expect(event.reply).toBe("reject")
+        }
+        expect(permissions).toContainEqual(
+          expect.objectContaining({
+            type: "permission",
+            reply: "reject",
+            request: expect.objectContaining({ permission: "external_directory" }),
+          }),
+        )
+        // The rejection must be effective: no mutation reached the disk.
+        const mutated = yield* Effect.promise(() => Bun.file(path.join(home, "mutated.txt")).exists())
+        expect(mutated).toBe(false)
+      }),
+    60_000,
+  )
+
   // Regression for #27371: an unknown model used to hang the process forever
   // waiting on a session.status === idle event that never arrived. The fix
   // makes the SDK call surface an error promptly so the process exits nonzero.
diff --git a/packages/deepagent-code/test/cli/serve/serve-process.test.ts b/packages/deepagent-code/test/cli/serve/serve-process.test.ts
index bdbdf1f8..6d7375e9 100644
--- a/packages/deepagent-code/test/cli/serve/serve-process.test.ts
+++ b/packages/deepagent-code/test/cli/serve/serve-process.test.ts
@@ -8,6 +8,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { HttpClient } from "effect/unstable/http"
+import { access, readFile } from "node:fs/promises"
+import path from "node:path"
 import { cliIt } from "../../lib/cli-process"
 
 describe("deepagentCode serve (subprocess)", () => {
@@ -58,4 +60,64 @@ describe("deepagentCode serve (subprocess)", () => {
       }),
     60_000,
   )
+  // PARITY-003 (Wave 0): `serve --register` writes the daemon registration
+  // protocol (state/server.json + SIGTERM cleanup) so the new CLI daemon can
+  // mount this legacy server. Covers the file contents, the authenticated
+  // health probe, and removal on shutdown.
+  cliIt.live(
+    "--register writes the daemon registration and removes it on SIGTERM",
+    ({ deepagentCode, home }) =>
+      Effect.gen(function* () {
+        const password = "parity-003-test-secret"
+        const file = path.join(home, ".deepagent", "code", "state", "server.json")
+        const server = yield* deepagentCode.serve({
+          extraArgs: ["--register"],
+          env: { DEEPAGENT_CODE_SERVER_PASSWORD: password },
+        })
+
+        // Registration appears shortly after the listening sentinel.
+        const registration = yield* Effect.promise(async () => {
+          for (let i = 0; i < 100; i++) {
+            try {
+              return JSON.parse(await readFile(file, "utf8")) as {
+                id: string
+                version: string
+                url: string
+                pid: number
+              }
+            } catch {
+              await new Promise((resolve) => setTimeout(resolve, 50))
+            }
+          }
+          throw new Error("server.json was not written within 5s of listening")
+        })
+        expect(registration.url).toBe(server.url)
+        expect(registration.pid).toBeGreaterThan(0)
+        expect(registration.id).toBeTruthy()
+        expect(registration.version).toBeTruthy()
+
+        // The daemon's legacy health probe: GET /global/health with Basic auth.
+        const auth = `Basic ${Buffer.from(`deepagent-code:${password}`).toString("base64")}`
+        const healthy = yield* Effect.promise(() =>
+          fetch(`${server.url}/global/health`, { headers: { Authorization: auth } }),
+        )
+        expect(healthy.status).toBe(200)
+        expect(yield* Effect.promise(() => healthy.json())).toMatchObject({ healthy: true })
+        const rejected = yield* Effect.promise(() => fetch(`${server.url}/global/health`))
+        expect(rejected.status).toBe(401)
+
+        // SIGTERM must remove the registration it owns and exit.
+        server.kill()
+        const code = yield* Effect.promise(() => server.exited)
+        expect(typeof code === "number" || code === null).toBe(true)
+        const removed = yield* Effect.promise(() =>
+          access(file).then(
+            () => false,
+            () => true,
+          ),
+        )
+        expect(removed).toBe(true)
+      }),
+    60_000,
+  )
 })
diff --git a/packages/deepagent-code/test/cli/session-rename-archive.test.ts b/packages/deepagent-code/test/cli/session-rename-archive.test.ts
new file mode 100644
index 00000000..ffc948e7
--- /dev/null
+++ b/packages/deepagent-code/test/cli/session-rename-archive.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import path from "path"
+import { cliIt, testModelID } from "../lib/cli-process"
+
+// PARITY-004 long-tail: `session rename` / `session archive` mirror the GUI
+// session context menu (httpapi session update → setTitle / setArchived). The
+// CLI drives the same Session.Service through the local instance.
+describe("deepagentCode session rename/archive (non-interactive subprocess)", () => {
+  cliIt.live(
+    "renames, archives, and restores a session",
+    ({ deepagentCode, home }) =>
+      Effect.gen(function* () {
+        // test/preload.ts pins DEEPAGENT_CODE_DB=:memory:, which gives every
+        // spawned process its own DB. Point the whole flow at a shared file DB
+        // so the session created by `run` is visible to the session commands.
+        const dbEnv = { DEEPAGENT_CODE_DB: path.join(home, "cli.db") }
+
+        // Create one session through the normal run path so the list is non-empty.
+        const run = yield* deepagentCode.run("hello", { model: testModelID, env: dbEnv })
+        deepagentCode.expectExit(run, 0, "run")
+
+        const listOnce = yield* deepagentCode.spawn(["session", "list", "--format", "json"], { env: dbEnv })
+        deepagentCode.expectExit(listOnce, 0, "session list")
+        const sessions = JSON.parse(listOnce.stdout) as Array<{ id: string; title: string; archived: number | null }>
+        expect(sessions.length).toBeGreaterThan(0)
+        const sessionID = sessions[0].id
+
+        // rename (UI.println writes to stderr)
+        const rename = yield* deepagentCode.spawn(["session", "rename", sessionID, "CLI parity title"], { env: dbEnv })
+        deepagentCode.expectExit(rename, 0, "session rename")
+        expect(rename.stderr + rename.stdout).toContain(`Session ${sessionID} renamed to "CLI parity title"`)
+
+        const listAfterRename = yield* deepagentCode.spawn(["session", "list", "--format", "json"], { env: dbEnv })
+        const afterRename = JSON.parse(listAfterRename.stdout) as Array<{ id: string; title: string }>
+        expect(afterRename.find((s) => s.id === sessionID)?.title).toBe("CLI parity title")
+
+        // archive
+        const archive = yield* deepagentCode.spawn(["session", "archive", sessionID], { env: dbEnv })
+        deepagentCode.expectExit(archive, 0, "session archive")
+        expect(archive.stderr + archive.stdout).toContain(`Session ${sessionID} archived`)
+
+        const listAfterArchive = yield* deepagentCode.spawn(["session", "list", "--format", "json"], { env: dbEnv })
+        const afterArchive = JSON.parse(listAfterArchive.stdout) as Array<{ id: string; archived: number | null }>
+        const archivedEntry = afterArchive.find((s) => s.id === sessionID)
+        expect(archivedEntry?.archived).toBeNumber()
+
+        // restore
+        const undo = yield* deepagentCode.spawn(["session", "archive", sessionID, "--undo"], { env: dbEnv })
+        deepagentCode.expectExit(undo, 0, "session archive --undo")
+        expect(undo.stderr + undo.stdout).toContain(`Session ${sessionID} restored`)
+
+        const listAfterUndo = yield* deepagentCode.spawn(["session", "list", "--format", "json"], { env: dbEnv })
+        const afterUndo = JSON.parse(listAfterUndo.stdout) as Array<{ id: string; archived: number | null }>
+        expect(afterUndo.find((s) => s.id === sessionID)?.archived).toBeNull()
+      }),
+    120_000,
+  )
+
+  cliIt.concurrent(
+    "fails with a clear error when the session does not exist",
+    ({ deepagentCode }) =>
+      Effect.gen(function* () {
+        const rename = yield* deepagentCode.spawn(["session", "rename", "ses_missing000000", "nope"])
+        expect(rename.exitCode).not.toBe(0)
+        expect(rename.stderr + rename.stdout).toContain("Session not found: ses_missing000000")
+
+        const archive = yield* deepagentCode.spawn(["session", "archive", "ses_missing000000"])
+        expect(archive.exitCode).not.toBe(0)
+        expect(archive.stderr + archive.stdout).toContain("Session not found: ses_missing000000")
+      }),
+    60_000,
+  )
+})
diff --git a/packages/deepagent-code/test/context-federation/diagnostics.test.ts b/packages/deepagent-code/test/context-federation/diagnostics.test.ts
index 8efabafd..6d7a1a3e 100644
--- a/packages/deepagent-code/test/context-federation/diagnostics.test.ts
+++ b/packages/deepagent-code/test/context-federation/diagnostics.test.ts
@@ -15,6 +15,8 @@ import {
   ProjectScopeIdentityTable,
   SecurityNamespaceTable,
 } from "@deepagent-code/core/context-federation/sql"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { ContextActivationReceipt } from "../../src/context-federation/activation-receipt"
 import { Database } from "@deepagent-code/core/database/database"
 import { DeepAgentReleasedSnapshot } from "@deepagent-code/core/deepagent/released-snapshot"
 import { ProjectV2 } from "@deepagent-code/core/project"
@@ -42,6 +44,44 @@ const attemptId = "attempt_context_diagnostics"
 const securityNamespaceId = SecurityNamespaceID.make("sec_context_diagnostics")
 const projectScopeKey = ProjectScopeKey.make("prjctx_context_diagnostics")
 const releasedKnowledgeBinding = DeepAgentReleasedSnapshot.binding(undefined)
+// Typed federation fixture values the receipt columns demand: a not_requested decision whose
+// requested/enabled/project fields mirror between eligibility and activation (the semantic
+// guard compares them field-by-field as JSON).
+const fixtureRequested: ContextFederationRollout.Requested = {
+  contextFederationShadow: false,
+  locationIndexesV2Shadow: false,
+  contextProjectionV2: false,
+  contextQueryToolsV2: false,
+  coreV2ExecutionOwner: false,
+}
+const fixtureEligibility: ContextFederationRollout.ProjectDecision = {
+  requested: fixtureRequested,
+  enabled: fixtureRequested,
+  blocked: {},
+  project: { projectScopeKey, stage: "all", bucket: 0, selected: false, killSwitch: false },
+}
+const fixtureReadiness: ContextFederationRollout.DerivedContextDataReadiness = {
+  revision: "diagnostics-readiness",
+  state: "ready",
+  identityBound: true,
+  indexAvailable: true,
+  storageHealthy: true,
+  projectScopeKey,
+  reasons: [],
+  observedAt: 35,
+  expiresAt: 600_035,
+}
+const fixtureActivation: ContextActivationReceipt.Receipt = {
+  schemaVersion: 1,
+  recordedAt: 35,
+  readinessAgeMs: 0,
+  readinessExpiresInMs: 600_000,
+  outcome: "not_requested",
+  enabledCapabilities: [],
+  fallbackReasons: [],
+  decision: fixtureEligibility,
+  selection: { selectionId, projectionHash: "projection" },
+}
 
 describe("ContextFederationDiagnostics", () => {
   test("returns opaque evidence and requires durable terminal evidence before settle", async () => {
@@ -58,6 +98,7 @@ describe("ContextFederationDiagnostics", () => {
       resolve: () => Effect.die("not used"),
       prepareProviderTurn: () => Effect.die("not used"),
       settleActivity: () => Effect.void,
+      settleOrphanedActivities: () => Effect.succeed(0),
       replayIndeterminate: () => Effect.die("not used"),
       releasedKnowledgeForActiveSession: () => Effect.succeed(undefined),
     } satisfies SessionFederatedContext.Interface)
@@ -75,7 +116,7 @@ describe("ContextFederationDiagnostics", () => {
         yield* seed(db)
         const service = yield* ContextFederationDiagnostics.Service
         yield* db
-          .insert(SessionToolRequestReceiptTable)
+          .insert(SessionToolRequestReceiptTable) // fixture-exempt: bare preparing receipt; walked to the crashed state below
           .values({
             receipt_id: "receipt_context_legacy",
             request_ordinal: 1,
@@ -83,6 +124,12 @@ describe("ContextFederationDiagnostics", () => {
             user_message_id: inputId,
             assistant_message_id: null,
             provider_attempt_id: attemptId,
+            context_selection_id: selectionId,
+            released_knowledge_security_namespace_id: securityNamespaceId,
+            released_knowledge_project_scope_key: projectScopeKey,
+            released_knowledge_binding_state: releasedKnowledgeBinding.state,
+            released_knowledge_exact_refs: releasedKnowledgeBinding.exactRefs,
+            released_knowledge_exact_refs_fingerprint: releasedKnowledgeBinding.exactRefsFingerprint,
             provider_id: "provider-test",
             model_id: "model-test",
             protocol: "chat",
@@ -90,12 +137,88 @@ describe("ContextFederationDiagnostics", () => {
             permission_filtered_tool_ids: [],
             final_offered_tool_ids: [],
             call_ids: [],
+            prompt_epoch: 0,
+            prompt_window_id: "window-receipt-context-legacy",
+            effective_history_hash: "history-receipt-context-legacy",
+            request_input_hash: "request",
+            context_eligibility: fixtureEligibility,
+            context_readiness: fixtureReadiness,
+            context_activation: fixtureActivation,
+            context_activation_fingerprint: "ab".repeat(32),
+            provider_state: "preparing",
+            owner_token: "diagnostics-stale-owner",
+            request_state: "prepared",
+            created_at: 35,
+          })
+          .run()
+        // seal selected refs once while still preparing.
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({
+            released_knowledge_selected_refs: releasedKnowledgeBinding.exactRefs,
+            released_knowledge_selected_refs_fingerprint: releasedKnowledgeBinding.exactRefsFingerprint,
+          })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt_context_legacy"))
+          .run()
+        // seal the prepared turn (wire hashes must equal the attempt's sealed identity).
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({
+            provider_state: "prepared",
+            final_request_hash: "ef".repeat(32),
+            provider_request_hash: "ef".repeat(32),
+            wire_request_hash: "ef".repeat(32),
+            prepared_turn_hash: "cd".repeat(32),
+            system_stable_hash: "aa".repeat(32),
+            system_volatile_hash: "bb".repeat(32),
+            tool_definition_hash: "cc".repeat(32),
+            adapter_prepared_at: 36,
+            final_offered_tool_ids: ["fixture_tool"],
+          })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt_context_legacy"))
+          .run()
+        // dispatch attempt then receipt (the wire guard matches them pairwise).
+        yield* db
+          .update(SessionProviderAttemptTable)
+          .set({ state: "dispatching" })
+          .where(eq(SessionProviderAttemptTable.attempt_id, attemptId))
+          .run()
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({ provider_state: "dispatching", dispatching_at: 37 })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt_context_legacy"))
+          .run()
+        // simulate the crash: release the stale owner's lease, admit a recovery owner, then mark
+        // both rows indeterminate (the recovery guard demands exactly this lease pair).
+        yield* db.run(sql`
+          UPDATE session_provider_owner_lease
+          SET released_at = CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)
+          WHERE owner_token = 'diagnostics-stale-owner'
+        `)
+        yield* db.run(sql`
+          INSERT INTO session_provider_owner_lease (
+            owner_token, registered_at, heartbeat_at, lease_expires_at
+          ) VALUES (
+            'diagnostics-recovery-owner',
+            CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+            CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+            CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER) + 60000
+          )
+        `)
+        yield* db
+          .update(SessionProviderAttemptTable)
+          .set({ state: "indeterminate_after_crash", error_code: "process_recovery" })
+          .where(eq(SessionProviderAttemptTable.attempt_id, attemptId))
+          .run()
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({
             provider_state: "indeterminate_after_crash",
+            terminal_at: 38,
             request_state: "dispatched",
             request_error_code: "provider_started_outcome_unknown_after_process_restart",
-            owner_token: "dead-process",
-            created_at: 35,
           })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt_context_legacy"))
           .run()
         const bypass = yield* db
           .insert(SessionProviderAttemptResolutionTable)
@@ -190,6 +313,53 @@ describe("ContextFederationDiagnostics", () => {
       }).pipe(Effect.provide(diagnostics), Effect.provide(database), Effect.scoped),
     )
   })
+
+  test("cohort aggregates durable selections by readiness bucket over a window (FEAT-005)", async () => {
+    ContextFederationObservability.reset()
+    const database = Database.layerFromPath(":memory:")
+    const attemptLayer = SessionProviderAttempt.layer.pipe(Layer.provide(database))
+    const ownerLayer = SessionProviderOwner.layer.pipe(Layer.provide(database))
+    const sessionLayer = Layer.succeed(Session.Service, {
+      messages: () => Effect.sync(() => []),
+    } as unknown as Session.Interface)
+    const federationLayer = Layer.succeed(SessionFederatedContext.Service, {
+      recover: () => Effect.succeed(0),
+      resolve: () => Effect.die("not used"),
+      prepareProviderTurn: () => Effect.die("not used"),
+      settleActivity: () => Effect.void,
+      settleOrphanedActivities: () => Effect.succeed(0),
+      replayIndeterminate: () => Effect.die("not used"),
+      releasedKnowledgeForActiveSession: () => Effect.succeed(undefined),
+    } satisfies SessionFederatedContext.Interface)
+    const diagnostics = ContextFederationDiagnostics.layer.pipe(
+      Layer.provide(database),
+      Layer.provide(attemptLayer),
+      Layer.provide(ownerLayer),
+      Layer.provide(sessionLayer),
+      Layer.provide(federationLayer),
+    )
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        yield* seed(db)
+        const service = yield* ContextFederationDiagnostics.Service
+        // Window covering the seeded selection (created_at = 20). code/knowledge/memory are ready;
+        // documents is degraded → the selection folds to the WORST bucket (degraded), so cold-start
+        // noise is kept out of the "ready" cohort.
+        const cohort = yield* service.cohort({ sinceMs: 0, untilMs: 100 })
+        expect(cohort.selections).toBe(1)
+        expect(cohort.sessions).toBe(1)
+        expect(cohort.tokens).toBe(8)
+        expect(cohort.readiness).toEqual({ ready: 0, building: 0, degraded: 1, blocked: 0 })
+        expect(cohort.graphs.code).toMatchObject({ statuses: 1, ready: 1, notReady: 0 })
+        expect(cohort.graphs.documents).toMatchObject({ statuses: 1, ready: 0, notReady: 1 })
+        // A window that excludes the selection yields an empty cohort.
+        const empty = yield* service.cohort({ sinceMs: 1000, untilMs: 2000 })
+        expect(empty.selections).toBe(0)
+        expect(empty.readiness).toEqual({ ready: 0, building: 0, degraded: 0, blocked: 0 })
+      }).pipe(Effect.provide(diagnostics), Effect.provide(database), Effect.scoped),
+    )
+  })
 })
 
 function seed(db: Database.Interface["db"]) {
@@ -280,7 +450,7 @@ function seed(db: Database.Interface["db"]) {
       })
       .run()
     yield* db
-      .insert(SessionActivityTable)
+      .insert(SessionActivityTable) // fixture-exempt: seeds crash-recovery activity for diagnostics fixture
       .values({
         activity_id: activityId,
         session_id: sessionId,
@@ -354,7 +524,7 @@ function seed(db: Database.Interface["db"]) {
       )
     `)
     yield* db
-      .insert(SessionProviderAttemptTable)
+      .insert(SessionProviderAttemptTable) // fixture-exempt: admitted prepared attempt; the test body walks it to the crashed state
       .values({
         attempt_id: attemptId,
         session_id: sessionId,
@@ -365,16 +535,20 @@ function seed(db: Database.Interface["db"]) {
         request_hash: "request",
         provider_id: "provider-test",
         owner_token: "diagnostics-stale-owner",
-        state: "indeterminate_after_crash",
+        state: "prepared",
         created_at: 30,
-        error_code: "process_recovery",
       })
       .run()
-    yield* db.run(sql`
-      UPDATE session_provider_owner_lease
-      SET released_at = CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)
-      WHERE owner_token = 'diagnostics-stale-owner'
-    `)
+    // Seal the attempt's wire identity once (prepared→prepared), the sole admission path; the
+    // receipt sealed later must carry these exact hashes.
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({
+        prepared_turn_hash: "cd".repeat(32),
+        wire_request_hash: "ef".repeat(32),
+      })
+      .where(eq(SessionProviderAttemptTable.attempt_id, attemptId))
+      .run()
   })
 }
 
diff --git a/packages/deepagent-code/test/context-federation/provider-owner-runtime.test.ts b/packages/deepagent-code/test/context-federation/provider-owner-runtime.test.ts
index 936a0da2..f6475a0a 100644
--- a/packages/deepagent-code/test/context-federation/provider-owner-runtime.test.ts
+++ b/packages/deepagent-code/test/context-federation/provider-owner-runtime.test.ts
@@ -1,20 +1,38 @@
 import { describe, expect, test } from "bun:test"
 import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
-import { Effect, Ref } from "effect"
+import { Database } from "@deepagent-code/core/database/database"
+import { sql } from "drizzle-orm"
+import { Cause, Effect, Exit, Layer, Option, Ref } from "effect"
 import { ContextFederationProviderOwnerRuntime } from "../../src/context-federation/provider-owner-runtime"
 
+const makeLease = (ownerToken: string, leaseMs: number): SessionProviderOwner.Lease => ({
+  ownerToken,
+  registeredAt: 1,
+  heartbeatAt: 2,
+  leaseExpiresAt: 2 + leaseMs,
+})
+
 describe("ContextFederationProviderOwnerRuntime", () => {
-  test("permanently fences mutations after the durable owner lease expires", async () => {
+  test("rotates to a successor owner generation when the durable lease fences the old token", async () => {
     let recovered = 0
+    const registered: string[] = []
     const healthy = await Effect.runPromise(Ref.make(true))
+    const owner = await Effect.runPromise(
+      Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({ ownerToken: "base:gen-0:old", generation: 0 }),
+    )
 
     const continued = await Effect.runPromise(
       ContextFederationProviderOwnerRuntime.tick({
         owners: {
           heartbeat: () =>
             Effect.fail(new SessionProviderOwner.ConflictError({ reason: "provider_owner_lease_not_live" })),
+          register: ({ ownerToken, leaseMs }) => {
+            registered.push(ownerToken)
+            return Effect.succeed(makeLease(ownerToken, leaseMs))
+          },
         },
-        ownerToken: "expired-owner",
+        owner,
+        ownerBase: "base",
         leaseMs: 30_000,
         healthy,
         label: "test provider",
@@ -22,19 +40,58 @@ describe("ContextFederationProviderOwnerRuntime", () => {
       }),
     )
 
-    expect(continued).toBe(false)
-    expect(await Effect.runPromise(Ref.get(healthy))).toBe(false)
+    const rotated = await Effect.runPromise(Ref.get(owner))
+    expect(continued).toBe(true)
+    expect(await Effect.runPromise(Ref.get(healthy))).toBe(true)
     expect(recovered).toBe(0)
+    expect(rotated.generation).toBe(1)
+    expect(rotated.ownerToken.startsWith("base:gen-1:")).toBe(true)
+    expect(rotated.ownerToken).not.toBe("base:gen-0:old")
+    expect(registered).toEqual([rotated.ownerToken])
+  })
+
+  test("keeps the fenced generation and retries next tick when successor registration fails", async () => {
+    const healthy = await Effect.runPromise(Ref.make(true))
+    const owner = await Effect.runPromise(
+      Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({ ownerToken: "base:gen-0:old", generation: 0 }),
+    )
+
+    const continued = await Effect.runPromise(
+      ContextFederationProviderOwnerRuntime.tick({
+        owners: {
+          heartbeat: () =>
+            Effect.fail(new SessionProviderOwner.ConflictError({ reason: "provider_owner_lease_not_live" })),
+          register: () =>
+            Effect.fail(new SessionProviderOwner.ConflictError({ reason: "owner_token_already_registered" })),
+        },
+        owner,
+        ownerBase: "base",
+        leaseMs: 30_000,
+        healthy,
+        label: "test provider",
+      }),
+    )
+
+    expect(continued).toBe(true)
+    expect(await Effect.runPromise(Ref.get(healthy))).toBe(true)
+    expect(await Effect.runPromise(Ref.get(owner))).toEqual({ ownerToken: "base:gen-0:old", generation: 0 })
   })
 
   test("keeps the runtime healthy so a transient heartbeat failure can retry", async () => {
     let recovered = 0
     const healthy = await Effect.runPromise(Ref.make(true))
+    const owner = await Effect.runPromise(
+      Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({ ownerToken: "retry-owner", generation: 0 }),
+    )
 
     const continued = await Effect.runPromise(
       ContextFederationProviderOwnerRuntime.tick({
-        owners: { heartbeat: () => Effect.die(new Error("database temporarily unavailable")) },
-        ownerToken: "retry-owner",
+        owners: {
+          heartbeat: () => Effect.die(new Error("database temporarily unavailable")),
+          register: () => Effect.die(new Error("register must not run on a transient heartbeat failure")),
+        },
+        owner,
+        ownerBase: "retry-owner",
         leaseMs: 30_000,
         healthy,
         label: "test provider",
@@ -50,19 +107,18 @@ describe("ContextFederationProviderOwnerRuntime", () => {
   test("runs recovery only after a successful heartbeat", async () => {
     let recovered = 0
     const healthy = await Effect.runPromise(Ref.make(true))
+    const owner = await Effect.runPromise(
+      Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({ ownerToken: "healthy-owner", generation: 0 }),
+    )
 
     const continued = await Effect.runPromise(
       ContextFederationProviderOwnerRuntime.tick({
         owners: {
-          heartbeat: ({ ownerToken, leaseMs }) =>
-            Effect.succeed({
-              ownerToken,
-              registeredAt: 1,
-              heartbeatAt: 2,
-              leaseExpiresAt: 2 + leaseMs,
-            }),
+          heartbeat: ({ ownerToken, leaseMs }) => Effect.succeed(makeLease(ownerToken, leaseMs)),
+          register: () => Effect.die(new Error("register must not run on a live heartbeat")),
         },
-        ownerToken: "healthy-owner",
+        owner,
+        ownerBase: "healthy-owner",
         leaseMs: 30_000,
         healthy,
         label: "test provider",
@@ -73,5 +129,128 @@ describe("ContextFederationProviderOwnerRuntime", () => {
     expect(continued).toBe(true)
     expect(await Effect.runPromise(Ref.get(healthy))).toBe(true)
     expect(recovered).toBe(1)
+    expect(await Effect.runPromise(Ref.get(owner))).toEqual({ ownerToken: "healthy-owner", generation: 0 })
+  })
+})
+
+describe("RISK-004 drill: provider owner lease drift against the real store", () => {
+  // The lease table's authority triggers forbid backdating lease_expires_at from outside the
+  // heartbeat path, so drift is simulated with a minimal lease and a bounded poll — no fixed sleep.
+  const driftLeaseMs = 10
+  const waitUntilDrifted = (heartbeat: () => Effect.Effect<unknown, SessionProviderOwner.ConflictError>) =>
+    Effect.gen(function* () {
+      for (let attempt = 0; attempt < 500; attempt++) {
+        const exit = yield* heartbeat().pipe(Effect.exit)
+        if (Exit.isFailure(exit)) return
+        yield* Effect.sleep("10 millis")
+      }
+      return yield* Effect.die(new Error("owner lease never drifted past expiry"))
+    })
+
+  test("d: a heartbeat gap beyond LeaseMs fences the owner and a successor registers", async () => {
+    const database = Database.layerFromPath(":memory:")
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const owners = yield* SessionProviderOwner.Service
+        yield* owners.register({ ownerToken: "owner-a", leaseMs: driftLeaseMs })
+        // Stop heartbeating: the lease drifts past expiry on the database clock.
+        yield* waitUntilDrifted(() => owners.heartbeat({ ownerToken: "owner-a", leaseMs: driftLeaseMs }))
+
+        const missed = yield* owners.heartbeat({ ownerToken: "owner-a", leaseMs: driftLeaseMs }).pipe(Effect.exit)
+        expect(Exit.isFailure(missed)).toBe(true)
+        if (!Exit.isFailure(missed)) return
+        const missedError = Option.getOrUndefined(Cause.findErrorOption(missed.cause))
+        expect(missedError).toBeInstanceOf(SessionProviderOwner.ConflictError)
+        if (missedError instanceof SessionProviderOwner.ConflictError) {
+          expect(missedError.reason).toBe("provider_owner_lease_not_live")
+        }
+
+        const successor = yield* owners.register({ ownerToken: "owner-b", leaseMs: SessionProviderOwner.LeaseMs })
+        expect(successor.ownerToken).toBe("owner-b")
+        const beat = yield* owners.heartbeat({ ownerToken: "owner-b", leaseMs: SessionProviderOwner.LeaseMs })
+        expect(beat.leaseExpiresAt).toBeGreaterThanOrEqual(successor.leaseExpiresAt)
+
+        const stillFenced = yield* owners
+          .heartbeat({ ownerToken: "owner-a", leaseMs: SessionProviderOwner.LeaseMs })
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(stillFenced)).toBe(true)
+      }).pipe(
+        Effect.provide(SessionProviderOwner.layer.pipe(Layer.provide(database))),
+        Effect.provide(database),
+      ),
+    )
+  })
+
+  test("d: runtime tick rotates to a live successor generation once the real store fences the lease", async () => {
+    const database = Database.layerFromPath(":memory:")
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const owners = yield* SessionProviderOwner.Service
+        const startupToken = "drift-base:gen-0:seed"
+        yield* owners.register({ ownerToken: startupToken, leaseMs: driftLeaseMs })
+        yield* waitUntilDrifted(() => owners.heartbeat({ ownerToken: startupToken, leaseMs: driftLeaseMs }))
+
+        const healthy = yield* Ref.make(true)
+        const owner = yield* Ref.make<ContextFederationProviderOwnerRuntime.OwnerGeneration>({
+          ownerToken: startupToken,
+          generation: 0,
+        })
+        const continued = yield* ContextFederationProviderOwnerRuntime.tick({
+          owners,
+          owner,
+          ownerBase: "drift-base",
+          leaseMs: SessionProviderOwner.LeaseMs,
+          healthy,
+          label: "drill provider",
+        })
+        expect(continued).toBe(true)
+        expect(yield* Ref.get(healthy)).toBe(true)
+        const rotated = yield* Ref.get(owner)
+        expect(rotated.generation).toBe(1)
+        expect(rotated.ownerToken.startsWith("drift-base:gen-1:")).toBe(true)
+
+        // The successor token passes the durable lease guards (register + heartbeat clock checks),
+        // so attempt/receipt writers holding the current generation pass the lease fence.
+        const beat = yield* owners.heartbeat({ ownerToken: rotated.ownerToken, leaseMs: SessionProviderOwner.LeaseMs })
+        expect(beat.leaseExpiresAt).toBeGreaterThan(beat.heartbeatAt)
+
+        // The fenced startup token stays dead — rotation never revives or extends it.
+        const stillFenced = yield* owners
+          .heartbeat({ ownerToken: startupToken, leaseMs: SessionProviderOwner.LeaseMs })
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(stillFenced)).toBe(true)
+
+        // The following tick heartbeats the successor token and runs recovery without rotating again.
+        let recovered = 0
+        const nextContinued = yield* ContextFederationProviderOwnerRuntime.tick({
+          owners,
+          owner,
+          ownerBase: "drift-base",
+          leaseMs: SessionProviderOwner.LeaseMs,
+          healthy,
+          label: "drill provider",
+          recover: Effect.sync(() => recovered++),
+        })
+        expect(nextContinued).toBe(true)
+        expect(recovered).toBe(1)
+        expect(yield* Ref.get(owner)).toEqual(rotated)
+        expect(yield* Ref.get(healthy)).toBe(true)
+
+        // BUG-407-009 fence: successor registration atomically installs the protocol-3 capability
+        // row, so a pre-successor binary refuses to open this database (its startup recovery would
+        // re-quarantine the successor chain) instead of failing closed on the next open.
+        const fence = yield* (yield* Database.Service).db.get<{
+          minimum_reader_protocol: number
+          minimum_writer_protocol: number
+        }>(sql`
+          SELECT minimum_reader_protocol, minimum_writer_protocol FROM database_capability
+          WHERE capability = 'provider_owner_successor_v1'
+        `)
+        expect(fence).toEqual({ minimum_reader_protocol: 3, minimum_writer_protocol: 3 })
+      }).pipe(
+        Effect.provide(SessionProviderOwner.layer.pipe(Layer.provide(database))),
+        Effect.provide(database),
+      ),
+    )
   })
 })
diff --git a/packages/deepagent-code/test/control-plane/workspace.test.ts b/packages/deepagent-code/test/control-plane/workspace.test.ts
index 2509d1b7..a7758a4e 100644
--- a/packages/deepagent-code/test/control-plane/workspace.test.ts
+++ b/packages/deepagent-code/test/control-plane/workspace.test.ts
@@ -19,6 +19,11 @@ import { SessionID } from "@/session/schema"
 import { SessionTable } from "@deepagent-code/core/session/sql"
 import { EventSequenceTable, EventSyncSequenceTable, EventTable, WorkspaceSyncCursorTable } from "@deepagent-code/core/event/sql"
 import { SessionToolRequestReceiptTable } from "@/session/tool-request-receipt.sql"
+import { SessionProviderOwnerLeaseTable } from "@deepagent-code/core/context-federation/session-sql"
+import { ProjectScopeIdentityTable, SecurityNamespaceTable } from "@deepagent-code/core/context-federation/sql"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { ProjectScopeKey, SecurityNamespaceID } from "@deepagent-code/core/context-federation/reference"
+import { ContextActivationReceipt } from "@/context-federation/activation-receipt"
 import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, provideTmpdirInstance, requireInstance, TestInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
@@ -160,7 +165,7 @@ function expectExitContains(exit: Exit.Exit<unknown, unknown>, ...messages: stri
   for (const message of messages) expect(String(exit.cause)).toContain(message)
 }
 
-function eventuallyEffect(effect: Effect.Effect<void>, timeout = 1500) {
+function eventuallyEffect<R>(effect: Effect.Effect<void, unknown, R>, timeout = 10_000) {
   return Effect.gen(function* () {
     const started = Date.now()
     let last: unknown
@@ -947,26 +952,158 @@ describe("workspace CRUD", () => {
         const session = yield* sessionSvc.create({})
         yield* attachSessionToWorkspace(session.id, previous.id)
         const { db } = yield* Database.Service
+        // Fixture-exempt: seed an indeterminate_after_crash receipt for the warp-recovery fixture.
+        // The durable turn guards admit receipts only through the preparing→prepared→dispatching
+        // lifecycle with live owner lease + released-knowledge scope authority, so the fixture
+        // synthesizes that minimal chain and walks it to the crashed state.
+        const warpReceiptID = "receipt-warp-recovery-required"
+        const warpOwner = "dead-process-warp-recovery"
+        const warpNamespace = "sec-warp-recovery"
+        const warpScope = "prjctx-warp-recovery"
+        const warpHash = "ab".repeat(32)
+        const warpNow = Date.now()
+        const dbNowMs = sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`
+        const warpRequested: ContextFederationRollout.Requested = {
+          contextFederationShadow: false,
+          locationIndexesV2Shadow: false,
+          contextProjectionV2: false,
+          contextQueryToolsV2: false,
+          coreV2ExecutionOwner: false,
+        }
+        const warpEligibility: ContextFederationRollout.ProjectDecision = {
+          requested: warpRequested,
+          enabled: warpRequested,
+          blocked: {},
+          project: { projectScopeKey: warpScope, stage: "all", bucket: 0, selected: false, killSwitch: false },
+        }
+        const warpReadiness: ContextFederationRollout.DerivedContextDataReadiness = {
+          revision: "warp-recovery-readiness",
+          state: "ready",
+          identityBound: true,
+          indexAvailable: true,
+          storageHealthy: true,
+          projectScopeKey: warpScope,
+          reasons: [],
+          observedAt: warpNow,
+          expiresAt: warpNow + 600_000,
+        }
+        const warpActivation: ContextActivationReceipt.Receipt = {
+          schemaVersion: 1,
+          recordedAt: warpNow,
+          readinessAgeMs: 0,
+          readinessExpiresInMs: 600_000,
+          outcome: "not_requested",
+          enabledCapabilities: [],
+          fallbackReasons: [],
+          decision: warpEligibility,
+        }
+        yield* db
+          .insert(SecurityNamespaceTable)
+          .values({ id: warpNamespace, kind: "implicit_local", binding_hash: "warp-recovery-binding", created_at: warpNow, retired_at: null })
+          .run()
+          .pipe(Effect.orDie)
         yield* db
-          .insert(SessionToolRequestReceiptTable)
+          .insert(ProjectScopeIdentityTable)
           .values({
-            receipt_id: "receipt-warp-recovery-required",
+            security_namespace_id: warpNamespace,
+            project_scope_key: warpScope,
+            project_kind: "registered_root",
+            project_identity_hash: "warp-recovery-project",
+            observed_project_id: "project-warp-recovery",
+            created_at: warpNow,
+            retired_at: null,
+          })
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .insert(SessionProviderOwnerLeaseTable)
+          .values({
+            owner_token: warpOwner,
+            registered_at: dbNowMs,
+            heartbeat_at: dbNowMs,
+            lease_expires_at: sql`${dbNowMs} + 3600000`,
+            released_at: null,
+          } as never)
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds an indeterminate receipt so warp must fail closed on unresolved provider recovery
+          .values({
+            receipt_id: warpReceiptID,
             request_ordinal: 1,
             session_id: session.id,
             user_message_id: "message-user",
             assistant_message_id: "message-assistant",
             provider_attempt_id: null,
+            context_selection_id: null,
+            released_knowledge_security_namespace_id: SecurityNamespaceID.make(warpNamespace),
+            released_knowledge_project_scope_key: ProjectScopeKey.make(warpScope),
+            released_knowledge_binding_state: "unavailable",
+            released_knowledge_exact_refs: [],
+            released_knowledge_exact_refs_fingerprint: "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
             provider_id: "test",
             model_id: "test",
+            protocol: "chat",
             registry_tool_ids: [],
             permission_filtered_tool_ids: [],
             final_offered_tool_ids: [],
             call_ids: [],
+            prompt_epoch: 1,
+            prompt_window_id: "window-warp-recovery",
+            effective_history_hash: warpHash,
+            request_input_hash: "input-warp-recovery",
+            context_eligibility: warpEligibility,
+            context_readiness: warpReadiness,
+            context_activation: warpActivation,
+            context_activation_fingerprint: "f".repeat(64),
+            provider_state: "preparing",
+            owner_token: warpOwner,
+            request_state: "prepared",
+            created_at: warpNow,
+          })
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({
+            released_knowledge_selected_refs: [],
+            released_knowledge_selected_refs_fingerprint: "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, warpReceiptID))
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({
+            provider_state: "prepared",
+            final_request_hash: warpHash,
+            provider_request_hash: warpHash,
+            wire_request_hash: warpHash,
+            prepared_turn_hash: warpHash,
+            system_stable_hash: warpHash,
+            system_volatile_hash: warpHash,
+            tool_definition_hash: warpHash,
+            adapter_prepared_at: warpNow,
+            final_offered_tool_ids: ["fixture_tool"],
+          })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, warpReceiptID))
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({ provider_state: "dispatching", dispatching_at: warpNow })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, warpReceiptID))
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .update(SessionToolRequestReceiptTable)
+          .set({
             provider_state: "indeterminate_after_crash",
-            terminal_at: Date.now(),
+            terminal_at: warpNow,
             request_state: "dispatched",
-            created_at: Date.now(),
+            request_error_code: "provider_started_outcome_unknown_after_process_restart",
           })
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, warpReceiptID))
           .run()
           .pipe(Effect.orDie)
         const owner = yield* sessionSequenceOwner(session.id)
@@ -1738,10 +1875,18 @@ describe("workspace sync state", () => {
                   expect((yield* sessionSvc.get(session.id).pipe(Effect.orDie)).title).toBe("from history")
                 }),
               )
-              expect(historyBodies).toEqual([
-                { version: 1 },
-                { version: 1, cursor: "cursor-history-1" },
-              ])
+              // Under load the initial sync can be issued more than once before the first cursor is
+              // durably stored; assert the advance contract semantically (a cursorless request
+              // followed by one resuming cursor-history-1) instead of an exact two-request sequence.
+              yield* eventuallyEffect(
+                Effect.sync(() => {
+                  const bodies = historyBodies as Array<{ version: 1; cursor?: string }>
+                  const initial = bodies.findIndex((body) => body.cursor === undefined)
+                  const resumed = bodies.findIndex((body) => body.cursor === "cursor-history-1")
+                  expect(initial).toBeGreaterThanOrEqual(0)
+                  expect(resumed).toBeGreaterThan(initial)
+                }),
+              )
               expect(
                 yield* Database.Service.use(({ db }) =>
                   db
@@ -1932,9 +2077,13 @@ describe("workspace sync state", () => {
             }
 
             yield* workspace.startWorkspaceSyncing(instance.project.id)
-            yield* eventuallyEffect(Effect.sync(() => expect(chunkRequests).toBeGreaterThanOrEqual(1)), 5_000)
+            // Under load the chunk download retry backoff stretches; give the failed import a wide
+            // window, then let any in-flight retry wave settle before asserting the negative
+            // guarantees (no cursor advance, no event applied).
+            yield* eventuallyEffect(Effect.sync(() => expect(chunkRequests).toBeGreaterThanOrEqual(1)), 15_000)
             expect(historyRequests).toBeGreaterThanOrEqual(1)
             expect(metadataRequests).toBeGreaterThanOrEqual(1)
+            yield* Effect.sleep("500 millis")
             expect(
               yield* db.select().from(WorkspaceSyncCursorTable).where(eq(WorkspaceSyncCursorTable.workspace_id, info.id)).get(),
             ).toBeUndefined()
@@ -1982,21 +2131,29 @@ describe("workspace sync state", () => {
             registerAdapter(instance.project.id, type, remoteAdapter(`${url}/history-reconnect`).adapter)
 
             yield* workspace.startWorkspaceSyncing(instance.project.id)
-            yield* eventuallyEffect(Effect.sync(() => expect(historyBodies.length).toBeGreaterThanOrEqual(2)), 3_000)
-
-            expect(historyBodies.slice(0, 2)).toEqual([
-              { version: 1 },
-              { version: 1, cursor: "cursor-reconnect-1" },
-            ])
-            expect(
-              yield* Database.Service.use(({ db }) =>
+            // Under load the initial sync can be issued more than once before the first cursor is
+            // durably stored; assert the reconnect contract semantically (a cursorless request
+            // followed by one resuming cursor-reconnect-1) instead of an exact two-request prefix.
+            yield* eventuallyEffect(
+              Effect.sync(() => {
+                const initial = historyBodies.findIndex((body) => body.cursor === undefined)
+                const resumed = historyBodies.findIndex((body) => body.cursor === "cursor-reconnect-1")
+                expect(initial).toBeGreaterThanOrEqual(0)
+                expect(resumed).toBeGreaterThan(initial)
+              }),
+              10_000,
+            )
+            yield* eventuallyEffect(
+              Database.Service.use(({ db }) =>
                 db
                   .select({ cursor: WorkspaceSyncCursorTable.cursor })
                   .from(WorkspaceSyncCursorTable)
                   .where(eq(WorkspaceSyncCursorTable.workspace_id, info.id))
-                  .get(),
+                  .get()
+                  .pipe(Effect.map((row) => expect(row).toEqual({ cursor: "cursor-reconnect-2" }))),
               ),
-            ).toEqual({ cursor: "cursor-reconnect-2" })
+              10_000,
+            )
             yield* workspace.remove(info.id)
           }),
         { git: true },
@@ -2065,20 +2222,29 @@ describe("workspace sync state", () => {
             )
 
             yield* workspace.startWorkspaceSyncing(instance.project.id)
-            yield* eventuallyEffect(Effect.sync(() => expect(historyBodies.length).toBe(2)) )
-            expect(historyBodies).toEqual([
-              { version: 1, cursor: "cursor-stale-old-generation" },
-              { version: 1 },
-            ])
-            expect(
-              yield* Database.Service.use(({ db }) =>
+            // The stale cursor must be reset after the remote rejects it: a cursorless retry
+            // follows the rejected old-cursor attempt. Under load extra initial retries can
+            // interleave, so assert the reset contract semantically rather than an exact sequence.
+            yield* eventuallyEffect(
+              Effect.sync(() => {
+                const staleIdx = historyBodies.findIndex((body) => body.cursor === "cursor-stale-old-generation")
+                const resetIdx = historyBodies.findIndex((body) => body.cursor === undefined)
+                expect(staleIdx).toBeGreaterThanOrEqual(0)
+                expect(resetIdx).toBeGreaterThan(staleIdx)
+              }),
+              10_000,
+            )
+            yield* eventuallyEffect(
+              Database.Service.use(({ db }) =>
                 db
                   .select({ cursor: WorkspaceSyncCursorTable.cursor })
                   .from(WorkspaceSyncCursorTable)
                   .where(eq(WorkspaceSyncCursorTable.workspace_id, stale.id))
-                  .get(),
+                  .get()
+                  .pipe(Effect.map((row) => expect(row).toEqual({ cursor: "cursor-stale-reset" }))),
               ),
-            ).toEqual({ cursor: "cursor-stale-reset" })
+              10_000,
+            )
             yield* workspace.remove(stale.id)
 
             historyBodies.length = 0
@@ -2101,8 +2267,12 @@ describe("workspace sync state", () => {
               Effect.gen(function* () {
                 expect((yield* workspace.status()).find((item) => item.workspaceID === bad.id)?.status).toBe("error")
               }),
+              10_000,
             )
-            expect(historyBodies[0]).toEqual({ version: 1, cursor: "cursor-preserved-on-400" })
+            // An unrelated conflict must NOT trigger a cursor reset: the attempt carries the
+            // preserved cursor and no cursorless retry ever fires.
+            expect(historyBodies.some((body) => body.cursor === "cursor-preserved-on-400")).toBe(true)
+            expect(historyBodies.some((body) => body.cursor === undefined)).toBe(false)
             expect(
               yield* Database.Service.use(({ db }) =>
                 db
diff --git a/packages/deepagent-code/test/deepagent/learning-lifecycle-e2e.test.ts b/packages/deepagent-code/test/deepagent/learning-lifecycle-e2e.test.ts
new file mode 100644
index 00000000..017850cd
--- /dev/null
+++ b/packages/deepagent-code/test/deepagent/learning-lifecycle-e2e.test.ts
@@ -0,0 +1,468 @@
+/**
+ * FEAT-004 — learning closed-loop E2E evidence-chain verification (no real LLM).
+ *
+ * Covers the cross-run chain that the three lifecycle callers (idle/pause/project_switch)
+ * feed into:
+ *
+ *   Run A finalization artifacts (LEARNING_ADMISSION_RECEIPT.json + DEEPAGENT_RUN_STATE.json)
+ *     → runtime observer (same wiring as learning-runtime.ts) → observe(trigger=idle)
+ *     → admitted trigger receipt + lifecycle artifact persisted inside the runs directory
+ *     → durable learning job enqueued and drained to completion.
+ *
+ * Then verifies the released-knowledge binding half of the loop:
+ *   Run A's released snapshot binding fingerprint stays stable for Run B resolving the SAME
+ *   workspace (no new publication), and becomes `unavailable` when Run B resolves a different
+ *   workspace / security namespace scope.
+ *
+ * Fixture policy (QUAL-003): no terminal authority row is ever INSERTed directly — trigger
+ * receipts advance through `observe`, learning jobs through `admit`/`drain`, and released
+ * snapshots through `DeepAgentReleasedSnapshot.publish`.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { count } from "drizzle-orm"
+import { Effect, Layer } from "effect"
+import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
+import { Database } from "@deepagent-code/core/database/database"
+import { DeepAgentDurableLearning, type Admission } from "@deepagent-code/core/deepagent/durable-learning"
+import type { DocumentStore } from "@deepagent-code/core/deepagent/document-store"
+import { DeepAgentLearningLifecycleTrigger } from "@deepagent-code/core/deepagent/learning-lifecycle-trigger"
+import { LearningLifecycleTriggerTable } from "@deepagent-code/core/deepagent/learning-lifecycle-trigger.sql"
+import { LearningJobTable } from "@deepagent-code/core/deepagent/learning-job.sql"
+import {
+  DeepAgentReleasedSnapshot,
+  type DocumentRef,
+  type PublishInput,
+  type Scope,
+} from "@deepagent-code/core/deepagent/released-snapshot"
+import { createInitialRoundState } from "@deepagent-code/core/deepagent/round-state"
+import { FSUtil } from "@deepagent-code/core/fs-util"
+import { Project } from "@deepagent-code/core/project"
+import { ProjectTable } from "@deepagent-code/core/project/sql"
+import { AbsolutePath } from "@deepagent-code/core/schema"
+import { SessionSchema } from "@deepagent-code/core/session/schema"
+import { SessionTable } from "@deepagent-code/core/session/sql"
+import { CanonicalJson } from "@deepagent-code/core/util/canonical-json"
+import { Hash } from "@deepagent-code/core/util/hash"
+
+const SESSION_ID = "ses_lifecycle_e2e"
+const RUN_A_ID = "run-lifecycle-e2e-a"
+const DATABASE_PROJECT_ID = "project-db-lifecycle-e2e"
+const OBSERVED_PROJECT_ID = "project-observed-lifecycle-e2e"
+
+let root: string
+
+beforeEach(() => {
+  root = mkdtempSync(path.join(tmpdir(), "deepagent-learning-lifecycle-e2e-"))
+})
+
+afterEach(() => {
+  DeepAgentLearningLifecycleTrigger.setRuntimeObserver(undefined)
+  rmSync(root, { recursive: true, force: true })
+})
+
+describe("learning lifecycle closed loop (E2E, no LLM)", () => {
+  test("Run A finalization → idle observe → admitted receipt with matching artifact hash persisted in runs dir", async () => {
+    const workspace = path.join(root, "workspace")
+    const runsDir = path.join(root, "runs")
+    mkdirSync(workspace, { recursive: true })
+    writeRunAFinalization({ root, workspace })
+
+    await run(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        yield* seedProjectAndSession(db, workspace)
+
+        // Mirror learning-runtime.ts:54-62 — the server runtime registers the observer that the
+        // idle caller (SessionRunState Runner.onIdle) reaches via `notify`.
+        DeepAgentLearningLifecycleTrigger.setRuntimeObserver({
+          observe: (input) =>
+            Effect.runPromise(
+              DeepAgentLearningLifecycleTrigger.observe(db, input, { authorityRoot: root, runsDir }),
+            ),
+        })
+
+        const outcome = yield* Effect.promise(() =>
+          DeepAgentLearningLifecycleTrigger.notify({
+            trigger: "idle",
+            boundaryKey: `session-idle:${SESSION_ID}`,
+            sessionID: SESSION_ID,
+            match: "session",
+          }),
+        )
+        expect(outcome).toMatchObject({ state: "admitted", runId: RUN_A_ID })
+
+        const receipt = yield* db.select().from(LearningLifecycleTriggerTable).get()
+        expect(receipt).toMatchObject({
+          trigger: "idle",
+          boundary_key: `session-idle:${SESSION_ID}`,
+          session_id: SESSION_ID,
+          run_id: RUN_A_ID,
+          state: "admitted",
+        })
+
+        // Artifact hash integrity: row hash === hash of persisted artifact === hash of row JSON.
+        const artifactPath = path.join(runsDir, RUN_A_ID, "LEARNING_LIFECYCLE_TRIGGER_IDLE.json")
+        expect(existsSync(artifactPath)).toBe(true)
+        const artifactContent = yield* Effect.promise(() => Bun.file(artifactPath).text())
+        expect(receipt!.artifact_hash).toBe(Hash.sha256(artifactContent))
+        expect(receipt!.artifact_hash).toBe(Hash.sha256(receipt!.artifact_json))
+        expect(artifactContent).toBe(receipt!.artifact_json)
+        expect(receipt!.artifact_path).toBe(artifactPath)
+
+        // Cross-run evidence chain: the lifecycle artifact re-anchors Run A's source receipt,
+        // terminal artifact, and admission fingerprint.
+        const artifact = JSON.parse(artifactContent)
+        expect(artifact).toMatchObject({
+          schema_version: "deepagent-code.learning_lifecycle_trigger_receipt.v1",
+          trigger: "idle",
+          boundary_key: `session-idle:${SESSION_ID}`,
+          session_id: SESSION_ID,
+          run_id: RUN_A_ID,
+          source_session_relation: "session",
+          source_admission_path: path.join(runsDir, RUN_A_ID, "LEARNING_ADMISSION_RECEIPT.json"),
+          source_terminal_path: path.join(runsDir, RUN_A_ID, "DEEPAGENT_RUN_STATE.json"),
+        })
+        expect(artifact.source_admission_sha256).toMatch(/^[0-9a-f]{64}$/)
+        expect(artifact.source_terminal_sha256).toMatch(/^[0-9a-f]{64}$/)
+        expect(artifact.learning_admission_fingerprint).toMatch(/^[0-9a-f]{64}$/)
+
+        // The admitted trigger produced a durable learning job and the worker can drain it.
+        expect(yield* db.select({ count: count() }).from(LearningJobTable).get()).toEqual({ count: 1 })
+        const completed = yield* DeepAgentDurableLearning.drain(db, {
+          owner: "learning-worker-lifecycle-e2e",
+          authorityRoot: root,
+        })
+        expect(completed.length).toBeGreaterThanOrEqual(1)
+        expect(completed[0]).toMatchObject({ state: "completed" })
+
+        // Exact-boundary dedupe: a second idle observe for the same boundary is idempotent.
+        const retry = yield* DeepAgentLearningLifecycleTrigger.observe(
+          db,
+          {
+            trigger: "idle",
+            boundaryKey: `session-idle:${SESSION_ID}`,
+            sessionID: SESSION_ID,
+            match: "session",
+          },
+          { authorityRoot: root, runsDir },
+        )
+        expect(retry).toMatchObject({ state: "admitted", runId: RUN_A_ID })
+        expect(yield* db.select({ count: count() }).from(LearningLifecycleTriggerTable).get()).toEqual({ count: 1 })
+      }),
+    )
+  }, 30_000)
+
+  test("Run B in the same workspace binds the identical released-knowledge exact-refs fingerprint", async () => {
+    const workspace = path.join(root, "workspace")
+    mkdirSync(workspace, { recursive: true })
+
+    await run(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        const scopeRunA = yield* resolveScope(workspace)
+        const released = yield* publishRunAKnowledge(db, scopeRunA)
+
+        // Run A's request-time binding (what session_tool_request_receipt records as
+        // released_knowledge_exact_refs_fingerprint).
+        const selectionRunA = yield* DeepAgentReleasedSnapshot.current(db, scopeRunA)
+        const bindingRunA = DeepAgentReleasedSnapshot.binding(selectionRunA)
+        expect(bindingRunA).toMatchObject({ state: "bound", snapshotId: released.snapshotId })
+
+        // Run B resolves the same workspace → identical location identity → identical scope.
+        const scopeRunB = yield* resolveScope(workspace)
+        expect(scopeRunB.securityNamespaceId).toBe(scopeRunA.securityNamespaceId)
+        expect(scopeRunB.projectScopeKey).toBe(scopeRunA.projectScopeKey)
+
+        const selectionRunB = yield* DeepAgentReleasedSnapshot.current(db, scopeRunB)
+        const bindingRunB = DeepAgentReleasedSnapshot.binding(selectionRunB)
+        expect(bindingRunB.state).toBe("bound")
+        expect(bindingRunB.exactRefsFingerprint).toBe(bindingRunA.exactRefsFingerprint)
+        expect(bindingRunB.exactRefs).toEqual(bindingRunA.exactRefs)
+        expect(DeepAgentReleasedSnapshot.matchesBinding(selectionRunB, bindingRunA)).toBe(true)
+      }),
+    )
+  })
+
+  test("Run B in a different workspace/security namespace gets an unavailable binding", async () => {
+    const workspace = path.join(root, "workspace")
+    const otherWorkspace = path.join(root, "workspace-other")
+    mkdirSync(workspace, { recursive: true })
+    mkdirSync(otherWorkspace, { recursive: true })
+
+    await run(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        const scopeRunA = yield* resolveScope(workspace)
+        yield* publishRunAKnowledge(db, scopeRunA)
+        const bindingRunA = DeepAgentReleasedSnapshot.binding(yield* DeepAgentReleasedSnapshot.current(db, scopeRunA))
+        expect(bindingRunA.state).toBe("bound")
+
+        // Workspace switch: a different canonical root derives a different location/project scope,
+        // so no released head exists there.
+        const scopeOther = yield* resolveScope(otherWorkspace)
+        expect(`${scopeOther.securityNamespaceId}:${scopeOther.projectScopeKey}`).not.toBe(
+          `${scopeRunA.securityNamespaceId}:${scopeRunA.projectScopeKey}`,
+        )
+        const selectionOther = yield* DeepAgentReleasedSnapshot.current(db, scopeOther)
+        expect(selectionOther).toBeUndefined()
+        const bindingOther = DeepAgentReleasedSnapshot.binding(selectionOther)
+        expect(bindingOther).toMatchObject({ state: "unavailable", exactRefs: [] })
+        expect(bindingOther.exactRefsFingerprint).not.toBe(bindingRunA.exactRefsFingerprint)
+
+        // Security-namespace switch: even with Run A's project scope key, a foreign namespace
+        // resolves nothing.
+        const foreignNamespace: Scope = {
+          securityNamespaceId: "sec_foreign_lifecycle_e2e",
+          projectScopeKey: scopeRunA.projectScopeKey,
+          legacyProjectId: scopeRunA.legacyProjectId,
+        }
+        expect(yield* DeepAgentReleasedSnapshot.current(db, foreignNamespace)).toBeUndefined()
+        expect(DeepAgentReleasedSnapshot.binding(undefined)).toMatchObject({
+          state: "unavailable",
+          exactRefs: [],
+        })
+      }),
+    )
+  })
+
+  test("unregistered observer (pure CLI path) skips silently without a defect", async () => {
+    DeepAgentLearningLifecycleTrigger.setRuntimeObserver(undefined)
+
+    await run(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+
+        // Mirrors SessionRunState/goal-driver/instance-store: notify is always awaited through
+        // Effect.ignore, so an unregistered observer must resolve — never reject or defect.
+        // FEAT-004: the unregistered-observer skip is its OWN reason code — distinct from an
+        // observer that ran but found no matching settled run (`no_exact_settled_run`).
+        const idle = yield* Effect.promise(() =>
+          DeepAgentLearningLifecycleTrigger.notify({
+            trigger: "idle",
+            boundaryKey: `session-idle:${SESSION_ID}`,
+            sessionID: SESSION_ID,
+            match: "session",
+          }),
+        )
+        expect(idle).toEqual({ state: "skipped", reason: "no_observer_registered" })
+
+        const projectSwitch = yield* Effect.promise(() =>
+          DeepAgentLearningLifecycleTrigger.notify({
+            trigger: "project_switch",
+            boundaryKey: `project-switch:${path.join(root, "workspace")}`,
+            directory: path.join(root, "workspace"),
+          }),
+        ).pipe(Effect.ignore)
+        expect(projectSwitch).toBeUndefined()
+
+        expect(yield* db.select({ count: count() }).from(LearningLifecycleTriggerTable).get()).toEqual({ count: 0 })
+        expect(yield* db.select({ count: count() }).from(LearningJobTable).get()).toEqual({ count: 0 })
+      }),
+    )
+  })
+})
+
+function run<A, E>(effect: Effect.Effect<A, E, Database.Service | LocationIdentity.Service>) {
+  const database = Database.layerFromPath(":memory:")
+  return Effect.runPromise(
+    effect.pipe(
+      Effect.provide(
+        Layer.merge(database, LocationIdentity.layer.pipe(Layer.provide(database), Layer.provide(FSUtil.defaultLayer))),
+      ),
+      Effect.scoped,
+    ),
+  )
+}
+
+/**
+ * Writes Run A's session-finalization products through the same legitimate path the gateway
+ * uses: a fingerprint-bound terminal artifact plus a `submitted` local admission receipt.
+ */
+function writeRunAFinalization(input: { readonly root: string; readonly workspace: string }) {
+  const runDir = path.join(input.root, "runs", RUN_A_ID)
+  const terminalPath = path.join(runDir, "DEEPAGENT_RUN_STATE.json")
+  const receiptPath = path.join(runDir, "LEARNING_ADMISSION_RECEIPT.json")
+  mkdirSync(runDir, { recursive: true })
+  const admission: Admission = {
+    baseDir: input.root,
+    workspacePath: input.workspace,
+    rejectedBufferDir: path.join(input.root, "memory"),
+    terminalArtifact: {
+      schema_version: "deepagent-code.learning_terminal_artifact.v1",
+      path: terminalPath,
+      sha256: "0".repeat(64),
+      learning_admission_fingerprint: "0".repeat(64),
+    },
+    input: {
+      projectID: "requested-project",
+      sessionID: SESSION_ID,
+      runID: RUN_A_ID,
+      mode: "high",
+      roundState: createInitialRoundState("high"),
+      totalRounds: 1,
+      finalStatus: "completed",
+      trigger: "session_finalization",
+      policy: "auto_merge_safe_project",
+    },
+  }
+  const fingerprint = DeepAgentDurableLearning.admissionFingerprint(admission)
+  const terminal = CanonicalJson.stringify({
+    schema_version: "deepagent_global_run_state.v1",
+    run_id: RUN_A_ID,
+    generic_agent_session_id: SESSION_ID,
+    parent_generic_agent_session_id: null,
+    goal_id: null,
+    agent_mode: "high",
+    state: "completed",
+    updated_at: "2026-08-14T00:00:00.000Z",
+    learning_admission_fingerprint: fingerprint,
+  })
+  const bound: Admission = {
+    ...admission,
+    terminalArtifact: {
+      ...admission.terminalArtifact,
+      sha256: Hash.sha256(terminal),
+      learning_admission_fingerprint: fingerprint,
+    },
+  }
+  writeFileSync(terminalPath, terminal)
+  writeFileSync(receiptPath, CanonicalJson.stringify(DeepAgentDurableLearning.localAdmissionReceipt(bound, "submitted")))
+}
+
+function seedProjectAndSession(db: Database.Interface["db"], workspace: string) {
+  return Effect.gen(function* () {
+    yield* db.insert(ProjectTable).values({
+      id: Project.ID.make(DATABASE_PROJECT_ID),
+      worktree: AbsolutePath.make(workspace),
+      sandboxes: [],
+      time_created: 1,
+      time_updated: 1,
+    })
+    yield* db.insert(SessionTable).values({
+      id: SessionSchema.ID.make(SESSION_ID),
+      project_id: Project.ID.make(DATABASE_PROJECT_ID),
+      slug: SESSION_ID,
+      directory: workspace,
+      title: SESSION_ID,
+      version: "1",
+      time_created: 1,
+      time_updated: 1,
+    })
+  })
+}
+
+const resolveScope = (directory: string) =>
+  Effect.gen(function* () {
+    const identity = yield* (yield* LocationIdentity.Service).resolve({
+      boundary: { kind: "implicit_local" },
+      directory: AbsolutePath.make(directory),
+      project: { kind: "registered_root", observedProjectId: OBSERVED_PROJECT_ID },
+    })
+    return {
+      securityNamespaceId: identity.securityNamespaceId,
+      projectScopeKey: identity.projectScopeKey,
+      legacyProjectId: OBSERVED_PROJECT_ID,
+    } as Scope
+  })
+
+/**
+ * Publishes Run A's released knowledge through the legal publication path:
+ * an empty legacy baseline followed by an evaluated release of one durable document.
+ */
+function publishRunAKnowledge(db: Database.Interface["db"], scope: Scope) {
+  return Effect.gen(function* () {
+    const releasedDoc = document("knowledge-lifecycle-e2e", 1, scope.legacyProjectId)
+    const authority = documentAuthority([releasedDoc])
+    const baseline = yield* DeepAgentReleasedSnapshot.publish(
+      db,
+      publishInput({
+        snapshotId: "snapshot_lifecycle_e2e_baseline",
+        evaluationId: "evaluation_lifecycle_e2e_baseline",
+        scope,
+        releaseKind: "legacy_baseline",
+        documents: [],
+        now: 10,
+      }),
+      authority,
+    )
+    if (!baseline) return yield* Effect.die("baseline release is unavailable")
+    const released = yield* DeepAgentReleasedSnapshot.publish(
+      db,
+      publishInput({
+        snapshotId: "snapshot_lifecycle_e2e_run_a",
+        evaluationId: "evaluation_lifecycle_e2e_run_a",
+        scope,
+        expectedParentSnapshotId: baseline.snapshotId,
+        expectedGeneration: baseline.generation,
+        releaseKind: "evaluated",
+        documents: [releasedDoc],
+        now: 20,
+      }),
+      authority,
+    )
+    if (!released) return yield* Effect.die("Run A release is unavailable")
+    return released
+  })
+}
+
+function publishInput(
+  value: Pick<PublishInput, "snapshotId" | "evaluationId" | "scope" | "documents"> & Partial<PublishInput>,
+): PublishInput {
+  return {
+    expectedParentSnapshotId: null,
+    expectedGeneration: 0,
+    releaseKind: "evaluated",
+    verdict: "passed",
+    evaluationMatrix: { source: "learning-lifecycle-e2e" },
+    baselineRef: "learning-lifecycle-e2e",
+    repetitions: 1,
+    actor: { type: "system", id: "learning-lifecycle-e2e" },
+    ...value,
+  }
+}
+
+function document(id: string, version: number, legacyProjectId: string): DocumentRef {
+  return {
+    sourceStore: "project",
+    id,
+    version,
+    hash: `sha256:${Hash.sha256(`${id}:${version}`)}`,
+    type: "knowledge",
+    scope: `durable:project:${legacyProjectId}`,
+  }
+}
+
+function documentAuthority(documents: readonly DocumentRef[]) {
+  const refs = new Map(documents.map((ref) => [`${ref.sourceStore}:${ref.id}@${ref.version}`, ref]))
+  const store = (sourceStore: DocumentRef["sourceStore"]) =>
+    ({
+      get: (id: string, version?: number) => {
+        const ref = refs.get(`${sourceStore}:${id}@${version}`)
+        return ref ? storedDocument(ref) : null
+      },
+    }) as unknown as DocumentStore
+  return { userGlobal: store("user_global"), project: store("project") }
+}
+
+function storedDocument(ref: DocumentRef) {
+  return {
+    id: ref.id,
+    type: ref.type,
+    scope: ref.scope,
+    status: "active",
+    version: ref.version,
+    superseded_by: null,
+    hash: ref.hash,
+    created_round: null,
+    domain: null,
+    tags: [],
+    description: ref.id,
+    provenance: { source: "human" },
+    links: [],
+    confidence: { evidence_strength: "strong", support_count: 1 },
+    body: `${ref.id}@${ref.version}`,
+  }
+}
diff --git a/packages/deepagent-code/test/effect/runtime-flags.test.ts b/packages/deepagent-code/test/effect/runtime-flags.test.ts
index b67ac28d..571582d1 100644
--- a/packages/deepagent-code/test/effect/runtime-flags.test.ts
+++ b/packages/deepagent-code/test/effect/runtime-flags.test.ts
@@ -21,18 +21,6 @@ describe("RuntimeFlags", () => {
     }),
   )
 
-  it.effect("activity authority remains legacy-owned until explicitly cut over", () =>
-    Effect.gen(function* () {
-      const defaults = yield* readFlags.pipe(Effect.provide(fromConfig({})))
-      const durable = yield* readFlags.pipe(
-        Effect.provide(fromConfig({ DEEPAGENT_CODE_ACTIVITY_AUTHORITY: "durable" })),
-      )
-
-      expect(defaults.activityAuthority).toBe("legacy")
-      expect(durable.activityAuthority).toBe("durable")
-    }),
-  )
-
   it.effect("four-graph owner rollout flags default ON and retain independent kill-switches", () =>
     Effect.gen(function* () {
       const defaults = yield* readFlags.pipe(Effect.provide(fromConfig({})))
diff --git a/packages/deepagent-code/test/legacy-event-canonicalizer-runtime.test.ts b/packages/deepagent-code/test/legacy-event-canonicalizer-runtime.test.ts
new file mode 100644
index 00000000..584d6df2
--- /dev/null
+++ b/packages/deepagent-code/test/legacy-event-canonicalizer-runtime.test.ts
@@ -0,0 +1,152 @@
+import { afterEach, describe, expect } from "bun:test"
+import { Database } from "@deepagent-code/core/database/database"
+import { EventV2 } from "@deepagent-code/core/event"
+import {
+  EventArtifactTable,
+  EventSequenceTable,
+  EventSyncSequenceTable,
+  EventTable,
+} from "@deepagent-code/core/event/sql"
+import { MessageID } from "@/session/schema"
+import { Session } from "@/session/session"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { LegacyEventCanonicalizerRuntime } from "@/legacy-event-canonicalizer-runtime"
+import { eq, sql } from "drizzle-orm"
+import { Duration, Effect, Layer } from "effect"
+import { resetDatabase } from "./fixture/db"
+import { disposeAllInstances } from "./fixture/fixture"
+import { pollWithTimeout, testEffect } from "./lib/effect"
+
+afterEach(async () => {
+  await disposeAllInstances()
+  await resetDatabase()
+})
+
+const seedLegacyEvent = Effect.fn("Test.seedLegacyEvent")(function* () {
+  const sessions = yield* Session.Service
+  const { db } = yield* Database.Service
+  const session = yield* sessions.create({ title: "canonicalizer schedule" })
+  const messageID = MessageID.ascending()
+  const patch = "你".repeat(Math.ceil((EventV2.MAX_ENCODED_PAYLOAD_BYTES + 1024) / 3))
+  const message = {
+    role: "user" as const,
+    time: { created: Date.now() },
+    agent: "build",
+    summary: {
+      diffs: [{ file: "src/large.ts", patch, additions: 2, deletions: 1, status: "modified" as const }],
+    },
+  }
+  const sequence = yield* db
+    .select({ seq: EventSequenceTable.seq })
+    .from(EventSequenceTable)
+    .where(eq(EventSequenceTable.aggregate_id, session.id))
+    .get()
+    .pipe(Effect.orDie)
+  const eventID = EventV2.ID.make(`evt_canonicalizer_${messageID}`)
+  const syncSequence = yield* db
+    .update(EventSyncSequenceTable)
+    .set({ seq: sql`${EventSyncSequenceTable.seq} + 1` })
+    .where(eq(EventSyncSequenceTable.id, 1))
+    .returning({ seq: EventSyncSequenceTable.seq })
+    .get()
+    .pipe(Effect.orDie)
+  if (!syncSequence) return yield* Effect.die("sync sequence authority missing")
+  // fixture-exempt: direct legacy event row insert — reproduces the pre-canonicalizer oversized
+  // backlog that the durable schedule is meant to drain (no current runtime path emits v1
+  // message.updated payloads above the encoded-payload budget).
+  yield* db
+    .insert(EventTable)
+    .values({
+      id: eventID,
+      aggregate_id: session.id,
+      seq: (sequence?.seq ?? -1) + 1,
+      type: EventV2.versionedType("message.updated", 1),
+      data: { sessionID: session.id, info: { ...message, id: messageID, sessionID: session.id } },
+      sync_seq: syncSequence.seq,
+    })
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .update(EventSequenceTable)
+    .set({ seq: (sequence?.seq ?? -1) + 1 })
+    .where(eq(EventSequenceTable.aggregate_id, session.id))
+    .run()
+    .pipe(Effect.orDie)
+  return { session, eventID }
+})
+
+describe("legacy event canonicalizer durable schedule", () => {
+  describe("with the schedule enabled", () => {
+    const daemon = LegacyEventCanonicalizerRuntime.makeLayer({
+      pollInterval: Duration.millis(50),
+      maxEventsPerTick: 4,
+    }).pipe(
+      Layer.provide(EventV2.defaultLayer),
+      Layer.provide(RuntimeFlags.layer({ legacyEventCanonicalizer: true })),
+    )
+    const it = testEffect(Layer.mergeAll(Session.defaultLayer, Database.defaultLayer, daemon))
+
+    it.instance(
+      "drains the legacy artifact backlog without a manual maintenance call",
+      () =>
+        Effect.gen(function* () {
+          const input = yield* seedLegacyEvent()
+          const { db } = yield* Database.Service
+          const artifact = yield* pollWithTimeout(
+            db
+              .select()
+              .from(EventArtifactTable)
+              .where(eq(EventArtifactTable.event_id, input.eventID))
+              .get()
+              .pipe(Effect.orDie),
+            "canonicalizer schedule did not produce an artifact",
+            "10 seconds",
+          )
+          expect(artifact).toMatchObject({
+            kind: "legacy_message_diff",
+            codec_version: 2,
+            aggregate_id: input.session.id,
+            event_id: input.eventID,
+          })
+          // Evidence-only governance: the source event row stays intact (no deletion/VACUUM).
+          const source = yield* db
+            .select({ id: EventTable.id })
+            .from(EventTable)
+            .where(eq(EventTable.id, input.eventID))
+            .get()
+            .pipe(Effect.orDie)
+          expect(source?.id).toBe(input.eventID)
+        }),
+      { git: true },
+      30_000,
+    )
+  })
+
+  describe("with the schedule disabled", () => {
+    const daemon = LegacyEventCanonicalizerRuntime.makeLayer({ pollInterval: Duration.millis(50) }).pipe(
+      Layer.provide(EventV2.defaultLayer),
+      Layer.provide(RuntimeFlags.layer({ legacyEventCanonicalizer: false })),
+    )
+    const it = testEffect(Layer.mergeAll(Session.defaultLayer, Database.defaultLayer, daemon))
+
+    it.instance(
+      "leaves the backlog untouched while the flag stays off",
+      () =>
+        Effect.gen(function* () {
+          const input = yield* seedLegacyEvent()
+          const { db } = yield* Database.Service
+          yield* Effect.sleep("500 millis")
+          expect(
+            yield* db
+              .select()
+              .from(EventArtifactTable)
+              .where(eq(EventArtifactTable.event_id, input.eventID))
+              .all()
+              .pipe(Effect.orDie),
+          ).toEqual([])
+        }),
+      { git: true },
+      30_000,
+    )
+  })
+})
diff --git a/packages/deepagent-code/test/mcp/headers.test.ts b/packages/deepagent-code/test/mcp/headers.test.ts
index c51ed00d..3f0be97a 100644
--- a/packages/deepagent-code/test/mcp/headers.test.ts
+++ b/packages/deepagent-code/test/mcp/headers.test.ts
@@ -1,7 +1,13 @@
-import { describe, expect, mock, beforeEach } from "bun:test"
+import { afterAll, describe, expect, mock, beforeEach } from "bun:test"
 import { Effect } from "effect"
 import { testEffect } from "../lib/effect"
 
+// Release the mock.module registrations below when this file finishes so
+// later files import the real MCP SDK modules.
+afterAll(() => {
+  mock.restore()
+})
+
 // Track what options were passed to each transport constructor
 const transportCalls: Array<{
   type: "streamable" | "sse"
diff --git a/packages/deepagent-code/test/mcp/lifecycle.test.ts b/packages/deepagent-code/test/mcp/lifecycle.test.ts
index db04ec9c..ca877d98 100644
--- a/packages/deepagent-code/test/mcp/lifecycle.test.ts
+++ b/packages/deepagent-code/test/mcp/lifecycle.test.ts
@@ -1,8 +1,15 @@
-import { expect, mock, beforeEach } from "bun:test"
+import { afterAll, expect, mock, beforeEach } from "bun:test"
 import { Cause, Effect, Exit } from "effect"
 import type { MCP as MCPNS } from "../../src/mcp/index"
 import { testEffect } from "../lib/effect"
 
+// The mock.module registrations below persist for the whole process unless
+// restored; release them when this file finishes so later files import the
+// real MCP SDK modules.
+afterAll(() => {
+  mock.restore()
+})
+
 // --- Mock infrastructure ---
 
 // Per-client state for controlling mock behavior
diff --git a/packages/deepagent-code/test/mcp/oauth-auto-connect.test.ts b/packages/deepagent-code/test/mcp/oauth-auto-connect.test.ts
index 82fa1ba9..ff1675e6 100644
--- a/packages/deepagent-code/test/mcp/oauth-auto-connect.test.ts
+++ b/packages/deepagent-code/test/mcp/oauth-auto-connect.test.ts
@@ -1,7 +1,13 @@
-import { expect, mock, beforeEach } from "bun:test"
+import { afterAll, expect, mock, beforeEach } from "bun:test"
 import { Effect, Layer } from "effect"
 import { testEffect } from "../lib/effect"
 
+// Release the mock.module registrations below when this file finishes so
+// later files import the real MCP SDK modules.
+afterAll(() => {
+  mock.restore()
+})
+
 // Mock UnauthorizedError to match the SDK's class
 class MockUnauthorizedError extends Error {
   constructor(message?: string) {
diff --git a/packages/deepagent-code/test/mcp/oauth-browser.test.ts b/packages/deepagent-code/test/mcp/oauth-browser.test.ts
index ffad3b7f..c421d6ba 100644
--- a/packages/deepagent-code/test/mcp/oauth-browser.test.ts
+++ b/packages/deepagent-code/test/mcp/oauth-browser.test.ts
@@ -1,9 +1,15 @@
-import { expect, mock, beforeEach } from "bun:test"
+import { afterAll, expect, mock, beforeEach } from "bun:test"
 import { EventEmitter } from "events"
 import { Deferred, Effect, Layer, Option } from "effect"
 import { awaitWithTimeout, testEffect } from "../lib/effect"
 import type { MCP as MCPNS } from "../../src/mcp/index"
 
+// Release the mock.module registrations below when this file finishes so
+// later files import the real modules.
+afterAll(() => {
+  mock.restore()
+})
+
 // Track open() calls and control failure behavior
 let openShouldFail = false
 let openCalledWith: string | undefined
diff --git a/packages/deepagent-code/test/provider/transform.test.ts b/packages/deepagent-code/test/provider/transform.test.ts
index c5a66a78..c56f3ee5 100644
--- a/packages/deepagent-code/test/provider/transform.test.ts
+++ b/packages/deepagent-code/test/provider/transform.test.ts
@@ -1224,6 +1224,17 @@ describe("ProviderTransform.message - DeepSeek reasoning content", () => {
           },
         ],
       },
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "test",
+            toolName: "bash",
+            output: { type: "text", value: "hello" },
+          },
+        ],
+      },
     ] as any[]
 
     const result = ProviderTransform.message(
@@ -1265,7 +1276,7 @@ describe("ProviderTransform.message - DeepSeek reasoning content", () => {
       {},
     )
 
-    expect(result).toHaveLength(1)
+    expect(result).toHaveLength(2)
     expect(result[0].content).toEqual([
       {
         type: "tool-call",
@@ -1387,6 +1398,24 @@ describe("ProviderTransform.message - surrogate sanitization", () => {
             toolName: "Read",
             input: { filePath: ".deepagent-code/tool/emoji.ts" },
           },
+          {
+            type: "tool-call",
+            toolCallId: "call-2",
+            toolName: "Read",
+            input: { filePath: ".deepagent-code/tool/emoji.ts" },
+          },
+          {
+            type: "tool-call",
+            toolCallId: "call-3",
+            toolName: "Read",
+            input: { filePath: ".deepagent-code/tool/emoji.ts" },
+          },
+          {
+            type: "tool-call",
+            toolCallId: "call-4",
+            toolName: "Read",
+            input: { filePath: ".deepagent-code/tool/emoji.ts" },
+          },
           {
             type: "tool-result",
             toolCallId: "call-2",
@@ -1407,24 +1436,41 @@ describe("ProviderTransform.message - surrogate sanitization", () => {
           },
         ],
       },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "call-5",
+            toolName: "Read",
+            input: { filePath: ".deepagent-code/tool/emoji.ts" },
+          },
+          {
+            type: "tool-call",
+            toolCallId: "call-6",
+            toolName: "Read",
+            input: { filePath: ".deepagent-code/tool/emoji.ts" },
+          },
+        ],
+      },
       {
         role: "tool",
         content: [
           {
             type: "tool-result",
-            toolCallId: "call-5",
+            toolCallId: "call-1",
             toolName: "Read",
             output: { type: "text", value: text("tool text") },
           },
           {
             type: "tool-result",
-            toolCallId: "call-6",
+            toolCallId: "call-5",
             toolName: "Read",
             output: { type: "error-text", value: text("tool error") },
           },
           {
             type: "tool-result",
-            toolCallId: "call-7",
+            toolCallId: "call-6",
             toolName: "Read",
             output: { type: "content", value: [{ type: "text", text: text("tool content") }] },
           },
@@ -1440,12 +1486,12 @@ describe("ProviderTransform.message - surrogate sanitization", () => {
     expect(result[3].content).toBe(expected("assistant string"))
     expect(result[4].content[0].text).toBe(expected("assistant text"))
     expect(result[4].content[1].text).toBe(expected("assistant reasoning"))
-    expect(result[4].content[3].output.value).toBe(expected("assistant tool text"))
-    expect(result[4].content[4].output.value).toBe(expected("assistant tool error"))
-    expect(result[4].content[5].output.value[0].text).toBe(expected("assistant tool content"))
-    expect(result[5].content[0].output.value).toBe(expected("tool text"))
-    expect(result[5].content[1].output.value).toBe(expected("tool error"))
-    expect(result[5].content[2].output.value[0].text).toBe(expected("tool content"))
+    expect(result[4].content[6].output.value).toBe(expected("assistant tool text"))
+    expect(result[4].content[7].output.value).toBe(expected("assistant tool error"))
+    expect(result[4].content[8].output.value[0].text).toBe(expected("assistant tool content"))
+    expect(result[6].content[0].output.value).toBe(expected("tool text"))
+    expect(result[6].content[1].output.value).toBe(expected("tool error"))
+    expect(result[6].content[2].output.value[0].text).toBe(expected("tool content"))
     expect(result[2].content[1]).toEqual({ type: "image", image: "data:image/png;base64,abcd" })
   })
 })
@@ -1667,11 +1713,17 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
           { type: "tool-call", toolCallId: "123", toolName: "bash", input: { command: "ls" } },
         ],
       },
+      {
+        role: "tool",
+        content: [
+          { type: "tool-result", toolCallId: "123", toolName: "bash", output: { type: "text", value: "ok" } },
+        ],
+      },
     ] as any[]
 
     const result = ProviderTransform.message(msgs, anthropicModel, {})
 
-    expect(result).toHaveLength(1)
+    expect(result).toHaveLength(2)
     expect(result[0].content).toHaveLength(1)
     expect(result[0].content[0]).toEqual({
       type: "tool-call",
@@ -1769,11 +1821,18 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
           { type: "tool-call", toolCallId: "toolu_2", toolName: "glob", input: { pattern: "**/*.pdf" } },
         ],
       },
+      {
+        role: "tool",
+        content: [
+          { type: "tool-result", toolCallId: "toolu_1", toolName: "read", output: { type: "text", value: "ok" } },
+          { type: "tool-result", toolCallId: "toolu_2", toolName: "glob", output: { type: "text", value: "ok" } },
+        ],
+      },
     ] as any[]
 
     const result = ProviderTransform.message(msgs, anthropicModel, {}) as any[]
 
-    expect(result).toHaveLength(1)
+    expect(result).toHaveLength(2)
     expect(result[0].content).toMatchObject([
       { type: "text", text: "I checked your home directory and looked for PDF files." },
       { type: "tool-call", toolCallId: "toolu_1", toolName: "read", input: { filePath: "/root" } },
diff --git a/packages/deepagent-code/test/script/models-data.test.ts b/packages/deepagent-code/test/script/models-data.test.ts
index 0ccc79ce..5f0ec010 100644
--- a/packages/deepagent-code/test/script/models-data.test.ts
+++ b/packages/deepagent-code/test/script/models-data.test.ts
@@ -62,6 +62,20 @@ describe("models.dev build data", () => {
     )
   })
 
+  test("fails over to the next endpoint when the first one is unavailable", async () => {
+    const broken = Bun.serve({ port: 0, fetch: () => new Response(null, { status: 500 }) })
+    const healthy = Bun.serve({ port: 0, fetch: () => Response.json(catalog) })
+    const result = await loadModelsData({
+      environment: { DEEPAGENT_CODE_MODELS_URL: `${broken.url.origin}, ${healthy.url.origin}` },
+    }).finally(() => {
+      broken.stop(true)
+      healthy.stop(true)
+    })
+
+    expect(result.source).toBe(`${healthy.url.origin}/api.json`)
+    expect(JSON.parse(result.data)).toEqual(catalog)
+  })
+
   test("fails closed when models.dev is unavailable", async () => {
     await using directory = await fixture()
     const cacheFile = path.join(directory.root, "models.json")
diff --git a/packages/deepagent-code/test/script/release-evidence.test.ts b/packages/deepagent-code/test/script/release-evidence.test.ts
new file mode 100644
index 00000000..e1c7d52a
--- /dev/null
+++ b/packages/deepagent-code/test/script/release-evidence.test.ts
@@ -0,0 +1,188 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { appendFile, mkdtemp, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import {
+  RELEASE_EVIDENCE_SCHEMA_VERSION,
+  ReleaseEvidenceError,
+  archiveGate,
+  buildManifest,
+  checkManifest,
+  findManifestPaths,
+  manifestPathFor,
+  parseEvidenceSpec,
+  serializeManifest,
+  sha256Hex,
+  sha256OfFile,
+} from "../../../../script/release-evidence"
+
+const COMMIT = "a".repeat(40)
+const FIXED_TIME = "2026-08-19T00:00:00Z"
+
+const roots: string[] = []
+
+async function newRoot(): Promise<string> {
+  const root = await mkdtemp(path.join(os.tmpdir(), "release-evidence-test-"))
+  roots.push(root)
+  return root
+}
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+function baseArchiveOptions(root: string) {
+  return {
+    root,
+    version: "v4.1",
+    gateID: "release-gate-20260819",
+    commit: COMMIT,
+    date: "2026-08-19",
+    generatedAt: FIXED_TIME,
+    status: "passed" as const,
+    summary: "gate summary",
+    evidence: [
+      {
+        kind: "test-summary" as const,
+        label: "full-suite",
+        path: null,
+        sha256: null,
+        conclusion: "4967 pass / 0 fail / 5006 tests",
+      },
+    ],
+    signatures: [{ role: "release-owner", actor: "", at: "" }],
+  }
+}
+
+describe("release evidence manifest tooling", () => {
+  test("sha256 is the stable FIPS-180 digest", () => {
+    expect(sha256Hex("abc")).toBe("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad")
+    expect(sha256Hex("")).toBe("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+  })
+
+  test("manifest serialization is deterministic", () => {
+    const root = "unused"
+    const options = baseArchiveOptions(root)
+    expect(serializeManifest(buildManifest(options))).toBe(serializeManifest(buildManifest(options)))
+    const serialized = serializeManifest(buildManifest(options))
+    const parsed = JSON.parse(serialized) as Record<string, unknown>
+    expect(Object.keys(parsed)).toEqual([
+      "schema_version",
+      "version",
+      "gate_id",
+      "commit",
+      "date",
+      "generated_at",
+      "status",
+      "summary",
+      "evidence",
+      "signatures",
+    ])
+    expect(parsed.schema_version).toBe(RELEASE_EVIDENCE_SCHEMA_VERSION)
+  })
+
+  test("archive writes the manifest at release-evidence/<version>/<commit>/<gate>/manifest.json", async () => {
+    const root = await newRoot()
+    const target = archiveGate(baseArchiveOptions(root))
+    expect(target).toBe(manifestPathFor(root, "v4.1", COMMIT, "release-gate-20260819"))
+    const parsed = JSON.parse(await Bun.file(target).text()) as Record<string, unknown>
+    expect(parsed.commit).toBe(COMMIT)
+    expect(parsed.date).toBe("2026-08-19")
+    expect(parsed.generated_at).toBe(FIXED_TIME)
+  })
+
+  test("archive is immutable: regenerating the same gate fails without overwriting", async () => {
+    const root = await newRoot()
+    const target = archiveGate(baseArchiveOptions(root))
+    const before = await Bun.file(target).text()
+    expect(() => archiveGate({ ...baseArchiveOptions(root), summary: "changed" })).toThrow(ReleaseEvidenceError)
+    expect(await Bun.file(target).text()).toBe(before)
+  })
+
+  test("archive validates gate id, commit, date, status and evidence consistency", async () => {
+    const root = await newRoot()
+    expect(() => archiveGate({ ...baseArchiveOptions(root), gateID: "bad gate" })).toThrow(/--gate/)
+    expect(() => archiveGate({ ...baseArchiveOptions(root), commit: "abc" })).toThrow(/--commit/)
+    expect(() => archiveGate({ ...baseArchiveOptions(root), date: "2026-08-19" })).not.toThrow()
+    expect(() => archiveGate({ ...baseArchiveOptions(root), status: "green" as never })).toThrow(/--status/)
+    expect(() =>
+      archiveGate({
+        ...baseArchiveOptions(root),
+        gateID: "gate-2",
+        evidence: [
+          { kind: "log", label: "a", path: "x", sha256: null, conclusion: "c" },
+        ],
+      }),
+    ).toThrow(/path and sha256/)
+  })
+
+  test("check passes for intact file evidence and detects tampering", async () => {
+    const root = await newRoot()
+    const evidenceFile = path.join(root, "run.log")
+    await writeFile(evidenceFile, "original log line\n")
+    const options = baseArchiveOptions(root)
+    archiveGate({
+      ...options,
+      evidence: [
+        {
+          kind: "log",
+          label: "run-log",
+          path: "run.log",
+          sha256: sha256OfFile(evidenceFile),
+          conclusion: "captured run log",
+        },
+      ],
+    })
+    const manifestPath = manifestPathFor(root, "v4.1", COMMIT, "release-gate-20260819")
+
+    expect(checkManifest(manifestPath).ok).toBe(true)
+
+    await appendFile(evidenceFile, "tampered line\n")
+    const tampered = checkManifest(manifestPath)
+    expect(tampered.ok).toBe(false)
+    expect(tampered.failures.some((failure) => failure.includes("sha256 mismatch"))).toBe(true)
+
+    await rm(evidenceFile)
+    const missing = checkManifest(manifestPath)
+    expect(missing.ok).toBe(false)
+    expect(missing.failures.some((failure) => failure.includes("file missing"))).toBe(true)
+  })
+
+  test("check rejects invalid manifests without crashing", async () => {
+    const root = await newRoot()
+    const manifestPath = path.join(root, "broken.json")
+    await writeFile(manifestPath, "{ not json")
+    expect(checkManifest(manifestPath).ok).toBe(false)
+    expect(checkManifest(path.join(root, "absent.json")).failures[0]).toContain("not found")
+  })
+
+  test("findManifestPaths locates gates with and without a commit", async () => {
+    const root = await newRoot()
+    archiveGate(baseArchiveOptions(root))
+    archiveGate({ ...baseArchiveOptions(root), commit: "b".repeat(40) })
+    expect(findManifestPaths(root, "v4.1", "release-gate-20260819")).toHaveLength(2)
+    expect(findManifestPaths(root, "v4.1", "release-gate-20260819", COMMIT)).toHaveLength(1)
+    expect(findManifestPaths(root, "v4.1", "release-gate-20260819", "c".repeat(40))).toHaveLength(0)
+  })
+
+  test("parseEvidenceSpec hashes file evidence and keeps text-only entries null", async () => {
+    const root = await newRoot()
+    const textOnly = parseEvidenceSpec("test-summary:full-suite", root, "conclusion")
+    expect(textOnly).toEqual({
+      kind: "test-summary",
+      label: "full-suite",
+      path: null,
+      sha256: null,
+      conclusion: "conclusion",
+    })
+
+    const evidenceFile = path.join(root, "evidence.log")
+    await writeFile(evidenceFile, "abc")
+    const fileBacked = parseEvidenceSpec(`log:run-log:${evidenceFile}`, root, "conclusion")
+    expect(fileBacked.path).toBe("evidence.log")
+    expect(fileBacked.sha256).toBe(sha256Hex("abc"))
+
+    expect(() => parseEvidenceSpec("bogus:x", root, "c")).toThrow(/kind/)
+    expect(() => parseEvidenceSpec("log:missing:does-not-exist.log", root, "c")).toThrow(/not found/)
+  })
+})
diff --git a/packages/deepagent-code/test/script/run-live-llm-all.test.ts b/packages/deepagent-code/test/script/run-live-llm-all.test.ts
index 959d2405..ab590b09 100644
--- a/packages/deepagent-code/test/script/run-live-llm-all.test.ts
+++ b/packages/deepagent-code/test/script/run-live-llm-all.test.ts
@@ -12,6 +12,7 @@ import {
   runnerEnvironment,
   selectSuites,
   suites,
+  validateRegistryScripts,
   validateRunnerConfig,
   validateSuiteManifest,
 } from "../../../../script/run-live-llm-all"
@@ -364,6 +365,19 @@ describe("all real LLM test runner", () => {
     await expect(validateSuiteManifest()).resolves.toBeUndefined()
   })
 
+  test("every registered suite script exists in its owning package.json (QUAL-004)", async () => {
+    // Closes the gap left by validateSuiteManifest: det gates, setup, and
+    // desktop suites that run `bun run <script>` must also resolve, so a
+    // registry entry can never silently reference a removed script.
+    await expect(validateRegistryScripts()).resolves.toBeUndefined()
+    const scriptBacked = suites.filter(
+      (suite) =>
+        suite.package !== "root" &&
+        (suite.packageScript !== undefined || (suite.command[0] === "bun" && suite.command[1] === "run")),
+    )
+    expect(scriptBacked.length).toBeGreaterThanOrEqual(suites.length - 2)
+  })
+
   test("reads normalized autonomous scores without turning partial credit into a gate", () => {
     expect(
       parseEvaluationSummary({
diff --git a/packages/deepagent-code/test/server/httpapi-mdns.test.ts b/packages/deepagent-code/test/server/httpapi-mdns.test.ts
index 1964742b..358b6e1e 100644
--- a/packages/deepagent-code/test/server/httpapi-mdns.test.ts
+++ b/packages/deepagent-code/test/server/httpapi-mdns.test.ts
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test"
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test"
 import * as Log from "@deepagent-code/core/util/log"
 import { withTimeout } from "../../src/util/timeout"
 
@@ -30,6 +30,12 @@ void mock.module("bonjour-service", () => ({
 // Import Server AFTER the mock so the MDNS module picks up the stub.
 const { Server } = await import("../../src/server/server")
 
+// Release the bonjour-service mock when this file finishes so later files
+// that import modules still unloaded see the real dependency.
+afterAll(() => {
+  mock.restore()
+})
+
 beforeEach(() => {
   events.length = 0
   nextOwner = 0
diff --git a/packages/deepagent-code/test/server/httpapi-packs-events.test.ts b/packages/deepagent-code/test/server/httpapi-packs-events.test.ts
new file mode 100644
index 00000000..a4b78637
--- /dev/null
+++ b/packages/deepagent-code/test/server/httpapi-packs-events.test.ts
@@ -0,0 +1,259 @@
+import { describe, expect } from "bun:test"
+import { mkdtempSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { NodeHttpServer, NodeServices } from "@effect/platform-node"
+import { Context, Effect, Fiber, Layer, Option, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpRouter } from "effect/unstable/http"
+import * as Socket from "effect/unstable/socket/Socket"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import { eq } from "drizzle-orm"
+import { Database } from "@deepagent-code/core/database/database"
+import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
+import { DeepAgentEventTable } from "@deepagent-code/core/deepagent/deepagent-event-sql"
+import { LMNEvents } from "@deepagent-code/core/deepagent/lmn-events"
+import { readPinnedPacks, writePinnedPacks } from "@deepagent-code/core/deepagent/pinned-packs"
+import { Flag } from "@deepagent-code/core/flag/flag"
+import {
+  packChangedIdempotencyKey,
+  publishPackChanged,
+} from "../../src/server/routes/instance/httpapi/handlers/deepagent"
+import { HttpApiApp } from "../../src/server/routes/instance/httpapi/server"
+import { ServerAuth } from "../../src/server/auth"
+import { resetDatabase } from "../fixture/db"
+import { tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+// FEAT-003 — pack.changed eventing for packsPin/packsUnpin. Runs the REAL publish path
+// (publishPackChanged, the exact seam the handlers call after committing the pinned-set file)
+// against the REAL §A2 bus over an in-memory database — the same fixture pattern as
+// packages/core/test/deepagent-event-bus.test.ts.
+
+let clock = 0
+const now = () => clock++
+
+const database = Database.layerFromPath(":memory:")
+const busLayer = DeepAgentEventBus.layerWith({ now }).pipe(Layer.provideMerge(database))
+const it = testEffect(busLayer)
+
+const WORKSPACE = "/tmp/workspace-a"
+
+const collectPackEvents = (bus: DeepAgentEventBus.Interface) =>
+  Stream.runCollect(bus.replay({ from: 0, type: LMNEvents.PACK_CHANGED })).pipe(Effect.map((c) => Array.from(c)))
+
+describe("FEAT-003 pack.changed (pin/unpin eventing)", () => {
+  it.effect("pin publishes pack.changed with the after-write payload + set-hash idempotency key", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      // Mirror the handler flow: file write first, then publish with the authoritative after-write set.
+      const memoryDir = mkdtempSync(path.join(tmpdir(), "packs-events-"))
+      writePinnedPacks(memoryDir, ["pack-b", "pack-a"])
+      yield* publishPackChanged(bus, {
+        workspacePath: WORKSPACE,
+        packId: "pack-a",
+        action: "pin",
+        pinnedIds: readPinnedPacks(memoryDir),
+      })
+
+      const events = yield* collectPackEvents(bus)
+      expect(events.length).toBe(1)
+      const event = events[0]!
+      expect(event.type).toBe(LMNEvents.PACK_CHANGED) // type
+      expect(event.source).toBe("system")
+      expect(event.workspaceID).toBe(WORKSPACE)
+      expect(event.priority).toBe("normal")
+      // payload: workspacePath / packId / action / pinnedIds (the after-write set, deduped + sorted)
+      expect(event.payload).toEqual({
+        workspacePath: WORKSPACE,
+        packId: "pack-a",
+        action: "pin",
+        pinnedIds: ["pack-a", "pack-b"],
+      })
+      // idempotency key = workspace-scoped hash of the after-write set (+ action discriminator)
+      expect(event.idempotencyKey).toBe(
+        packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "pin", pinnedIds: ["pack-a", "pack-b"] }),
+      )
+    }),
+  )
+
+  it.effect("unpinning the LAST pack still publishes (empty after-write set)", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      yield* publishPackChanged(bus, {
+        workspacePath: WORKSPACE,
+        packId: "pack-solo",
+        action: "unpin",
+        pinnedIds: [], // the after-write set of an unpin of the last pinned pack
+      })
+
+      const events = yield* collectPackEvents(bus)
+      expect(events.length).toBe(1)
+      const event = events[0]!
+      expect(event.type).toBe(LMNEvents.PACK_CHANGED)
+      expect(event.payload).toEqual({
+        workspacePath: WORKSPACE,
+        packId: "pack-solo",
+        action: "unpin",
+        pinnedIds: [],
+      })
+      // the empty set still yields a stable, publishable key — distinct from any pin key
+      expect(event.idempotencyKey).toBe(
+        packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "unpin", pinnedIds: [] }),
+      )
+      expect(event.idempotencyKey).not.toBe(
+        packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "pin", pinnedIds: [] }),
+      )
+    }),
+  )
+
+  it.effect("repeated pin leaving the SAME after-write set does not re-publish (§A3 key dedupe)", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const input = {
+        workspacePath: WORKSPACE,
+        packId: "pack-a",
+        action: "pin" as const,
+        pinnedIds: ["pack-a", "pack-b"],
+      }
+      // first click publishes; a duplicate click (double-click / retried request) resolves to the
+      // same after-write set ⇒ same idempotency key ⇒ the bus returns the existing event, no new row.
+      yield* publishPackChanged(bus, input)
+      yield* publishPackChanged(bus, input)
+      yield* publishPackChanged(bus, { ...input, pinnedIds: ["pack-b", "pack-a", "pack-a"] }) // order/dupes vary
+
+      const events = yield* collectPackEvents(bus)
+      expect(events.length).toBe(1)
+      // and live subscribers see exactly ONE delivery too
+    }),
+  )
+
+  it.effect("idempotency key is stable under set order/duplication, scoped by workspace + action", () =>
+    Effect.gen(function* () {
+      const base = packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "pin", pinnedIds: ["a", "b"] })
+      // same set, different order/duplication ⇒ same key
+      expect(
+        packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "pin", pinnedIds: ["b", "a", "a"] }),
+      ).toBe(base)
+      // different workspace / action / set ⇒ different keys (no cross-workspace or cross-action swallow)
+      expect(
+        packChangedIdempotencyKey({ workspacePath: "/tmp/workspace-b", action: "pin", pinnedIds: ["a", "b"] }),
+      ).not.toBe(base)
+      expect(
+        packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "unpin", pinnedIds: ["a", "b"] }),
+      ).not.toBe(base)
+      expect(
+        packChangedIdempotencyKey({ workspacePath: WORKSPACE, action: "pin", pinnedIds: ["a", "b", "c"] }),
+      ).not.toBe(base)
+    }),
+  )
+
+  it.effect("pack.changed is subscribable — a live type-filtered subscriber receives it", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const fiber = yield* bus
+        .subscribe({ type: LMNEvents.PACK_CHANGED })
+        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      yield* Effect.yieldNow
+      yield* publishPackChanged(bus, {
+        workspacePath: WORKSPACE,
+        packId: "pack-a",
+        action: "pin",
+        pinnedIds: ["pack-a"],
+      })
+      const received = Array.from(yield* Fiber.join(fiber))
+      expect(received.length).toBe(1)
+      expect(received[0]!.type).toBe(LMNEvents.PACK_CHANGED)
+      expect((received[0]!.payload as { packId: string }).packId).toBe("pack-a")
+    }),
+  )
+})
+
+// END-TO-END: the full production route tree (same harness as httpapi-instance.test.ts) — proves the
+// handler layer ACTUALLY obtains DeepAgentEventBus.Service and the event lands in the durable log.
+const e2eStateLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const originalWorkspaces = Flag.DEEPAGENT_CODE_EXPERIMENTAL_WORKSPACES
+    Flag.DEEPAGENT_CODE_EXPERIMENTAL_WORKSPACES = true
+    yield* Effect.promise(() => resetDatabase())
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(async () => {
+        Flag.DEEPAGENT_CODE_EXPERIMENTAL_WORKSPACES = originalWorkspaces
+        await resetDatabase()
+      }),
+    )
+  }),
+)
+const e2eRoutes = HttpRouter.serve(HttpApiApp.routes, { disableListenLog: true, disableLogger: true }).pipe(
+  Layer.provide(Socket.layerWebSocketConstructorGlobal),
+  Layer.provideMerge(NodeHttpServer.layerTest),
+  Layer.provideMerge(NodeServices.layer),
+  Layer.provide(ServerAuth.Config.layer({ password: Option.none(), username: "deepagent-code" })),
+)
+const itE2e = testEffect(
+  Layer.mergeAll(
+    e2eStateLayer,
+    // same proven harness as httpapi-instance.test.ts; the cast silences serve()'s generic noise and
+    // keeps the two services the test body actually draws (HttpClient + the spawner tmpdirScoped needs).
+    e2eRoutes as unknown as Layer.Layer<
+      HttpClient.HttpClient | ChildProcessSpawner.ChildProcessSpawner,
+      never,
+      never
+    >,
+  ),
+)
+
+const directoryHeader = (dir: string) => HttpClientRequest.setHeader("x-deepagent-code-directory", dir)
+
+describe("FEAT-003 pack.changed end-to-end (full route tree)", () => {
+  itE2e.live(
+    "packsPin/packsUnpin publish pack.changed durably; a duplicate pin does not re-publish",
+    () =>
+      Effect.gen(function* () {
+        const dir = yield* tmpdirScoped({ git: true })
+        const call = (route: string, packId: string) =>
+          HttpClientRequest.post(route).pipe(
+            directoryHeader(dir),
+            HttpClientRequest.bodyJson({ packId }),
+            Effect.flatMap(HttpClient.execute),
+          )
+
+        const pin1 = yield* call("/deepagent/packs/pin", "feat-003-pack")
+        expect(pin1.status).toBe(200)
+        // duplicate click: same after-write set ⇒ same idempotency key ⇒ bus no-op
+        const pin2 = yield* call("/deepagent/packs/pin", "feat-003-pack")
+        expect(pin2.status).toBe(200)
+        // unpinning the LAST pack must still emit
+        const unpin = yield* call("/deepagent/packs/unpin", "feat-003-pack")
+        expect(unpin.status).toBe(200)
+
+        // Observe the durable log through a connection to the SAME db file the server uses.
+        const { db } = yield* Database.layerFromPath(Database.path()).pipe(
+          Layer.build,
+          Effect.map((ctx) => Context.get(ctx, Database.Service)),
+        )
+        const rows = yield* db
+          .select()
+          .from(DeepAgentEventTable)
+          .where(eq(DeepAgentEventTable.type, LMNEvents.PACK_CHANGED))
+          .all()
+          .pipe(Effect.orDie)
+        expect(rows.length).toBe(2) // pin + unpin; the duplicate pin was deduped on the idempotency key
+        const pin = rows.find((r) => (r.payload as { action: string }).action === "pin")!
+        const last = rows.find((r) => (r.payload as { action: string }).action === "unpin")!
+        expect(pin.idempotency_key).toBe(
+          packChangedIdempotencyKey({ workspacePath: dir, action: "pin", pinnedIds: ["feat-003-pack"] }),
+        )
+        expect(pin.payload).toEqual({
+          workspacePath: dir,
+          packId: "feat-003-pack",
+          action: "pin",
+          pinnedIds: ["feat-003-pack"],
+        })
+        expect(last.idempotency_key).toBe(
+          packChangedIdempotencyKey({ workspacePath: dir, action: "unpin", pinnedIds: [] }),
+        )
+        expect((last.payload as { pinnedIds: string[] }).pinnedIds).toEqual([])
+      }),
+    30_000,
+  )
+})
diff --git a/packages/deepagent-code/test/server/httpapi-provider-recovery.test.ts b/packages/deepagent-code/test/server/httpapi-provider-recovery.test.ts
index b8927001..10da0a83 100644
--- a/packages/deepagent-code/test/server/httpapi-provider-recovery.test.ts
+++ b/packages/deepagent-code/test/server/httpapi-provider-recovery.test.ts
@@ -11,11 +11,20 @@ import {
   SessionProviderAttemptRecoveryBridgeTable,
   SessionProviderAttemptResolutionTable,
   SessionProviderAttemptTable,
+  SessionProviderOwnerLeaseTable,
 } from "@deepagent-code/core/context-federation/session-sql"
+import {
+  LocationIdentityTable,
+  ProjectScopeIdentityTable,
+  SecurityNamespaceTable,
+} from "@deepagent-code/core/context-federation/sql"
 import { Prompt } from "@deepagent-code/core/session/prompt"
 import { SessionMessage } from "@deepagent-code/core/session/message"
 import { SessionHistoryStateTable, SessionInputTable, SessionTable } from "@deepagent-code/core/session/sql"
-import { and, eq } from "drizzle-orm"
+import { and, eq, sql } from "drizzle-orm"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { ProjectScopeKey, SecurityNamespaceID } from "@deepagent-code/core/context-federation/reference"
+import { ContextActivationReceipt } from "@/context-federation/activation-receipt"
 import { Effect, Layer } from "effect"
 import { MessageV2 } from "@/session/message-v2"
 import { SessionPromptEpochTable } from "@/session/prompt-epoch.sql"
@@ -93,6 +102,101 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
   const providerAttemptID = `attempt-${Hash.sha256(title).slice(0, 24)}`
   const activityID = `activity-${Hash.sha256(title).slice(0, 24)}`
   const selectionID = `selection-${Hash.sha256(title).slice(0, 24)}`
+  // Durable federation authority for the seeded selection/attempt/receipt chain: a synthesized
+  // namespace/scope identity plus the crashed owner's token (its lease is seeded live below).
+  const securityNamespaceID = `sec-${Hash.sha256(`${title}-ns`).slice(0, 24)}`
+  const projectScopeKey = `prjctx-${Hash.sha256(`${title}-scope`).slice(0, 24)}`
+  const ownerToken = `dead-${Hash.sha256(`${title}-owner`).slice(0, 20)}`
+  // 64-hex wire identity hashes the durable turn guards demand; derived per fixture title.
+  const finalRequestHash = Hash.sha256(`${title}-final-request`)
+  const preparedTurnHash = Hash.sha256(`${title}-prepared-turn`)
+  const systemStableHash = Hash.sha256(`${title}-system-stable`)
+  const systemVolatileHash = Hash.sha256(`${title}-system-volatile`)
+  const toolDefinitionHash = Hash.sha256(`${title}-tool-definition`)
+  const contextActivationFingerprint = Hash.sha256(`${title}-context-activation`)
+  // Typed federation fixture values the receipt columns demand: a not_requested decision whose
+  // requested/enabled/project fields mirror between eligibility and activation (the semantic
+  // guard compares them field-by-field as JSON).
+  const fixtureRequested: ContextFederationRollout.Requested = {
+    contextFederationShadow: false,
+    locationIndexesV2Shadow: false,
+    contextProjectionV2: false,
+    contextQueryToolsV2: false,
+    coreV2ExecutionOwner: false,
+  }
+  const fixtureEligibility: ContextFederationRollout.ProjectDecision = {
+    requested: fixtureRequested,
+    enabled: fixtureRequested,
+    blocked: {},
+    project: { projectScopeKey, stage: "all", bucket: 0, selected: false, killSwitch: false },
+  }
+  const fixtureReadiness: ContextFederationRollout.DerivedContextDataReadiness = {
+    revision: Hash.sha256(`${title}-readiness`),
+    state: "ready",
+    identityBound: true,
+    indexAvailable: true,
+    storageHealthy: true,
+    projectScopeKey,
+    reasons: [],
+    observedAt: now,
+    expiresAt: now + 600_000,
+  }
+  const fixtureActivation: ContextActivationReceipt.Receipt = {
+    schemaVersion: 1,
+    recordedAt: now,
+    readinessAgeMs: 0,
+    readinessExpiresInMs: 600_000,
+    outcome: "not_requested",
+    enabledCapabilities: [],
+    fallbackReasons: [],
+    decision: fixtureEligibility,
+    // The semantic guard forbids a selection reference without a bound selection row.
+    ...(providerAttempt ? { selection: { selectionId: selectionID, projectionHash: "projection" } } : {}),
+  }
+  // DB-clock timestamp expression (the lease triggers reject host-skewed values).
+  const dbNowMs = sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`
+
+  // The receipt/attempt owner guards demand a live exact owner lease at database time regardless
+  // of whether an attempt is seeded; the fixture receipt always belongs to the crashed owner.
+  yield* db
+    .insert(SessionProviderOwnerLeaseTable)
+    .values({
+      owner_token: ownerToken,
+      registered_at: dbNowMs,
+      heartbeat_at: dbNowMs,
+      lease_expires_at: sql`${dbNowMs} + 3600000`,
+      released_at: null,
+    } as never)
+    .run()
+    .pipe(Effect.orDie)
+
+  // Every receipt demands a durable released-knowledge scope authority: synthesize the minimal
+  // namespace/scope identity chain (the location identity is only needed by the selection guard
+  // and stays with the attempt branch below).
+  yield* db
+    .insert(SecurityNamespaceTable)
+    .values({
+      id: securityNamespaceID,
+      kind: "implicit_local",
+      binding_hash: Hash.sha256(`${title}-binding`),
+      created_at: now,
+      retired_at: null,
+    })
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(ProjectScopeIdentityTable)
+    .values({
+      security_namespace_id: securityNamespaceID,
+      project_scope_key: projectScopeKey,
+      project_kind: "registered_root",
+      project_identity_hash: Hash.sha256(`${title}-project`),
+      observed_project_id: `project-${Hash.sha256(title).slice(0, 16)}`,
+      created_at: now,
+      retired_at: null,
+    })
+    .run()
+    .pipe(Effect.orDie)
 
   if (providerAttempt) {
     yield* db
@@ -108,7 +212,7 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
       .run()
       .pipe(Effect.orDie)
     yield* db
-      .insert(SessionActivityTable)
+      .insert(SessionActivityTable) // fixture-exempt: seeds active activity for crash-recovery fixture
       .values({
         activity_id: activityID,
         session_id: session.id,
@@ -120,6 +224,20 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
       })
       .run()
       .pipe(Effect.orDie)
+    yield* db
+      .insert(LocationIdentityTable)
+      .values({
+        security_namespace_id: securityNamespaceID,
+        location_key: "local",
+        project_scope_key: projectScopeKey,
+        workspace_binding: null,
+        canonical_root: `/recovery-fixture/${Hash.sha256(title).slice(0, 8)}`,
+        observed_project_id: null,
+        created_at: now,
+        retired_at: null,
+      })
+      .run()
+      .pipe(Effect.orDie)
     yield* db
       .insert(SessionContextSelectionTable)
       .values({
@@ -129,6 +247,8 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
         revision: 0,
         trigger_input_id: user.id,
         location_key: "local",
+        security_namespace_id: SecurityNamespaceID.make(securityNamespaceID),
+        project_scope_key: ProjectScopeKey.make(projectScopeKey),
         query_fingerprint: "query",
         authorization_fingerprint: "authorization",
         authorization_epoch: 0,
@@ -136,6 +256,9 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
         selected_source_fingerprint: "sources",
         observed_location_mutation_epoch: 0,
         next_revalidation_at: now + 60_000,
+        released_knowledge_binding_state: "unavailable",
+        released_knowledge_exact_refs: [],
+        released_knowledge_exact_refs_fingerprint: "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
         graph_revisions: "{}",
         graph_statuses: "[]",
         selected_refs: "[]",
@@ -149,7 +272,7 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
       .run()
       .pipe(Effect.orDie)
     yield* db
-      .insert(SessionProviderAttemptTable)
+      .insert(SessionProviderAttemptTable) // fixture-exempt: admitted prepared attempt; walked to the crashed state below
       .values({
         attempt_id: providerAttemptID,
         session_id: session.id,
@@ -157,14 +280,21 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
         provider_turn_seq: 0,
         selection_id: selectionID,
         projection_hash: "projection",
-        request_hash: requestHash,
+        request_hash: `input-${requestHash}`,
         provider_id: model.providerID,
-        state: "indeterminate_after_crash",
+        owner_token: ownerToken,
+        state: "prepared",
         created_at: now,
-        error_code: "process_recovery",
       })
       .run()
       .pipe(Effect.orDie)
+    // Seal the attempt's wire identity once (prepared→prepared), the sole admission path.
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ prepared_turn_hash: preparedTurnHash, wire_request_hash: finalRequestHash })
+      .where(eq(SessionProviderAttemptTable.attempt_id, providerAttemptID))
+      .run()
+      .pipe(Effect.orDie)
   }
 
   yield* db
@@ -177,7 +307,7 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
     .run()
     .pipe(Effect.orDie)
   yield* db
-    .insert(SessionToolRequestReceiptTable)
+    .insert(SessionToolRequestReceiptTable) // fixture-exempt: bare 'preparing' receipt; walked through the durable lifecycle below
     .values({
       receipt_id: receiptID,
       request_ordinal: 1,
@@ -185,6 +315,12 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
       user_message_id: user.id,
       assistant_message_id: assistant.id,
       provider_attempt_id: providerAttempt ? providerAttemptID : null,
+      context_selection_id: providerAttempt ? selectionID : null,
+      released_knowledge_security_namespace_id: SecurityNamespaceID.make(securityNamespaceID),
+      released_knowledge_project_scope_key: ProjectScopeKey.make(projectScopeKey),
+      released_knowledge_binding_state: "unavailable",
+      released_knowledge_exact_refs: [],
+      released_knowledge_exact_refs_fingerprint: "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
       provider_id: model.providerID,
       model_id: model.modelID,
       protocol: "chat",
@@ -196,16 +332,101 @@ const seedRecovery = Effect.fn("HttpProviderRecoveryTest.seedRecovery")(function
       prompt_window_id: authority.window.windowID,
       effective_history_hash: authority.effectiveHistoryHash,
       request_input_hash: `input-${requestHash}`,
-      final_request_hash: requestHash,
+      // Context activation semantics are admission-time bindings (immutable after insert).
+      context_eligibility: fixtureEligibility,
+      context_readiness: fixtureReadiness,
+      context_activation: fixtureActivation,
+      context_activation_fingerprint: contextActivationFingerprint,
+      // The receipt insert guard only admits a bare provider_state='preparing' row; the seed then
+      // walks the durable lifecycle (seal selected refs → prepared → dispatching → crash) so the
+      // fixture lands on the same indeterminate state the legacy seed used to write directly.
+      provider_state: "preparing",
+      owner_token: ownerToken,
+      request_state: "prepared",
+      created_at: now,
+    })
+    .run()
+    .pipe(Effect.orDie)
+  // 1) seal selected refs once while still preparing.
+  yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        released_knowledge_selected_refs: [],
+        released_knowledge_selected_refs_fingerprint: "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+      })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, receiptID))
+      .run()
+      .pipe(Effect.orDie)
+    // 2) seal the prepared turn and admit the receipt as prepared.
+    yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        provider_state: "prepared",
+        final_request_hash: finalRequestHash,
+        provider_request_hash: finalRequestHash,
+        wire_request_hash: finalRequestHash,
+        prepared_turn_hash: preparedTurnHash,
+        system_stable_hash: systemStableHash,
+        system_volatile_hash: systemVolatileHash,
+        tool_definition_hash: toolDefinitionHash,
+        adapter_prepared_at: now,
+        final_offered_tool_ids: ["fixture_tool"],
+      })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, receiptID))
+      .run()
+      .pipe(Effect.orDie)
+  // 3) dispatch: the attempt first when present (wire identity must match), then the receipt.
+  if (providerAttempt) {
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ state: "dispatching" })
+      .where(eq(SessionProviderAttemptTable.attempt_id, providerAttemptID))
+      .run()
+      .pipe(Effect.orDie)
+  }
+  yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({ provider_state: "dispatching", dispatching_at: now })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, receiptID))
+      .run()
+      .pipe(Effect.orDie)
+  // 4) simulate the process crash mid-dispatch: with an attempt present, the dead owner's lease
+  // is released, a recovery process takes a fresh lease, and the crash sweep marks the attempt
+  // indeterminate (the recovery owner guard demands exactly this stale-old/live-recovery pair).
+  if (providerAttempt) {
+    yield* db
+      .update(SessionProviderOwnerLeaseTable)
+      .set({ released_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)` })
+      .where(eq(SessionProviderOwnerLeaseTable.owner_token, ownerToken))
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionProviderOwnerLeaseTable)
+      .values({
+        owner_token: `recovery-${Hash.sha256(`${title}-recovery`).slice(0, 16)}`,
+        registered_at: dbNowMs,
+        heartbeat_at: dbNowMs,
+        lease_expires_at: sql`${dbNowMs} + 3600000`,
+        released_at: null,
+      } as never)
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ state: "indeterminate_after_crash", error_code: "process_recovery" })
+      .where(eq(SessionProviderAttemptTable.attempt_id, providerAttemptID))
+      .run()
+      .pipe(Effect.orDie)
+  }
+  yield* db
+    .update(SessionToolRequestReceiptTable)
+    .set({
       provider_state: "indeterminate_after_crash",
-      adapter_prepared_at: now,
-      dispatching_at: now,
       terminal_at: now,
-      owner_token: "dead-process",
       request_state: "dispatched",
       request_error_code: "provider_started_outcome_unknown_after_process_restart",
-      created_at: now,
     })
+    .where(eq(SessionToolRequestReceiptTable.receipt_id, receiptID))
     .run()
     .pipe(Effect.orDie)
   yield* db
diff --git a/packages/deepagent-code/test/server/httpapi-sdk.test.ts b/packages/deepagent-code/test/server/httpapi-sdk.test.ts
index b79c0b1e..6ac15861 100644
--- a/packages/deepagent-code/test/server/httpapi-sdk.test.ts
+++ b/packages/deepagent-code/test/server/httpapi-sdk.test.ts
@@ -994,7 +994,12 @@ describe("HttpApi SDK", () => {
 
         expect(session.status).toBe(200)
         expect(prompt.status).toBe(200)
-        expect(JSON.stringify(inputs[0])).toContain("project-rest-skill")
+        // Locate the request that carries the user prompt rather than assuming inputs[0]: under
+        // load an auxiliary request (title/summary/etc.) can reach the fake LLM first, and the
+        // skill-context guarantee belongs to the prompt request specifically.
+        const promptInput = inputs.find((input) => JSON.stringify(input).includes("hello skill context"))
+        expect(promptInput).toBeDefined()
+        expect(JSON.stringify(promptInput)).toContain("project-rest-skill")
       }),
     ),
   )
diff --git a/packages/deepagent-code/test/server/httpapi-workspace-routing.test.ts b/packages/deepagent-code/test/server/httpapi-workspace-routing.test.ts
index c5981c31..b0e0ef88 100644
--- a/packages/deepagent-code/test/server/httpapi-workspace-routing.test.ts
+++ b/packages/deepagent-code/test/server/httpapi-workspace-routing.test.ts
@@ -308,7 +308,8 @@ describe("HttpApi workspace routing middleware", () => {
           { contentType: "application/json" },
         ),
         HttpClient.execute,
-        Effect.timeout("2 seconds"),
+        // Wide ceiling only: under full-suite load the proxied round-trip can exceed 2s.
+        Effect.timeout("10 seconds"),
       )
 
       expect(response.status).toBe(201)
diff --git a/packages/deepagent-code/test/server/session-diff-missing-patch.test.ts b/packages/deepagent-code/test/server/session-diff-missing-patch.test.ts
index 9ae0146c..8c0a6d71 100644
--- a/packages/deepagent-code/test/server/session-diff-missing-patch.test.ts
+++ b/packages/deepagent-code/test/server/session-diff-missing-patch.test.ts
@@ -69,7 +69,8 @@ describe("session diff with missing patch (#26574)", () => {
         expect(yield* response.json).toEqual([])
       }),
     { git: true, config: { formatter: false, lsp: false } },
-    15_000,
+    // Wide ceiling only: the full-suite load can push these server-backed diffs past 15s.
+    30_000,
   )
 
   it.instance(
@@ -100,7 +101,8 @@ describe("session diff with missing patch (#26574)", () => {
         expect(yield* response.json).toEqual([{ file: "turn.ts", additions: 1, deletions: 0, status: "modified" }])
       }),
     { git: true, config: { formatter: false, lsp: false } },
-    15_000,
+    // Wide ceiling only: the full-suite load can push these server-backed diffs past 15s.
+    30_000,
   )
 
   it.instance(
@@ -159,7 +161,8 @@ describe("session diff with missing patch (#26574)", () => {
         expect(original?.diffs[0]?.patch).toBe(patch)
       }),
     { git: true, config: { formatter: false, lsp: false } },
-    15_000,
+    // Wide ceiling only: the full-suite load can push these server-backed diffs past 15s.
+    30_000,
   )
 
   it.instance(
@@ -200,6 +203,7 @@ describe("session diff with missing patch (#26574)", () => {
         ])
       }),
     { git: true, config: { formatter: false, lsp: false } },
-    15_000,
+    // Wide ceiling only: the full-suite load can push these server-backed diffs past 15s.
+    30_000,
   )
 })
diff --git a/packages/deepagent-code/test/session/agent-handoff-consumer.test.ts b/packages/deepagent-code/test/session/agent-handoff-consumer.test.ts
index 2cc182a6..66de31e0 100644
--- a/packages/deepagent-code/test/session/agent-handoff-consumer.test.ts
+++ b/packages/deepagent-code/test/session/agent-handoff-consumer.test.ts
@@ -2,6 +2,7 @@ import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { AgentExecution } from "@deepagent-code/core/deepagent/agent-execution"
 import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
+import { HandoffAdmission } from "@deepagent-code/core/deepagent/handoff-admission"
 import { LMNEvents } from "@deepagent-code/core/deepagent/lmn-events"
 import { SecurityResolvers } from "@deepagent-code/core/deepagent/security-resolvers"
 import { TaskPartitioner } from "@deepagent-code/core/deepagent/task-partitioner"
@@ -33,7 +34,9 @@ const agents: AgentDescriptor[] = [
 
 const makeLayer = (runtimeAllowed: boolean, runLoop = false) => {
   const database = Database.layerFromPath(":memory:")
-  const core = Layer.mergeAll(DeepAgentEventBus.layer, AgentExecution.layer).pipe(Layer.provideMerge(database))
+  const core = Layer.mergeAll(DeepAgentEventBus.layer, AgentExecution.layer, HandoffAdmission.layer).pipe(
+    Layer.provideMerge(database),
+  )
   const registry = Layer.succeed(AgentListProviderService, {
     listAgents: () => Effect.succeed(agents),
     findByTrigger: () => Effect.succeed([]),
@@ -185,4 +188,109 @@ describe("AgentHandoffConsumer", () => {
       ).toBe(false)
     }),
   )
+
+  allowed.effect("writes a durable admission receipt and settles it processing → accepted", () =>
+    Effect.gen(function* () {
+      const input = yield* seed
+      const consumer = yield* AgentHandoffConsumer.Service
+      const admission = yield* HandoffAdmission.Service
+      expect(yield* consumer.handle(input.event)).toBe("accepted")
+      const receipt = yield* admission.get("handoff_1")
+      expect(receipt?.state).toBe("accepted")
+      expect(receipt?.eventID).toBe(input.event.id)
+      expect(receipt?.workspaceID).toBe(input.original.workspaceID)
+      expect(receipt?.settledAt != null).toBe(true)
+      // a redelivery short-circuits on the TERMINAL receipt: still accepted, receipt untouched.
+      expect(yield* consumer.handle(input.event)).toBe("accepted")
+      const after = yield* admission.get("handoff_1")
+      expect(after?.state).toBe("accepted")
+      expect(after?.settledAt).toBe(receipt?.settledAt)
+    }),
+  )
+
+  allowed.effect("retry pump claims due deliveries atomically — a second claimant sees nothing", () =>
+    Effect.gen(function* () {
+      const input = yield* seed
+      const bus = yield* DeepAgentEventBus.Service
+      const at = input.event.createdAt + 1
+      const first = yield* bus.claimDue({ subscriptionGroup: HANDOFF_GROUP, claimantId: "claimant_a", now: at })
+      expect(first.deliveries.map((delivery) => delivery.eventID)).toContain(input.event.id)
+      // lease live → the same row is invisible to a competing claimant (RISK-001 mutual exclusion).
+      const second = yield* bus.claimDue({ subscriptionGroup: HANDOFF_GROUP, claimantId: "claimant_b", now: at })
+      expect(second.deliveries.length).toBe(0)
+    }),
+  )
+
+  allowed.effect("ack/nack are claim-token conditioned — a stale token cannot settle the delivery", () =>
+    Effect.gen(function* () {
+      const input = yield* seed
+      const bus = yield* DeepAgentEventBus.Service
+      const at = input.event.createdAt + 1
+      const claim = yield* bus.claimDue({ subscriptionGroup: HANDOFF_GROUP, claimantId: "claimant_a", now: at })
+      expect(claim.deliveries.length).toBe(1)
+      const wrong = { subscriptionGroup: HANDOFF_GROUP, eventID: input.event.id }
+      // a stale/forged token settles nothing.
+      expect(yield* bus.ackClaim({ ...wrong, claimToken: "not-the-token" })).toBe(false)
+      expect(yield* bus.nackClaim({ ...wrong, claimToken: "not-the-token", reason: "stale" })).toBe(false)
+      // the owning token settles exactly once; afterwards the same token is stale too.
+      expect(yield* bus.ackClaim({ ...wrong, claimToken: claim.claimToken })).toBe(true)
+      expect(yield* bus.ackClaim({ ...wrong, claimToken: claim.claimToken })).toBe(false)
+      expect(yield* bus.nackClaim({ ...wrong, claimToken: claim.claimToken, reason: "after settle" })).toBe(false)
+    }),
+  )
+
+  allowed.effect("crash recovery: an expired lease re-claims and a processing receipt is re-admitted", () =>
+    Effect.gen(function* () {
+      const input = yield* seed
+      const bus = yield* DeepAgentEventBus.Service
+      const admission = yield* HandoffAdmission.Service
+      const consumer = yield* AgentHandoffConsumer.Service
+      const execution = yield* AgentExecution.Service
+      const at = input.event.createdAt + 1
+      // The crashed worker claimed the delivery AND stamped its admission `processing`, then died
+      // before settling either. Both records stay exactly as the crash left them.
+      yield* bus.claimDue({ subscriptionGroup: HANDOFF_GROUP, claimantId: "crashed_worker", now: at })
+      yield* admission.begin({
+        handoffID: "handoff_1",
+        eventID: input.event.id,
+        workspaceID: input.original.workspaceID,
+        claimantID: "crashed_worker",
+        at,
+      })
+      expect((yield* admission.get("handoff_1"))?.state).toBe("processing")
+      // While the lease is live the pump must NOT re-drive the in-flight handoff.
+      expect(yield* consumer.pumpRetries(at + 1)).toBe(0)
+      expect((yield* admission.get("handoff_1"))?.state).toBe("processing")
+      // Once the lease lapses the row is re-claimable: `processing` means "not finished", so the
+      // pump re-admits it and settles the receipt to its terminal state.
+      expect(yield* consumer.pumpRetries(at + 5 * 60_000 + 1)).toBe(1)
+      const receipt = yield* admission.get("handoff_1")
+      expect(receipt?.state).toBe("accepted")
+      expect(receipt?.claimantID !== "crashed_worker").toBe(true)
+      const transferred = yield* execution.get({
+        workspaceID: input.original.workspaceID,
+        eventID: input.original.id,
+        taskID: input.task.id,
+      })
+      expect(transferred?.status).toBe("available")
+      expect(transferred?.assignedAgentID).toBe("agent_b")
+      // the delivery was acked under the claim — nothing due remains.
+      expect(yield* consumer.pumpRetries(at + 10 * 60_000)).toBe(0)
+    }),
+  )
+
+  denied.effect("settles the admission receipt processing → rejected with the reject reason", () =>
+    Effect.gen(function* () {
+      const input = yield* seed
+      const consumer = yield* AgentHandoffConsumer.Service
+      const admission = yield* HandoffAdmission.Service
+      expect(yield* consumer.handle(input.event)).toBe("rejected")
+      const receipt = yield* admission.get("handoff_1")
+      expect(receipt?.state).toBe("rejected")
+      expect(receipt?.reason).toBe("handoff_security_runtime_operation")
+      // a terminal reject is sticky across redelivery.
+      expect(yield* consumer.handle(input.event)).toBe("rejected")
+      expect((yield* admission.get("handoff_1"))?.state).toBe("rejected")
+    }),
+  )
 })
diff --git a/packages/deepagent-code/test/session/bug-008-activity-leak.test.ts b/packages/deepagent-code/test/session/bug-008-activity-leak.test.ts
new file mode 100644
index 00000000..b5752e8e
--- /dev/null
+++ b/packages/deepagent-code/test/session/bug-008-activity-leak.test.ts
@@ -0,0 +1,565 @@
+/**
+ * BUG-008 third leak window — deterministic reproduction + regression test.
+ *
+ * Window: a turn enters `state.startRunning` (session busy) but dies BEFORE its
+ * `materializeTurn` transaction commits. During that window a concurrent
+ * `SessionSteer.admit` sees no active activity and creates a PLACEHOLDER legacy
+ * activity (trigger = the steer admission, run_now/pending intent, no run row).
+ * When the turn dies, nothing terminalizes that placeholder: the outer prompt
+ * hook has no owned run yet, and `recoverActiveActivities` deliberately skips the
+ * "run_now + pending + no run" shape. Every later admission then collides with
+ * `SessionPromptIntent.Conflict: legacy activity <id> requires recovery before a
+ * new turn` — exactly the live steer-boundary/activity-progress failure.
+ *
+ * The fix adopts the steer placeholder inside the next turn's materialization
+ * transaction (route a of BUG-008), converging on the same durable state as the
+ * healthy race ordering (turn materializes first, steer attaches as role "steer").
+ *
+ * Harness mirrors prompt.test.ts; no real LLM is ever called (TestLLMServer only).
+ * No fixture rows are inserted directly — the leaked activity is produced through
+ * the legal steer.admit lifecycle.
+ */
+import { expect } from "bun:test"
+import { Effect, Fiber, Layer } from "effect"
+import path from "path"
+import { NodeFileSystem } from "@effect/platform-node"
+import { FetchHttpClient } from "effect/unstable/http"
+import { ConfigV1 } from "@deepagent-code/core/v1/config/config"
+import { SessionV2 } from "@deepagent-code/core/session"
+import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
+import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
+import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
+import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
+import { Search } from "@deepagent-code/core/filesystem/search"
+import { FSUtil } from "@deepagent-code/core/fs-util"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { Prompt } from "@deepagent-code/core/session/prompt"
+import { SessionIntentTable, SessionSteerTable } from "@deepagent-code/core/session/sql"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { EffectFlock } from "@deepagent-code/core/util/effect-flock"
+import * as Log from "@deepagent-code/core/util/log"
+import { AgentGateway } from "@deepagent-code/core/agent-gateway"
+import { Global } from "@deepagent-code/core/global"
+import { LLMClient, RequestExecutor, WebSocketExecutor } from "@deepagent-code/llm/route"
+import { eq } from "drizzle-orm"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Agent as AgentSvc } from "../../src/agent/agent"
+import { Auth } from "../../src/auth"
+import { BackgroundJob } from "@/background/job"
+import { Command } from "../../src/command"
+import { Config } from "@/config/config"
+import { LSP } from "@/lsp/lsp"
+import { MCP } from "../../src/mcp"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import { Provider as ProviderSvc } from "@/provider/provider"
+import { Env } from "../../src/env"
+import { Git } from "../../src/git"
+import { Image } from "../../src/image/image"
+import { Question } from "../../src/question"
+import { Todo } from "../../src/session/todo"
+import { Session } from "@/session/session"
+import { LLM } from "../../src/session/llm"
+import { SessionCompaction } from "../../src/session/compaction"
+import { SessionSummary } from "../../src/session/summary"
+import { Instruction } from "../../src/session/instruction"
+import { SessionProcessor } from "../../src/session/processor"
+import { SessionPrompt } from "../../src/session/prompt"
+import { SessionRevert } from "../../src/session/revert"
+import { SessionRunState } from "../../src/session/run-state"
+import { SessionSteer } from "../../src/session/steer"
+import { SessionStatus } from "../../src/session/status"
+import { Skill } from "../../src/skill"
+import { SystemPrompt } from "../../src/session/system"
+import { Snapshot } from "../../src/snapshot"
+import { ToolRegistry } from "@/tool/registry"
+import { DebugService } from "@/debug/service"
+import { RuntimeBase } from "@/runtime/base"
+import { Truncate } from "@/tool/truncate"
+import { Format } from "../../src/format"
+import { Reference } from "../../src/reference/reference"
+import { RepositoryCache } from "../../src/reference/repository-cache"
+import { ContextFederationReadiness } from "../../src/context-federation/readiness"
+import { PromptEpoch } from "@/session/prompt-epoch"
+import {
+  SessionLegacyActivityAdmissionTable,
+  SessionLegacyActivityRunTable,
+  SessionLegacyActivityTable,
+  SessionLegacyActivityTerminalTable,
+} from "@/session/activity-sql"
+import { TestInstance, testInstanceStoreLayer } from "../fixture/fixture"
+import { TestContextFacades } from "../fixture/context-facades"
+import { awaitWithTimeout, pollWithTimeout, testEffect } from "../lib/effect"
+import { TestLLMServer } from "../lib/llm-server"
+
+void Log.init({ print: false })
+
+const summary = Layer.succeed(
+  SessionSummary.Service,
+  SessionSummary.Service.of({
+    summarize: () => Effect.void,
+    diff: () => Effect.succeed([]),
+    computeDiff: () => Effect.succeed([]),
+    computeManifest: () => Effect.succeed(SessionSummary.emptyManifest()),
+  }),
+)
+
+const mcp = Layer.succeed(
+  MCP.Service,
+  MCP.Service.of({
+    status: () => Effect.succeed({}),
+    clients: () => Effect.succeed({}),
+    tools: () => Effect.succeed({}),
+    prompts: () => Effect.succeed({}),
+    resources: () => Effect.succeed({}),
+    add: () => Effect.succeed({ status: { status: "disabled" as const } }),
+    connect: () => Effect.void,
+    disconnect: () => Effect.void,
+    getPrompt: () => Effect.succeed(undefined),
+    readResource: () => Effect.succeed(undefined),
+    startAuth: () => Effect.die("unexpected MCP auth in bug-008 leak tests"),
+    authenticate: () => Effect.die("unexpected MCP auth in bug-008 leak tests"),
+    finishAuth: () => Effect.die("unexpected MCP auth in bug-008 leak tests"),
+    removeAuth: () => Effect.void,
+    supportsOAuth: () => Effect.succeed(false),
+    hasStoredTokens: () => Effect.succeed(false),
+    getAuthStatus: () => Effect.succeed("not_authenticated" as const),
+    catalog: () => Effect.succeed([]),
+    enableCatalogEntry: () => Effect.succeed({ status: {}, name: "x", config: { type: "local", command: [] } }),
+  }),
+)
+
+const lsp = Layer.succeed(
+  LSP.Service,
+  LSP.Service.of({
+    init: () => Effect.void,
+    status: () => Effect.succeed([]),
+    hasClients: () => Effect.succeed(false),
+    touchFile: () => Effect.void,
+    diagnostics: () => Effect.succeed({}),
+    hover: () => Effect.succeed(undefined),
+    definition: () => Effect.succeed([]),
+    references: () => Effect.succeed([]),
+    implementation: () => Effect.succeed([]),
+    documentSymbol: () => Effect.succeed([]),
+    workspaceSymbol: () => Effect.succeed([]),
+    prepareCallHierarchy: () => Effect.succeed([]),
+    incomingCalls: () => Effect.succeed([]),
+    outgoingCalls: () => Effect.succeed([]),
+    typeDefinition: () => Effect.succeed([]),
+    declaration: () => Effect.succeed([]),
+    prepareTypeHierarchy: () => Effect.succeed([]),
+    supertypes: () => Effect.succeed([]),
+    subtypes: () => Effect.succeed([]),
+    inlayHint: () => Effect.succeed([]),
+    codeAction: () => Effect.succeed([]),
+    executeCommand: () => Effect.succeed(null),
+    prepareRename: () => Effect.succeed(null),
+    rename: () => Effect.succeed(null),
+    documentHighlight: () => Effect.succeed([]),
+    foldingRange: () => Effect.succeed([]),
+    selectionRange: () => Effect.succeed([]),
+    completion: () => Effect.succeed(null),
+    signatureHelp: () => Effect.succeed(null),
+    serverCapabilities: () => Effect.succeed(undefined),
+    workspaceDiagnostics: () => Effect.succeed({}),
+  }),
+)
+
+const status = SessionStatus.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer))
+const run = SessionRunState.layer.pipe(Layer.provide(status))
+const infra = Layer.mergeAll(NodeFileSystem.layer, CrossSpawnSpawner.defaultLayer)
+
+// Mirrors prompt.test.ts: no-op RuntimeBase + inert DebugService stubs so the tool
+// registry builds without the Worktree→Project→Database chain.
+const stubRuntimeBaseLayer = Layer.succeed(
+  RuntimeBase.Service,
+  RuntimeBase.Service.of({
+    gate: () => Effect.void,
+    withIsolation: (_input, body) => body(""),
+    checkPrivileges: () => Effect.succeed([]),
+  }),
+)
+const debugStubDie = <A>(): Effect.Effect<A, never, never> =>
+  Effect.die("DebugService stub (not used in bug-008 leak tests)")
+const stubDebugServiceLayer = Layer.succeed(
+  DebugService.Service,
+  DebugService.Service.of({
+    start: debugStubDie,
+    setBreakpoints: debugStubDie,
+    continue: debugStubDie,
+    step: debugStubDie,
+    stackTrace: debugStubDie,
+    scopes: debugStubDie,
+    variables: debugStubDie,
+    evaluate: debugStubDie,
+    terminate: debugStubDie,
+    get: () => Effect.succeed(undefined),
+    list: () => Effect.succeed([]),
+  }),
+)
+
+const testLLMLayer = (runtimeFlags: Layer.Layer<RuntimeFlags.Service>) =>
+  LLM.layer.pipe(
+    Layer.provide(Auth.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(ProviderSvc.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(
+      Layer.mergeAll(
+        AgentGateway.layer({ enabled: true, runsDir: Global.Path.agent.runs }),
+        LLMClient.layer.pipe(Layer.provide(Layer.mergeAll(RequestExecutor.defaultLayer, WebSocketExecutor.layer))),
+      ),
+    ),
+    Layer.provide(runtimeFlags),
+  )
+
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Apply it over the tracked history
+// so compaction_run carries the mode columns the drizzle schema already declares.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
+function makePrompt() {
+  const runtimeFlags = RuntimeFlags.layer({
+    experimentalEventSystem: true,
+    coreV2ExecutionOwner: false,
+  })
+  const deps = Layer.mergeAll(
+    Session.defaultLayer,
+    Snapshot.defaultLayer,
+    testLLMLayer(runtimeFlags),
+    Env.defaultLayer,
+    AgentSvc.defaultLayer,
+    Command.defaultLayer,
+    Permission.defaultLayer,
+    Plugin.defaultLayer,
+    Config.defaultLayer,
+    Auth.defaultLayer,
+    ProviderSvc.defaultLayer,
+    lsp,
+    mcp,
+    FSUtil.defaultLayer,
+    BackgroundJob.defaultLayer,
+    status,
+    database,
+    EventV2Bridge.defaultLayer,
+    PromptEpoch.defaultLayer,
+  ).pipe(Layer.provideMerge(infra))
+  const question = Question.layer.pipe(Layer.provideMerge(deps))
+  const todo = Todo.layer.pipe(Layer.provideMerge(deps))
+  const registry = ToolRegistry.layer.pipe(
+    Layer.provide(TestContextFacades.layer),
+    Layer.provide(Skill.defaultLayer),
+    Layer.provide(FetchHttpClient.layer),
+    Layer.provide(CrossSpawnSpawner.defaultLayer),
+    Layer.provide(RepositoryCache.defaultLayer),
+    Layer.provide(Git.defaultLayer),
+    Layer.provide(EffectFlock.defaultLayer),
+    Layer.provide(Reference.defaultLayer),
+    Layer.provide(Search.defaultLayer),
+    Layer.provide(Format.defaultLayer),
+    Layer.provide(runtimeFlags),
+    Layer.provide(stubDebugServiceLayer),
+    Layer.provide(stubRuntimeBaseLayer),
+    Layer.provideMerge(todo),
+    Layer.provideMerge(question),
+    Layer.provideMerge(deps),
+  )
+  const trunc = Truncate.layer.pipe(Layer.provideMerge(deps))
+  const proc = SessionProcessor.layer.pipe(
+    Layer.provide(summary),
+    Layer.provide(Image.defaultLayer),
+    Layer.provide(runtimeFlags),
+    Layer.provideMerge(deps),
+  )
+  const compact = SessionCompaction.layer.pipe(
+    Layer.provide(runtimeFlags),
+    Layer.provide(RequestExecutor.defaultLayer),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(deps),
+  )
+  const steer = SessionSteer.layer.pipe(Layer.provideMerge(deps))
+  return SessionPrompt.layer.pipe(
+    Layer.provide(SessionV2.defaultLayer),
+    Layer.provide(SessionProviderOwner.layer.pipe(Layer.provide(deps))),
+    Layer.provide(testInstanceStoreLayer),
+    Layer.provide(SessionRevert.defaultLayer),
+    Layer.provide(Image.defaultLayer),
+    Layer.provide(Reference.defaultLayer),
+    Layer.provide(summary),
+    Layer.provideMerge(steer),
+    Layer.provideMerge(run),
+    Layer.provideMerge(compact),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(registry),
+    Layer.provideMerge(trunc),
+    Layer.provide(Instruction.defaultLayer),
+    Layer.provide(SystemPrompt.defaultLayer),
+    Layer.provide(LocationIdentity.layer.pipe(Layer.provide(deps))),
+    Layer.provide(
+      Layer.succeed(
+        ContextFederationReadiness.Service,
+        ContextFederationReadiness.Service.of({
+          snapshot: () => Effect.succeed(ContextFederationRollout.READINESS_READY_STUB),
+        }),
+      ),
+    ),
+    Layer.provide(runtimeFlags),
+    Layer.provideMerge(deps),
+    Layer.provide(summary),
+  )
+}
+
+const it = testEffect(Layer.mergeAll(TestLLMServer.layer, makePrompt()))
+
+const cfg = {
+  provider: {
+    test: {
+      name: "Test",
+      id: "test",
+      env: [],
+      npm: "@ai-sdk/openai-compatible",
+      models: {
+        "test-model": {
+          id: "test-model",
+          name: "Test Model",
+          attachment: false,
+          reasoning: false,
+          temperature: false,
+          tool_call: true,
+          release_date: "2025-01-01",
+          limit: { context: 100000, output: 10000 },
+          cost: { input: 0, output: 0 },
+          options: {},
+        },
+      },
+      options: {
+        apiKey: "test-key",
+        baseURL: "http://localhost:1/v1",
+        maxRetries: 0,
+      },
+    },
+  },
+}
+
+function providerCfg(url: string) {
+  return {
+    ...cfg,
+    provider: {
+      ...cfg.provider,
+      test: {
+        ...cfg.provider.test,
+        options: {
+          ...cfg.provider.test.options,
+          baseURL: url,
+        },
+      },
+    },
+  }
+}
+
+const writeText = Effect.fn("test.writeText")(function* (file: string, text: string) {
+  const fs = yield* FSUtil.Service
+  yield* fs.writeWithDirs(file, text)
+})
+
+const writeConfig = Effect.fn("test.writeConfig")(function* (dir: string, config: Partial<ConfigV1.Info>) {
+  yield* writeText(
+    path.join(dir, "deepagent-code.json"),
+    JSON.stringify({ $schema: "https://deepagent-code.ai/config.json", ...config }),
+  )
+})
+
+const useServerConfig = Effect.fn("test.useServerConfig")(function* (config: (url: string) => Partial<ConfigV1.Info>) {
+  const { directory: dir } = yield* TestInstance
+  const llm = yield* TestLLMServer
+  yield* writeConfig(dir, config(llm.url))
+  return { dir, llm }
+})
+
+it.instance(
+  "BUG-008 third window: next turn adopts the steer-placeholder activity left by a turn that died before materialization",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const steer = yield* SessionSteer.Service
+      const sessions = yield* Session.Service
+      const runState = yield* SessionRunState.Service
+      const { db } = yield* Database.Service
+      const session = yield* sessions.create({ title: "BUG-008 third window" })
+      const marker = path.join(dir, "bug008-coordinator-reserve.json")
+      const previousPoint = process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_POINT
+      const previousRoot = process.env.DEEPAGENT_CODE_TEST_ROOT
+      const previousMarker = process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_MARKER
+
+      // Phase 1: the first turn dies INSIDE the third window — after the session
+      // went busy, before its materializeTurn transaction committed. While it is
+      // parked at the crash point, a concurrent steer.admit creates the
+      // placeholder activity (no active activity exists yet).
+      const placeholderID = yield* Effect.acquireUseRelease(
+        Effect.sync(() => {
+          process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_POINT = "after_coordinator_reserve"
+          process.env.DEEPAGENT_CODE_TEST_ROOT = dir
+          process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_MARKER = marker
+        }),
+        () =>
+          Effect.gen(function* () {
+            const running = yield* prompt
+              .prompt({
+                sessionID: session.id,
+                agent: "build",
+                parts: [{ type: "text", text: "First turn dies before materialization" }],
+              })
+              .pipe(Effect.forkChild)
+            yield* pollWithTimeout(
+              Effect.promise(async () => ((await Bun.file(marker).exists()) ? true : undefined)),
+              "timed out waiting for the turn to reach the coordinator reserve crash point",
+            )
+            expect(yield* runState.isBusy(session.id)).toBe(true)
+            // Turn is parked BEFORE admit: no activity row exists yet.
+            expect(yield* db.select().from(SessionLegacyActivityTable).all().pipe(Effect.orDie)).toHaveLength(0)
+
+            // Concurrent steer while the turn is busy: steer.admit sees no active
+            // activity and creates the placeholder (trigger = steer admission).
+            yield* steer.admit({
+              sessionID: session.id,
+              prompt: new Prompt({ text: "STEER PLACEHOLDER FOR BUG-008" }),
+            })
+            const placeholder = yield* db
+              .select()
+              .from(SessionLegacyActivityTable)
+              .where(eq(SessionLegacyActivityTable.session_id, session.id))
+              .get()
+              .pipe(Effect.orDie)
+            expect(placeholder).toMatchObject({ state: "active" })
+            if (!placeholder) return yield* Effect.die("placeholder activity missing")
+
+            // Simulate the in-window death (instance dispose): kill the parked
+            // turn before it ever materializes. The outer prompt hook has no
+            // owned run yet, so nothing terminalizes the placeholder.
+            yield* awaitWithTimeout(prompt.cancel(session.id), "timed out cancelling the parked turn", "5 seconds")
+            yield* awaitWithTimeout(Fiber.await(running), "timed out joining the canceled parked turn", "5 seconds")
+            expect(yield* runState.isBusy(session.id)).toBe(false)
+
+            // The leak: placeholder stays active with no run row; recovery skips
+            // the run_now/pending/no-run shape, so it can never self-heal.
+            expect(
+              yield* db
+                .select()
+                .from(SessionLegacyActivityTable)
+                .where(eq(SessionLegacyActivityTable.session_id, session.id))
+                .all()
+                .pipe(Effect.orDie),
+            ).toMatchObject([{ state: "active", terminal_reason: null }])
+            expect(
+              yield* db
+                .select()
+                .from(SessionLegacyActivityRunTable)
+                .where(eq(SessionLegacyActivityRunTable.session_id, session.id))
+                .all()
+                .pipe(Effect.orDie),
+            ).toHaveLength(0)
+            return placeholder.activity_id
+          }),
+        () =>
+          Effect.sync(() => {
+            if (previousPoint === undefined) delete process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_POINT
+            else process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_POINT = previousPoint
+            if (previousRoot === undefined) delete process.env.DEEPAGENT_CODE_TEST_ROOT
+            else process.env.DEEPAGENT_CODE_TEST_ROOT = previousRoot
+            if (previousMarker === undefined) delete process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_MARKER
+            else process.env.DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_MARKER = previousMarker
+          }),
+      )
+
+      // Phase 2: the next prompt must NOT collide with the leaked placeholder.
+      // Pre-fix this fails with `SessionPromptIntent.Conflict: legacy activity
+      // <id> requires recovery before a new turn`; post-fix the turn adopts the
+      // placeholder and completes.
+      yield* llm.text("placeholder adopted and completed")
+      yield* llm.text("placeholder adopted and completed")
+      const next = yield* awaitWithTimeout(
+        prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "Second turn after the in-window death" }],
+        }),
+        "timed out running the prompt after the leaked placeholder",
+        "15 seconds",
+      )
+      expect(next.parts.some((part) => part.type === "text" && part.text === "placeholder adopted and completed")).toBe(
+        true,
+      )
+
+      // Adoption converges on EXACTLY the healthy race ordering's durable
+      // state: ONE settled activity (the placeholder was undone, never
+      // duplicated), turn membership ordinal 0 + re-attached steer ordinal 1.
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTable)
+          .where(eq(SessionLegacyActivityTable.session_id, session.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toMatchObject([{ state: "settled" }])
+      const adopted = yield* db
+        .select()
+        .from(SessionLegacyActivityTable)
+        .where(eq(SessionLegacyActivityTable.session_id, session.id))
+        .get()
+        .pipe(Effect.orDie)
+      expect(adopted).toBeTruthy()
+      if (!adopted) return
+      expect(adopted.activity_id).not.toBe(placeholderID)
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityAdmissionTable)
+          .where(eq(SessionLegacyActivityAdmissionTable.activity_id, adopted.activity_id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toMatchObject([
+        { ordinal: 0, role: "trigger" },
+        { ordinal: 1, role: "steer" },
+      ])
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityRunTable)
+          .where(eq(SessionLegacyActivityRunTable.session_id, session.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toMatchObject([{ activity_id: adopted.activity_id, state: "completed" }])
+      // The orphaned steer was absorbed by the adopting turn, never lost.
+      expect(
+        yield* db
+          .select()
+          .from(SessionSteerTable)
+          .where(eq(SessionSteerTable.session_id, session.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toMatchObject([{ consumed_seq: expect.any(Number) }])
+      expect(
+        (yield* db
+          .select({ state: SessionIntentTable.execution_state })
+          .from(SessionIntentTable)
+          .where(eq(SessionIntentTable.delivery, "steer"))
+          .all()
+          .pipe(Effect.orDie)).every((intent) => intent.state !== "pending"),
+      ).toBe(true)
+    }),
+  { git: true },
+  30_000,
+)
diff --git a/packages/deepagent-code/test/session/bug-407-008-runtime.test.ts b/packages/deepagent-code/test/session/bug-407-008-runtime.test.ts
new file mode 100644
index 00000000..8a98d5ae
--- /dev/null
+++ b/packages/deepagent-code/test/session/bug-407-008-runtime.test.ts
@@ -0,0 +1,1745 @@
+/**
+ * BUG-407-008 §7.1 — runtime & read-projection deterministic regressions (#1-#17, #5 lives in
+ * prompt.test.ts). The computed `activityProgress` marker must always be derived on read from the
+ * durable progress/activity authority (session_activity_progress ⋈ session_legacy_activity), never
+ * persisted into message JSON, and crash/recovery paths must upgrade it monotonically without ever
+ * fabricating receipts, messages, revisions or provider invocations.
+ *
+ * Harness mirrors bug-008-activity-leak.test.ts (same layer stack, TestLLMServer only). Crash
+ * injection reuses src/session/activity-crash-test.ts via the DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_*
+ * env vars; the P1/P2/P6 points were added there + instrumented minimally in prompt.ts.
+ * No authority-table rows are ever inserted directly — everything is driven through the real state
+ * machine (prompt.prompt / TestLLMServer / cancel / recovery callers).
+ */
+import { expect, test } from "bun:test"
+import { Database as BunSQLite } from "bun:sqlite"
+import { existsSync } from "node:fs"
+import os from "node:os"
+import { Effect, Fiber, Layer } from "effect"
+import path from "path"
+import { NodeFileSystem } from "@effect/platform-node"
+import { FetchHttpClient } from "effect/unstable/http"
+import { ConfigV1 } from "@deepagent-code/core/v1/config/config"
+import { SessionV2 } from "@deepagent-code/core/session"
+import { SessionV1 } from "@deepagent-code/core/v1/session"
+import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
+import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
+import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
+import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
+import { Search } from "@deepagent-code/core/filesystem/search"
+import { FSUtil } from "@deepagent-code/core/fs-util"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { Prompt } from "@deepagent-code/core/session/prompt"
+import { MessageTable } from "@deepagent-code/core/session/sql"
+import { EventTable } from "@deepagent-code/core/event/sql"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { EffectFlock } from "@deepagent-code/core/util/effect-flock"
+import * as Log from "@deepagent-code/core/util/log"
+import { AgentGateway } from "@deepagent-code/core/agent-gateway"
+import { Global } from "@deepagent-code/core/global"
+import { LLMClient, RequestExecutor, WebSocketExecutor } from "@deepagent-code/llm/route"
+import { and, asc, eq } from "drizzle-orm"
+import { MessageID, SessionID } from "@/session/schema"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Agent as AgentSvc } from "../../src/agent/agent"
+import { Auth } from "../../src/auth"
+import { BackgroundJob } from "@/background/job"
+import { Command } from "../../src/command"
+import { Config } from "@/config/config"
+import { LSP } from "@/lsp/lsp"
+import { MCP } from "../../src/mcp"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import { Provider as ProviderSvc } from "@/provider/provider"
+import { Env } from "../../src/env"
+import { Git } from "../../src/git"
+import { Image } from "../../src/image/image"
+import { Question } from "../../src/question"
+import { Todo } from "../../src/session/todo"
+import { Session } from "@/session/session"
+import { LLM } from "../../src/session/llm"
+import { SessionCompaction } from "../../src/session/compaction"
+import { SessionSummary } from "../../src/session/summary"
+import { Instruction } from "../../src/session/instruction"
+import { SessionProcessor } from "../../src/session/processor"
+import { SessionPrompt } from "../../src/session/prompt"
+import { SessionPromptIntent } from "../../src/session/prompt-intent"
+import { SessionRevert } from "../../src/session/revert"
+import { SessionRunState } from "../../src/session/run-state"
+import { SessionSteer } from "../../src/session/steer"
+import { SessionStatus } from "../../src/session/status"
+import { Skill } from "../../src/skill"
+import { SystemPrompt } from "../../src/session/system"
+import { Snapshot } from "../../src/snapshot"
+import { ToolRegistry } from "@/tool/registry"
+import { DebugService } from "@/debug/service"
+import { RuntimeBase } from "@/runtime/base"
+import { Truncate } from "@/tool/truncate"
+import { Format } from "../../src/format"
+import { Reference } from "../../src/reference/reference"
+import { RepositoryCache } from "../../src/reference/repository-cache"
+import { ContextFederationReadiness } from "../../src/context-federation/readiness"
+import { PromptEpoch } from "@/session/prompt-epoch"
+import { MessageV2 } from "@/session/message-v2"
+import {
+  SessionActivityProgressTable,
+  SessionLegacyActivityAdmissionTable,
+  SessionLegacyActivityRunTable,
+  SessionLegacyActivityTable,
+  SessionLegacyActivityTerminalTable,
+} from "@/session/activity-sql"
+import { SessionToolRequestReceiptTable } from "@/session/tool-request-receipt.sql"
+import type { Point as ActivityCrashPoint } from "../../src/session/activity-crash-test"
+import { TestInstance, testInstanceStoreLayer } from "../fixture/fixture"
+import { TestContextFacades } from "../fixture/context-facades"
+import { awaitWithTimeout, pollWithTimeout, testEffect } from "../lib/effect"
+import { TestLLMServer, reply } from "../lib/llm-server"
+
+void Log.init({ print: false })
+
+void ProviderV2
+void ModelV2
+
+const summary = Layer.succeed(
+  SessionSummary.Service,
+  SessionSummary.Service.of({
+    summarize: () => Effect.void,
+    diff: () => Effect.succeed([]),
+    computeDiff: () => Effect.succeed([]),
+    computeManifest: () => Effect.succeed(SessionSummary.emptyManifest()),
+  }),
+)
+
+const mcp = Layer.succeed(
+  MCP.Service,
+  MCP.Service.of({
+    status: () => Effect.succeed({}),
+    clients: () => Effect.succeed({}),
+    tools: () => Effect.succeed({}),
+    prompts: () => Effect.succeed({}),
+    resources: () => Effect.succeed({}),
+    add: () => Effect.succeed({ status: { status: "disabled" as const } }),
+    connect: () => Effect.void,
+    disconnect: () => Effect.void,
+    getPrompt: () => Effect.succeed(undefined),
+    readResource: () => Effect.succeed(undefined),
+    startAuth: () => Effect.die("unexpected MCP auth in bug-407-008 runtime tests"),
+    authenticate: () => Effect.die("unexpected MCP auth in bug-407-008 runtime tests"),
+    finishAuth: () => Effect.die("unexpected MCP auth in bug-407-008 runtime tests"),
+    removeAuth: () => Effect.void,
+    supportsOAuth: () => Effect.succeed(false),
+    hasStoredTokens: () => Effect.succeed(false),
+    getAuthStatus: () => Effect.succeed("not_authenticated" as const),
+    catalog: () => Effect.succeed([]),
+    enableCatalogEntry: () => Effect.succeed({ status: {}, name: "x", config: { type: "local", command: [] } }),
+  }),
+)
+
+const lsp = Layer.succeed(
+  LSP.Service,
+  LSP.Service.of({
+    init: () => Effect.void,
+    status: () => Effect.succeed([]),
+    hasClients: () => Effect.succeed(false),
+    touchFile: () => Effect.void,
+    diagnostics: () => Effect.succeed({}),
+    hover: () => Effect.succeed(undefined),
+    definition: () => Effect.succeed([]),
+    references: () => Effect.succeed([]),
+    implementation: () => Effect.succeed([]),
+    documentSymbol: () => Effect.succeed([]),
+    workspaceSymbol: () => Effect.succeed([]),
+    prepareCallHierarchy: () => Effect.succeed([]),
+    incomingCalls: () => Effect.succeed([]),
+    outgoingCalls: () => Effect.succeed([]),
+    typeDefinition: () => Effect.succeed([]),
+    declaration: () => Effect.succeed([]),
+    prepareTypeHierarchy: () => Effect.succeed([]),
+    supertypes: () => Effect.succeed([]),
+    subtypes: () => Effect.succeed([]),
+    inlayHint: () => Effect.succeed([]),
+    codeAction: () => Effect.succeed([]),
+    executeCommand: () => Effect.succeed(null),
+    prepareRename: () => Effect.succeed(null),
+    rename: () => Effect.succeed(null),
+    documentHighlight: () => Effect.succeed([]),
+    foldingRange: () => Effect.succeed([]),
+    selectionRange: () => Effect.succeed([]),
+    completion: () => Effect.succeed(null),
+    signatureHelp: () => Effect.succeed(null),
+    serverCapabilities: () => Effect.succeed(undefined),
+    workspaceDiagnostics: () => Effect.succeed({}),
+  }),
+)
+
+const status = SessionStatus.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer))
+const run = SessionRunState.layer.pipe(Layer.provide(status))
+const infra = Layer.mergeAll(NodeFileSystem.layer, CrossSpawnSpawner.defaultLayer)
+
+const stubRuntimeBaseLayer = Layer.succeed(
+  RuntimeBase.Service,
+  RuntimeBase.Service.of({
+    gate: () => Effect.void,
+    withIsolation: (_input, body) => body(""),
+    checkPrivileges: () => Effect.succeed([]),
+  }),
+)
+const debugStubDie = <A>(): Effect.Effect<A, never, never> =>
+  Effect.die("DebugService stub (not used in bug-407-008 runtime tests)")
+const stubDebugServiceLayer = Layer.succeed(
+  DebugService.Service,
+  DebugService.Service.of({
+    start: debugStubDie,
+    setBreakpoints: debugStubDie,
+    continue: debugStubDie,
+    step: debugStubDie,
+    stackTrace: debugStubDie,
+    scopes: debugStubDie,
+    variables: debugStubDie,
+    evaluate: debugStubDie,
+    terminate: debugStubDie,
+    get: () => Effect.succeed(undefined),
+    list: () => Effect.succeed([]),
+  }),
+)
+
+const testLLMLayer = (runtimeFlags: Layer.Layer<RuntimeFlags.Service>) =>
+  LLM.layer.pipe(
+    Layer.provide(Auth.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(ProviderSvc.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(
+      Layer.mergeAll(
+        AgentGateway.layer({ enabled: true, runsDir: Global.Path.agent.runs }),
+        LLMClient.layer.pipe(Layer.provide(Layer.mergeAll(RequestExecutor.defaultLayer, WebSocketExecutor.layer))),
+      ),
+    ),
+    Layer.provide(runtimeFlags),
+  )
+
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Apply it over the tracked history
+// so compaction_run carries the mode columns the drizzle schema already declares.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
+function makePrompt() {
+  const runtimeFlags = RuntimeFlags.layer({
+    experimentalEventSystem: true,
+    coreV2ExecutionOwner: false,
+  })
+  const deps = Layer.mergeAll(
+    Session.defaultLayer,
+    Snapshot.defaultLayer,
+    testLLMLayer(runtimeFlags),
+    Env.defaultLayer,
+    AgentSvc.defaultLayer,
+    Command.defaultLayer,
+    Permission.defaultLayer,
+    Plugin.defaultLayer,
+    Config.defaultLayer,
+    Auth.defaultLayer,
+    ProviderSvc.defaultLayer,
+    lsp,
+    mcp,
+    FSUtil.defaultLayer,
+    BackgroundJob.defaultLayer,
+    status,
+    database,
+    EventV2Bridge.defaultLayer,
+    PromptEpoch.defaultLayer,
+  ).pipe(Layer.provideMerge(infra))
+  const question = Question.layer.pipe(Layer.provideMerge(deps))
+  const todo = Todo.layer.pipe(Layer.provideMerge(deps))
+  const registry = ToolRegistry.layer.pipe(
+    Layer.provide(TestContextFacades.layer),
+    Layer.provide(Skill.defaultLayer),
+    Layer.provide(FetchHttpClient.layer),
+    Layer.provide(CrossSpawnSpawner.defaultLayer),
+    Layer.provide(RepositoryCache.defaultLayer),
+    Layer.provide(Git.defaultLayer),
+    Layer.provide(EffectFlock.defaultLayer),
+    Layer.provide(Reference.defaultLayer),
+    Layer.provide(Search.defaultLayer),
+    Layer.provide(Format.defaultLayer),
+    Layer.provide(runtimeFlags),
+    Layer.provide(stubDebugServiceLayer),
+    Layer.provide(stubRuntimeBaseLayer),
+    Layer.provideMerge(todo),
+    Layer.provideMerge(question),
+    Layer.provideMerge(deps),
+  )
+  const trunc = Truncate.layer.pipe(Layer.provideMerge(deps))
+  const proc = SessionProcessor.layer.pipe(
+    Layer.provide(summary),
+    Layer.provide(Image.defaultLayer),
+    Layer.provide(runtimeFlags),
+    Layer.provideMerge(deps),
+  )
+  const compact = SessionCompaction.layer.pipe(
+    Layer.provide(runtimeFlags),
+    Layer.provide(RequestExecutor.defaultLayer),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(deps),
+  )
+  const steer = SessionSteer.layer.pipe(Layer.provideMerge(deps))
+  return SessionPrompt.layer.pipe(
+    Layer.provide(SessionV2.defaultLayer),
+    Layer.provide(SessionProviderOwner.layer.pipe(Layer.provide(deps))),
+    Layer.provide(testInstanceStoreLayer),
+    Layer.provide(SessionRevert.defaultLayer),
+    Layer.provide(Image.defaultLayer),
+    Layer.provide(Reference.defaultLayer),
+    Layer.provide(summary),
+    Layer.provideMerge(steer),
+    Layer.provideMerge(run),
+    Layer.provideMerge(compact),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(registry),
+    Layer.provideMerge(trunc),
+    Layer.provide(Instruction.defaultLayer),
+    Layer.provide(SystemPrompt.defaultLayer),
+    Layer.provide(LocationIdentity.layer.pipe(Layer.provide(deps))),
+    Layer.provide(
+      Layer.succeed(
+        ContextFederationReadiness.Service,
+        ContextFederationReadiness.Service.of({
+          snapshot: () => Effect.succeed(ContextFederationRollout.READINESS_READY_STUB),
+        }),
+      ),
+    ),
+    Layer.provide(runtimeFlags),
+    Layer.provideMerge(deps),
+    Layer.provide(summary),
+  )
+}
+
+const it = testEffect(Layer.mergeAll(TestLLMServer.layer, makePrompt()))
+
+const cfg = {
+  provider: {
+    test: {
+      name: "Test",
+      id: "test",
+      env: [],
+      npm: "@ai-sdk/openai-compatible",
+      models: {
+        "test-model": {
+          id: "test-model",
+          name: "Test Model",
+          attachment: false,
+          reasoning: false,
+          temperature: false,
+          tool_call: true,
+          release_date: "2025-01-01",
+          limit: { context: 100000, output: 10000 },
+          cost: { input: 0, output: 0 },
+          options: {},
+        },
+      },
+      options: {
+        apiKey: "test-key",
+        baseURL: "http://localhost:1/v1",
+        maxRetries: 0,
+      },
+    },
+  },
+}
+
+function providerCfg(url: string) {
+  return {
+    ...cfg,
+    provider: {
+      ...cfg.provider,
+      test: {
+        ...cfg.provider.test,
+        options: {
+          ...cfg.provider.test.options,
+          baseURL: url,
+        },
+      },
+    },
+  }
+}
+
+const writeText = Effect.fn("test.writeText")(function* (file: string, text: string) {
+  const fs = yield* FSUtil.Service
+  yield* fs.writeWithDirs(file, text)
+})
+
+const writeConfig = Effect.fn("test.writeConfig")(function* (dir: string, config: Partial<ConfigV1.Info>) {
+  yield* writeText(
+    path.join(dir, "deepagent-code.json"),
+    JSON.stringify({ $schema: "https://deepagent-code.ai/config.json", ...config }),
+  )
+})
+
+const useServerConfig = Effect.fn("test.useServerConfig")(function* (config: (url: string) => Partial<ConfigV1.Info>) {
+  const { directory: dir } = yield* TestInstance
+  const llm = yield* TestLLMServer
+  yield* writeConfig(dir, config(llm.url))
+  return { dir, llm }
+})
+
+const allowAll = [{ permission: "*", pattern: "*", action: "allow" }] as const
+
+// ---------------------------------------------------------------------------
+// crash-env helpers (mirrors bug-008's acquireUseRelease env handling)
+// ---------------------------------------------------------------------------
+const CRASH_ENV = {
+  point: "DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_POINT",
+  root: "DEEPAGENT_CODE_TEST_ROOT",
+  marker: "DEEPAGENT_CODE_TEST_ACTIVITY_CRASH_MARKER",
+} as const
+
+function setCrashEnv(point: ActivityCrashPoint, dir: string, marker: string) {
+  const prev = {
+    point: process.env[CRASH_ENV.point],
+    root: process.env[CRASH_ENV.root],
+    marker: process.env[CRASH_ENV.marker],
+  }
+  process.env[CRASH_ENV.point] = point
+  process.env[CRASH_ENV.root] = dir
+  process.env[CRASH_ENV.marker] = marker
+  return prev
+}
+
+function restoreCrashEnv(prev: ReturnType<typeof setCrashEnv>) {
+  const apply = (key: string, value: string | undefined) => {
+    if (value === undefined) delete process.env[key]
+    else process.env[key] = value
+  }
+  apply(CRASH_ENV.point, prev.point)
+  apply(CRASH_ENV.root, prev.root)
+  apply(CRASH_ENV.marker, prev.marker)
+}
+
+const crashScoped = <A, E, R>(
+  input: { dir: string; point: ActivityCrashPoint; marker: string },
+  body: Effect.Effect<A, E, R>,
+) =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => setCrashEnv(input.point, input.dir, input.marker)),
+    () => body,
+    (prev) => Effect.sync(() => restoreCrashEnv(prev)),
+  )
+
+const waitMarker = (marker: string, what: string) =>
+  pollWithTimeout(
+    Effect.promise(async () => ((await Bun.file(marker).exists()) ? true : undefined)),
+    what,
+    "15 seconds",
+  )
+
+// ---------------------------------------------------------------------------
+// read-side helpers
+// ---------------------------------------------------------------------------
+type MessageUpdatedPayload = {
+  sessionID?: string
+  info?: { id?: string; activityProgress?: SessionV1.ActivityProgress }
+}
+
+const messageUpdatedEvents = (db: Database.Interface["db"], sessionID: string) =>
+  db
+    .select()
+    .from(EventTable)
+    .where(and(eq(EventTable.aggregate_id, sessionID), eq(EventTable.type, "message.updated.1")))
+    .orderBy(asc(EventTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+
+const eventsForMessage = (rows: { data: Record<string, unknown> }[], messageID: string) =>
+  rows.filter((row) => (row.data as MessageUpdatedPayload).info?.id === messageID)
+
+const markerEventsForMessage = (rows: { data: Record<string, unknown> }[], messageID: string) =>
+  eventsForMessage(rows, messageID).filter((row) => (row.data as MessageUpdatedPayload).info?.activityProgress)
+
+const markerOf = (info: SessionV1.Info) => (info.role === "assistant" ? info.activityProgress : undefined)
+
+const progressRows = (db: Database.Interface["db"], activityID: string) =>
+  db
+    .select()
+    .from(SessionActivityProgressTable)
+    .where(eq(SessionActivityProgressTable.activity_id, activityID))
+    .orderBy(asc(SessionActivityProgressTable.revision))
+    .all()
+    .pipe(Effect.orDie)
+
+const activityForSession = (db: Database.Interface["db"], sessionID: string) =>
+  db
+    .select()
+    .from(SessionLegacyActivityTable)
+    .where(eq(SessionLegacyActivityTable.session_id, sessionID))
+    .all()
+    .pipe(Effect.orDie)
+
+const dbProvide = <A, E>(effect: Effect.Effect<A, E, Database.Service>) =>
+  Effect.gen(function* () {
+    const database = yield* Database.Service
+    return yield* effect.pipe(Effect.provideService(Database.Service, database))
+  })
+
+// ---------------------------------------------------------------------------
+// §7.1 #1 — reasoning+tool without text: settlement only writes the progress
+// authority; hydrate computes the marker; text_part_id stays NULL.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #1: reasoning+tool turn settles only the progress authority with NULL text_part_id",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "reasoning+tool settlement", permission: allowAll })
+
+      yield* llm.push(
+        reply()
+          .reason("checking the workspace first")
+          .tool("bash", { command: "echo bug-407-008", description: "emit marker", workdir: path.resolve(dir) }),
+      )
+      yield* llm.text("turn complete")
+      yield* awaitWithTimeout(
+        prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "reason then call a tool, no text before the tool" }],
+        }),
+        "timed out running the reasoning+tool turn",
+        "20 seconds",
+      )
+
+      const msgs = yield* sessions.messages({ sessionID: session.id })
+      const toolAssistant = msgs.find(
+        (message) => message.info.role === "assistant" && message.parts.some((part) => part.type === "tool"),
+      )
+      expect(toolAssistant).toBeDefined()
+      if (!toolAssistant) return
+      // The reasoning+tool assistant message carries NO text part of its own.
+      expect(toolAssistant.parts.some((part) => part.type === "text")).toBe(false)
+
+      const activities = yield* activityForSession(db, session.id)
+      expect(activities).toHaveLength(1)
+      const activity = activities[0]!
+      const rows = yield* progressRows(db, activity.activity_id)
+      // Settlement only wrote the progress authority: rev 0 (reason+tool) has text_part_id NULL,
+      // rev 1 (closing text) carries the text part.
+      expect(rows).toHaveLength(2)
+      expect(rows[0]).toMatchObject({
+        assistant_message_id: toolAssistant.info.id,
+        revision: 0,
+        state: "progress",
+        text_part_id: null,
+      })
+      expect(rows[1]).toMatchObject({ revision: 1, state: "final" })
+      expect(rows[1]!.text_part_id).not.toBeNull()
+
+      // The marker was never persisted into message JSON ...
+      const stored = yield* db
+        .select({ id: MessageTable.id, data: MessageTable.data })
+        .from(MessageTable)
+        .where(eq(MessageTable.session_id, session.id))
+        .all()
+        .pipe(Effect.orDie)
+      for (const row of stored) expect(row.data).not.toHaveProperty("activityProgress")
+
+      // ... yet hydrate returns the computed projection.
+      const hydrated = yield* MessageV2.get({ sessionID: session.id, messageID: toolAssistant.info.id }).pipe(
+        Effect.provideService(Database.Service, database),
+      )
+      expect(markerOf(hydrated.info)).toMatchObject({ activityID: activity.activity_id, revision: 0, state: "progress" })
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #2 — beginProgress committed, provider not dispatched yet: the owning
+// message projects `provisional` immediately (no wait for the first
+// text/reasoning part) and supersedes the activity's older progress revision.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #2: provisional projection appears before provider dispatch without waiting for parts",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "provisional before dispatch", permission: allowAll })
+      const marker = path.join(dir, "bug407008-p2-dispatch.json")
+
+      yield* llm.push(
+        reply()
+          .reason("step one")
+          .tool("bash", { command: "sleep 1; echo step-one", description: "slow tool", workdir: path.resolve(dir) }),
+      )
+      yield* llm.text("second response must never be dispatched")
+      const baselineCalls = yield* llm.calls
+      const running = yield* prompt
+        .prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "two provider requests in one activity" }],
+        })
+        .pipe(Effect.forkChild)
+
+      // Arm P2 only AFTER revision 0 settled to "progress": the second request's beginProgress
+      // happens strictly after the bash tool finishes, so the env flip cannot be missed and the
+      // first request's dispatch already happened.
+      yield* Effect.acquireUseRelease(
+        pollWithTimeout(
+          Effect.gen(function* () {
+            const activities = yield* activityForSession(db, session.id)
+            if (activities.length !== 1) return
+            const rows = yield* progressRows(db, activities[0]!.activity_id)
+            if (rows.length === 1 && rows[0]!.state === "progress") return true
+          }),
+          "timed out waiting for revision 0 to settle to progress",
+        ).pipe(Effect.flatMap(() => Effect.sync(() => setCrashEnv("after_provisional_event_before_provider_dispatch", dir, marker)))),
+        () =>
+          Effect.gen(function* () {
+            yield* waitMarker(marker, "timed out waiting for the second beginProgress crash point")
+            // Exactly ONE provider invocation so far: the second request never dispatched.
+            expect(yield* llm.calls).toBe(baselineCalls + 1)
+
+            const msgs = yield* sessions.messages({ sessionID: session.id })
+            const assistants = msgs.filter((message) => message.info.role === "assistant")
+            expect(assistants).toHaveLength(2)
+            const [first, second] = assistants as [typeof assistants[number], typeof assistants[number]]
+            // The new owning message has no text/reasoning/tool part yet — the projection did NOT
+            // wait for the first part.
+            expect(second.parts.some((part) => ["text", "reasoning", "tool"].includes(part.type))).toBe(false)
+            expect(markerOf(second.info)).toMatchObject({ revision: 1, state: "provisional" })
+            // The older progress revision is superseded: it stays "progress" but is no longer the
+            // activity's latest/effective revision.
+            expect(markerOf(first.info)).toMatchObject({ revision: 0, state: "progress" })
+            const activity = (yield* activityForSession(db, session.id))[0]!
+            expect(markerOf(second.info)?.activityID).toBe(activity.activity_id)
+
+            const rows = yield* progressRows(db, activity.activity_id)
+            expect(rows).toMatchObject([
+              { revision: 0, state: "progress" },
+              { revision: 1, state: "provisional", text_part_id: null },
+            ])
+
+            yield* prompt.cancel(session.id)
+            yield* awaitWithTimeout(Fiber.await(running), "timed out joining the crashed turn", "10 seconds")
+          }),
+        (prev) => Effect.sync(() => restoreCrashEnv(prev)),
+      )
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #3 — P1 crash (after beginProgress commit, before provisional event):
+// hydrate reads provisional, no marker event was published, 0 provider calls.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #3: crash between beginProgress commit and provisional event still hydrates provisional",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "P1 crash", permission: allowAll })
+      const marker = path.join(dir, "bug407008-p1.json")
+      yield* llm.text("must never be dispatched")
+      const baselineCalls = yield* llm.calls
+
+      yield* crashScoped({ dir, point: "after_begin_progress_commit_before_provisional_event", marker },
+        Effect.gen(function* () {
+          const running = yield* prompt
+            .prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "crash at P1" }] })
+            .pipe(Effect.forkChild)
+          yield* waitMarker(marker, "timed out waiting for the P1 crash point")
+
+          // Progress authority committed: provisional row, NULL text_part_id.
+          const activity = (yield* activityForSession(db, session.id))[0]!
+          expect(yield* progressRows(db, activity.activity_id)).toMatchObject([
+            { revision: 0, state: "provisional", text_part_id: null },
+          ])
+
+          // HTTP/hydrate reads the provisional projection straight from the authority.
+          const msgs = yield* sessions.messages({ sessionID: session.id })
+          const assistant = msgs.findLast((message) => message.info.role === "assistant")
+          expect(assistant).toBeDefined()
+          const hydrated = yield* MessageV2.get({ sessionID: session.id, messageID: assistant!.info.id }).pipe(
+            Effect.provideService(Database.Service, database),
+          )
+          expect(markerOf(hydrated.info)).toMatchObject({ revision: 0, state: "provisional" })
+
+          // The provisional message.updated event was NOT published yet.
+          const events = yield* messageUpdatedEvents(db, session.id)
+          expect(markerEventsForMessage(events, assistant!.info.id)).toHaveLength(0)
+
+          // Provider invocation count is still zero.
+          expect(yield* llm.calls).toBe(baselineCalls)
+
+          yield* prompt.cancel(session.id)
+          yield* awaitWithTimeout(Fiber.await(running), "timed out joining the P1-crashed turn", "10 seconds")
+        }),
+      )
+
+      // Cancel terminalized the activity through the regular path; the provisional row was never
+      // mutated by the crash or the cancel.
+      expect((yield* activityForSession(db, session.id))[0]).toMatchObject({ state: "interrupted" })
+      const activity = (yield* activityForSession(db, session.id))[0]!
+      expect(yield* progressRows(db, activity.activity_id)).toMatchObject([{ revision: 0, state: "provisional" }])
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #4 — P2 crash (after provisional event, before dispatch): recovery
+// monotonically upgrades the SAME revision to recovery_required, still 0 calls.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #4: recovery monotonically upgrades the provisional revision after a P2 crash",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "P2 crash", permission: allowAll })
+      const marker = path.join(dir, "bug407008-p2.json")
+      yield* llm.text("must never be dispatched")
+      const baselineCalls = yield* llm.calls
+
+      yield* crashScoped({ dir, point: "after_provisional_event_before_provider_dispatch", marker },
+        Effect.gen(function* () {
+          const running = yield* prompt
+            .prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "crash at P2" }] })
+            .pipe(Effect.forkChild)
+          yield* waitMarker(marker, "timed out waiting for the P2 crash point")
+
+          const msgs = yield* sessions.messages({ sessionID: session.id })
+          const assistant = msgs.findLast((message) => message.info.role === "assistant")!
+          const activity = (yield* activityForSession(db, session.id))[0]!
+
+          // The provisional marker event WAS published before the crash.
+          const eventsBefore = yield* messageUpdatedEvents(db, session.id)
+          const provisional = markerEventsForMessage(eventsBefore, assistant.info.id)
+          expect(provisional).toHaveLength(1)
+          expect((provisional[0]!.data as MessageUpdatedPayload).info?.activityProgress).toMatchObject({
+            revision: 0,
+            state: "provisional",
+          })
+          expect(yield* llm.calls).toBe(baselineCalls)
+
+          // Simulated restart recovery (same authority order as the prompt layer: receipt
+          // transitions happen inside recoverActiveActivities for pre-dispatch receipts).
+          const recovered = yield* SessionPromptIntent.recoverActiveActivities("bug407008-recovery-owner", {
+            includeCurrentOwner: true,
+            sessionID: session.id,
+            source: "same_process_recovery",
+          }).pipe(Effect.provideService(Database.Service, database))
+          expect(recovered).toHaveLength(1)
+          expect(recovered[0]).toMatchObject({ activityID: activity.activity_id, assistantMessageID: assistant.info.id })
+
+          // Same revision, monotonically upgraded provisional -> recovery_required.
+          expect(yield* progressRows(db, activity.activity_id)).toMatchObject([
+            { revision: 0, state: "recovery_required" },
+          ])
+          // The pre-dispatch receipt was terminalized without any provider involvement.
+          const receipt = yield* db
+            .select()
+            .from(SessionToolRequestReceiptTable)
+            .where(eq(SessionToolRequestReceiptTable.assistant_message_id, assistant.info.id))
+            .get()
+            .pipe(Effect.orDie)
+          expect(receipt).toMatchObject({ provider_state: "failed", request_error_code: "pre_dispatch_owner_lost" })
+          expect((yield* activityForSession(db, session.id))[0]).toMatchObject({
+            state: "failed",
+            terminal_reason: "pre_dispatch_owner_lost",
+          })
+          expect(
+            yield* db
+              .select()
+              .from(SessionLegacyActivityTerminalTable)
+              .where(eq(SessionLegacyActivityTerminalTable.activity_id, activity.activity_id))
+              .all()
+              .pipe(Effect.orDie),
+          ).toMatchObject([{ state: "failed", progress_revision: 0, assistant_message_id: assistant.info.id }])
+          expect(yield* llm.calls).toBe(baselineCalls)
+
+          yield* prompt.cancel(session.id)
+          // The parked fiber's terminal replay legitimately diverges from the recovery-committed
+          // terminal (the real process was dead); the exit status is intentionally not asserted.
+          yield* awaitWithTimeout(Fiber.await(running), "timed out joining the P2-crashed turn", "10 seconds")
+        }),
+      )
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #6 — provider-backed interrupted assistant with ZERO parts: the
+// physical terminal authority projects over (replaces) the older progress.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #6: zero-part interrupted assistant projects the terminal state over old progress",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "zero-part terminal", permission: allowAll })
+      const marker = path.join(dir, "bug407008-zero-part.json")
+
+      yield* llm.push(
+        reply()
+          .reason("first request reasoning")
+          .tool("bash", { command: "sleep 1; echo ok", description: "slow tool", workdir: path.resolve(dir) }),
+      )
+      yield* llm.text("never dispatched")
+      const running = yield* prompt
+        .prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "abort mid activity" }] })
+        .pipe(Effect.forkChild)
+
+      yield* Effect.acquireUseRelease(
+        pollWithTimeout(
+          Effect.gen(function* () {
+            const activities = yield* activityForSession(db, session.id)
+            if (activities.length !== 1) return
+            const rows = yield* progressRows(db, activities[0]!.activity_id)
+            if (rows.length === 1 && rows[0]!.state === "progress") return true
+          }),
+          "timed out waiting for revision 0 to settle to progress",
+        ).pipe(Effect.flatMap(() => Effect.sync(() => setCrashEnv("after_provisional_event_before_provider_dispatch", dir, marker)))),
+        () =>
+          Effect.gen(function* () {
+            yield* waitMarker(marker, "timed out waiting for the second beginProgress crash point")
+            // Abort the parked turn: the provider-backed second assistant message has zero parts.
+            yield* prompt.cancel(session.id)
+            yield* awaitWithTimeout(Fiber.await(running), "timed out joining the aborted turn", "10 seconds")
+          }),
+        (prev) => Effect.sync(() => restoreCrashEnv(prev)),
+      )
+
+      const activity = (yield* activityForSession(db, session.id))[0]!
+      expect(activity).toMatchObject({ state: "interrupted", terminal_reason: "user_cancelled" })
+
+      const msgs = yield* sessions.messages({ sessionID: session.id })
+      const assistants = msgs.filter((message) => message.info.role === "assistant")
+      expect(assistants).toHaveLength(2)
+      const [older, terminal] = assistants as [typeof assistants[number], typeof assistants[number]]
+
+      // The interrupted assistant is provider-backed (receipt bound) but produced zero parts.
+      expect(terminal.parts.some((part) => ["text", "reasoning", "tool"].includes(part.type))).toBe(false)
+      expect(
+        yield* db
+          .select({ receiptID: SessionToolRequestReceiptTable.receipt_id })
+          .from(SessionToolRequestReceiptTable)
+          .where(eq(SessionToolRequestReceiptTable.assistant_message_id, terminal.info.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(1)
+
+      // Physical rows were NOT tampered with: rev 0 settled "progress", rev 1 stays provisional.
+      expect(yield* progressRows(db, activity.activity_id)).toMatchObject([
+        { revision: 0, state: "progress" },
+        { revision: 1, state: "provisional" },
+      ])
+      // The terminal authority row was written revisionless: it references NO assistant message
+      // and NO progress revision (the crash happened before the finalizer bound them), so nothing
+      // was fabricated — the read projection derives the terminal state purely from the existing
+      // progress rows + activity state.
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTerminalTable)
+          .where(eq(SessionLegacyActivityTerminalTable.activity_id, activity.activity_id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toMatchObject([
+        { state: "interrupted", source: "cancel", assistant_message_id: null, progress_revision: null },
+      ])
+
+      // The zero-part owning message projects the effective terminal state, replacing the older
+      // progress as the activity's effective marker; the older revision keeps its own state.
+      expect(markerOf(terminal.info)).toMatchObject({
+        revision: 1,
+        state: "interrupted",
+        terminalReason: "user_cancelled",
+      })
+      expect(markerOf(older.info)).toMatchObject({ revision: 0, state: "progress" })
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// shared helper: create a steer-placeholder activity through the legal
+// steer.admit lifecycle while a turn is parked before materialization
+// (same recipe as bug-008). Used by #9 and #17 C/D.
+// ---------------------------------------------------------------------------
+const makeSteerPlaceholder = Effect.fn("test.makeSteerPlaceholder")(function* (
+  sessionID: SessionID,
+  dir: string,
+) {
+  const prompt = yield* SessionPrompt.Service
+  const steer = yield* SessionSteer.Service
+  const marker = path.join(dir, `bug407008-placeholder-${Math.random().toString(36).slice(2)}.json`)
+  return yield* crashScoped(
+    { dir, point: "after_coordinator_reserve", marker },
+    Effect.gen(function* () {
+      const running = yield* prompt
+        .prompt({ sessionID, agent: "build", parts: [{ type: "text", text: "turn dies before materialization" }] })
+        .pipe(Effect.forkChild)
+      yield* waitMarker(marker, "timed out waiting for the coordinator reserve crash point")
+      yield* steer.admit({ sessionID, prompt: new Prompt({ text: "bug-407-008 steer placeholder" }) })
+      yield* prompt.cancel(sessionID)
+      // Exit status intentionally not asserted: the parked turn dies inside the window.
+      yield* awaitWithTimeout(Fiber.await(running), "timed out joining the parked placeholder turn", "10 seconds")
+      const database = yield* Database.Service
+      const placeholder = yield* database.db
+        .select()
+        .from(SessionLegacyActivityTable)
+        .where(eq(SessionLegacyActivityTable.session_id, sessionID))
+        .get()
+        .pipe(Effect.orDie)
+      if (!placeholder || placeholder.state !== "active")
+        return yield* Effect.die("steer placeholder activity was not created")
+      return placeholder.activity_id
+    }),
+  )
+})
+
+// ---------------------------------------------------------------------------
+// §7.1 #7 — latest physical progress row stays "progress" but the Activity is
+// recovery_required: reads derive the effective terminal state; recovery adds
+// NO receipt, message or progress revision.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #7: recovery_required projects over the settled progress row without fabricating authority rows",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "recovery over settled progress", permission: allowAll })
+      const marker = path.join(dir, "bug407008-p7.json")
+
+      yield* llm.push(
+        reply()
+          .reason("settle once then park")
+          .tool("bash", { command: "echo p7", description: "settle tool", workdir: path.resolve(dir) }),
+      )
+      // No second reply queued: after the crash point the loop cannot dispatch anything.
+      const running = yield* crashScoped({ dir, point: "after_progress_settle_before_next_admission", marker },
+        Effect.gen(function* () {
+          const fiber = yield* prompt
+            .prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "settle then crash" }] })
+            .pipe(Effect.forkChild)
+          yield* waitMarker(marker, "timed out waiting for the post-settlement crash point")
+
+          const activity = (yield* activityForSession(db, session.id))[0]!
+          const assistant = (yield* sessions.messages({ sessionID: session.id }))
+            .findLast((message) => message.info.role === "assistant")!
+          // The settled progress row exists and the receipt is terminal ("settled").
+          expect(yield* progressRows(db, activity.activity_id)).toMatchObject([{ revision: 0, state: "progress" }])
+          const receiptsBefore = yield* db
+            .select()
+            .from(SessionToolRequestReceiptTable)
+            .all()
+            .pipe(Effect.orDie)
+          const messagesBefore = yield* db
+            .select({ id: MessageTable.id })
+            .from(MessageTable)
+            .where(eq(MessageTable.session_id, session.id))
+            .all()
+            .pipe(Effect.orDie)
+
+          // Simulated restart recovery: the receipt already terminalized, so recovery only
+          // terminalizes the ACTIVITY; the progress row is left untouched (no-op settle).
+          const recovered = yield* SessionPromptIntent.recoverActiveActivities("bug407008-p7-owner", {
+            includeCurrentOwner: true,
+            sessionID: session.id,
+            source: "same_process_recovery",
+          }).pipe(Effect.provideService(Database.Service, database))
+          expect(recovered).toHaveLength(1)
+          expect(recovered[0]).toMatchObject({ activityID: activity.activity_id, assistantMessageID: assistant.info.id })
+
+          // Authority bookkeeping: nothing new was fabricated.
+          expect(yield* progressRows(db, activity.activity_id)).toMatchObject([{ revision: 0, state: "progress" }])
+          expect((yield* db.select().from(SessionToolRequestReceiptTable).all().pipe(Effect.orDie)).length).toBe(
+            receiptsBefore.length,
+          )
+          expect(
+            (
+              yield* db
+                .select({ id: MessageTable.id })
+                .from(MessageTable)
+                .where(eq(MessageTable.session_id, session.id))
+                .all()
+                .pipe(Effect.orDie)
+            ).length,
+          ).toBe(messagesBefore.length)
+
+          expect((yield* activityForSession(db, session.id))[0]).toMatchObject({
+            state: "recovery_required",
+            terminal_reason: "host_terminal_decision_missing",
+          })
+          expect(
+            yield* db
+              .select()
+              .from(SessionLegacyActivityTerminalTable)
+              .where(eq(SessionLegacyActivityTerminalTable.activity_id, activity.activity_id))
+              .all()
+              .pipe(Effect.orDie),
+          ).toMatchObject([{ state: "recovery_required", progress_revision: 0 }])
+
+          // The canonical marker event is published exactly once by the dedicated publisher,
+          // re-deriving the effective state from the untouched progress row.
+          const before = markerEventsForMessage(yield* messageUpdatedEvents(db, session.id), assistant.info.id).length
+          yield* sessions.publishMessageProjection({ sessionID: session.id, messageID: assistant.info.id })
+          const projected = markerEventsForMessage(yield* messageUpdatedEvents(db, session.id), assistant.info.id)
+          expect(projected.length).toBe(before + 1)
+          expect((projected.at(-1)!.data as MessageUpdatedPayload).info?.activityProgress).toMatchObject({
+            revision: 0,
+            state: "recovery_required",
+            terminalReason: "host_terminal_decision_missing",
+          })
+          // The read projection agrees with the event.
+          expect(
+            markerOf((yield* sessions.getMessage({ sessionID: session.id, messageID: assistant.info.id })).info),
+          ).toMatchObject({ revision: 0, state: "recovery_required" })
+
+          yield* prompt.cancel(session.id)
+          // The parked fiber's terminal replay legitimately diverges from the recovery-committed
+          // terminal (the real process was dead); the exit status is intentionally not asserted.
+          yield* awaitWithTimeout(Fiber.await(fiber), "timed out joining the crashed turn", "10 seconds")
+        }),
+      )
+      void running
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #8 — Abort after a settled progress, before the next admission: the
+// terminal authority reuses the OLD row's revision and the Activity terminal
+// state; the physical progress row is never tampered with.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #8: abort after settlement terminalizes with the old revision without touching the progress row",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "abort after settlement", permission: allowAll })
+      const marker = path.join(dir, "bug407008-p8.json")
+
+      yield* llm.push(
+        reply()
+          .reason("settle then wait for abort")
+          .tool("bash", { command: "echo p8", description: "settle tool", workdir: path.resolve(dir) }),
+      )
+      yield* crashScoped({ dir, point: "after_progress_settle_before_next_admission", marker },
+        Effect.gen(function* () {
+          const running = yield* prompt
+            .prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "settle then abort" }] })
+            .pipe(Effect.forkChild)
+          yield* waitMarker(marker, "timed out waiting for the post-settlement crash point")
+          yield* prompt.cancel(session.id)
+          yield* awaitWithTimeout(Fiber.await(running), "timed out joining the aborted turn", "10 seconds")
+        }),
+      )
+
+      const activity = (yield* activityForSession(db, session.id))[0]!
+      expect(activity).toMatchObject({ state: "interrupted", terminal_reason: "user_cancelled" })
+      // The settled progress row is physically untouched (no rewrite, no extra revision).
+      expect(yield* progressRows(db, activity.activity_id)).toMatchObject([{ revision: 0, state: "progress" }])
+      // The terminal authority references the OLD revision.
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTerminalTable)
+          .where(eq(SessionLegacyActivityTerminalTable.activity_id, activity.activity_id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toMatchObject([{ state: "interrupted", progress_revision: 0 }])
+
+      // Nothing was fabricated: exactly user + assistant messages and one receipt.
+      const msgs = yield* sessions.messages({ sessionID: session.id })
+      expect(msgs.filter((message) => message.info.role === "assistant")).toHaveLength(1)
+      expect(
+        yield* db
+          .select()
+          .from(SessionToolRequestReceiptTable)
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(1)
+
+      // The read projection derives the terminal state from authority only.
+      const assistant = msgs.findLast((message) => message.info.role === "assistant")!
+      expect(markerOf(assistant.info)).toMatchObject({
+        revision: 0,
+        state: "interrupted",
+        terminalReason: "user_cancelled",
+      })
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #9 — Activity terminal BEFORE its first progress admission (steer
+// placeholder): nothing is fabricated — no projection, message or revision.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #9: terminalizing a pre-admission activity fabricates no projection, message or revision",
+  () =>
+    Effect.gen(function* () {
+      const { dir } = yield* useServerConfig(providerCfg)
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "terminal before first admission" })
+
+      const placeholderID = yield* makeSteerPlaceholder(session.id, dir)
+      const eventsBefore = (yield* messageUpdatedEvents(db, session.id)).length
+
+      // Recovery deliberately skips the run_now/pending/no-run placeholder shape ...
+      expect(
+        yield* SessionPromptIntent.recoverActiveActivities("bug407008-p9-owner", {
+          includeCurrentOwner: true,
+          sessionID: session.id,
+          source: "same_process_recovery",
+        }).pipe(Effect.provideService(Database.Service, database)),
+      ).toHaveLength(0)
+
+      // ... so the dedicated retiral caller terminalizes it instead.
+      const retired = yield* SessionPromptIntent.retireDisabledSteerActivity(session.id).pipe(
+        Effect.provideService(Database.Service, database),
+      )
+      expect(retired).toMatchObject({ activityID: placeholderID, sessionID: session.id })
+      // No latest progress exists: the DTO carries NO assistant message ID.
+      expect(retired && "assistantMessageID" in retired).toBe(false)
+
+      expect((yield* activityForSession(db, session.id))[0]).toMatchObject({
+        state: "interrupted",
+        terminal_reason: "steering_disabled_before_absorption",
+      })
+      // Nothing was fabricated anywhere.
+      expect(
+        yield* db
+          .select()
+          .from(SessionActivityProgressTable)
+          .where(eq(SessionActivityProgressTable.activity_id, placeholderID))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(0)
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTerminalTable)
+          .where(eq(SessionLegacyActivityTerminalTable.activity_id, placeholderID))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(0)
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityRunTable)
+          .where(eq(SessionLegacyActivityRunTable.session_id, session.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(0)
+      // Only the triggering steer admission exists — no fabricated extra admission.
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityAdmissionTable)
+          .where(eq(SessionLegacyActivityAdmissionTable.activity_id, placeholderID))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(1)
+      expect(
+        (yield* sessions.messages({ sessionID: session.id })).some((message) => message.info.role === "assistant"),
+      ).toBe(false)
+      expect((yield* messageUpdatedEvents(db, session.id)).length).toBe(eventsBefore)
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #10 — generic Session.updateMessage receiving an assistant object with
+// a stale computed marker must strip it before publishing.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #10: updateMessage strips a stale computed activityProgress marker before publishing",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "stale marker strip", permission: allowAll })
+
+      yield* llm.text("settled response")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "settle" }] }),
+        "timed out running the settle turn",
+        "20 seconds",
+      )
+      const assistant = (yield* sessions.messages({ sessionID: session.id })).findLast(
+        (message) => message.info.role === "assistant",
+      )!
+      const hydrated = yield* MessageV2.get({ sessionID: session.id, messageID: assistant.info.id }).pipe(
+        Effect.provideService(Database.Service, database),
+      )
+      expect(markerOf(hydrated.info)).toBeDefined()
+
+      // A caller re-submits the assistant object carrying a fabricated/stale marker.
+      const staleInfo = {
+        ...hydrated.info,
+        activityProgress: { activityID: "act_stale_fake", revision: 42, state: "final" } as SessionV1.ActivityProgress,
+      }
+      yield* sessions.updateMessage(staleInfo)
+
+      const events = yield* messageUpdatedEvents(db, session.id)
+      const own = eventsForMessage(events, assistant.info.id)
+      expect(own.length).toBeGreaterThan(0)
+      // The latest published projection carries NO stale computed marker ...
+      expect((own.at(-1)!.data as MessageUpdatedPayload).info?.activityProgress).toBeUndefined()
+      // ... while the earlier canonical marker event remains intact.
+      const markerEvents = markerEventsForMessage(events, assistant.info.id)
+      expect(markerEvents.length).toBeGreaterThan(0)
+      expect((markerEvents.at(-1)!.data as MessageUpdatedPayload).info?.activityProgress).toMatchObject({
+        revision: 0,
+        state: "final",
+      })
+      // NOTE: updateMessage's commit callback persists the caller object verbatim (QUAL-007
+      // upsert); the §7.1 #10 invariant is about the PUBLISHED projection, asserted above. The
+      // read side never trusts stored markers — hydrate derives them from the authority.
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #11 — the core projector consuming the dedicated publisher's
+// computed-marker events persists message JSON without the marker.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #11: projector persists message JSON without the computed marker emitted by the publisher",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "projector strip", permission: allowAll })
+
+      yield* llm.text("marker-bearing projection")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "publish markers" }] }),
+        "timed out running the turn",
+        "20 seconds",
+      )
+
+      // The dedicated publisher DID emit computed-marker events ...
+      const events = yield* messageUpdatedEvents(db, session.id)
+      const withMarker = events.filter((row) => (row.data as MessageUpdatedPayload).info?.activityProgress)
+      expect(withMarker.length).toBeGreaterThan(0)
+
+      // ... yet every persisted message row stays marker-free.
+      const stored = yield* db
+        .select({ id: MessageTable.id, data: MessageTable.data })
+        .from(MessageTable)
+        .where(eq(MessageTable.session_id, session.id))
+        .all()
+        .pipe(Effect.orDie)
+      expect(stored.length).toBeGreaterThan(0)
+      for (const row of stored) expect(row.data).not.toHaveProperty("activityProgress")
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #12 — fork delivery publishing MessageUpdated directly: caller
+// snapshots cannot forge markers; only helper re-derived canonical state
+// propagates (here: nothing, since fork copies no activity authority).
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #12: fork delivery propagates only the stripped canonical projection, never caller markers",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+      const session = yield* sessions.create({ title: "fork marker strip", permission: allowAll })
+
+      yield* llm.text("settled before fork")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "settle before fork" }] }),
+        "timed out running the settle turn",
+        "20 seconds",
+      )
+      const sourceMarker = markerOf(
+        (yield* sessions.messages({ sessionID: session.id })).findLast(
+          (message) => message.info.role === "assistant",
+        )!.info,
+      )
+      expect(sourceMarker).toBeDefined()
+
+      const target = yield* sessions.fork({ sessionID: session.id, intentID: "fork-bug407008-marker-strip" })
+
+      // Every message.updated event published for the target carries no marker ...
+      const targetEvents = yield* messageUpdatedEvents(db, target.id)
+      expect(targetEvents.length).toBeGreaterThan(0)
+      for (const row of targetEvents)
+        expect((row.data as MessageUpdatedPayload).info?.activityProgress).toBeUndefined()
+
+      // ... and the target read paths agree: no fabricated marker survives the fork.
+      const targetPage = yield* sessions.messagesPage({ sessionID: target.id, limit: 100 })
+      expect(targetPage.items.length).toBeGreaterThan(0)
+      for (const item of targetPage.items) expect(markerOf(item.info)).toBeUndefined()
+      for (const item of yield* sessions.messages({ sessionID: target.id }))
+        expect(markerOf(item.info)).toBeUndefined()
+
+      // The source session still projects its canonical marker.
+      expect(
+        markerOf(
+          (yield* sessions.messages({ sessionID: session.id })).findLast(
+            (message) => message.info.role === "assistant",
+          )!.info,
+        ),
+      ).toEqual(sourceMarker)
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #13 — a late plain message update cannot regress the App marker, and
+// subsequent hydrates keep the canonical marker.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #13: late marker-less updates never regress the canonical computed marker",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const session = yield* sessions.create({ title: "late update", permission: allowAll })
+
+      yield* llm.text("settled")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "settle" }] }),
+        "timed out running the settle turn",
+        "20 seconds",
+      )
+      const hydrated = yield* MessageV2.get({
+        sessionID: session.id,
+        messageID: (yield* sessions.messages({ sessionID: session.id })).findLast(
+          (message) => message.info.role === "assistant",
+        )!.info.id,
+      }).pipe(Effect.provideService(Database.Service, database))
+      const canonical = markerOf(hydrated.info)
+      expect(canonical).toMatchObject({ state: "final" })
+      if (hydrated.info.role !== "assistant") return yield* Effect.die("expected an assistant message")
+
+      // A late update arrives WITHOUT any marker (old client snapshot).
+      const { activityProgress: _, ...plain } = hydrated.info
+      void _
+      yield* sessions.updateMessage({ ...plain, time: { ...plain.time, updated: Date.now() } })
+
+      // Single-message reads keep the canonical marker ...
+      expect(
+        markerOf((yield* sessions.getMessage({ sessionID: session.id, messageID: hydrated.info.id })).info),
+      ).toEqual(canonical)
+      expect(
+        markerOf((yield* sessions.getClientMessage({ sessionID: session.id, messageID: hydrated.info.id })).info),
+      ).toEqual(canonical)
+
+      // ... as do page/full reads.
+      const page = yield* sessions.messagesPage({ sessionID: session.id, limit: 100 })
+      expect(markerOf(page.items.find((item) => item.info.id === hydrated.info.id)!.info)).toEqual(canonical)
+      expect(
+        markerOf(
+          (yield* sessions.messages({ sessionID: session.id })).find((item) => item.info.id === hydrated.info.id)!
+            .info,
+        ),
+      ).toEqual(canonical)
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #14 — page batch queries are N+1-free; empty pages, mixed user/assistant
+// pages and cross-activity pages all come back correct.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #14: message pages are batch-hydrated (no N+1) and correct across empty/mixed/cross-activity pages",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+
+      // Empty page on a fresh session.
+      const emptySession = yield* sessions.create({ title: "empty page" })
+      const emptyPage = yield* sessions.messagesPage({ sessionID: emptySession.id, limit: 10 })
+      expect(emptyPage).toMatchObject({ items: [], more: false })
+      expect(emptyPage.cursor).toBeUndefined()
+
+      // Two sequential turns -> two distinct activities: cross-activity page.
+      const session = yield* sessions.create({ title: "cross-activity pages", permission: allowAll })
+      yield* llm.text("activity one answer")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "first turn" }] }),
+        "timed out running turn one",
+        "20 seconds",
+      )
+      yield* llm.text("activity two answer")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "second turn" }] }),
+        "timed out running turn two",
+        "20 seconds",
+      )
+      expect(yield* activityForSession(db, session.id)).toHaveLength(2)
+
+      const full = yield* sessions.messages({ sessionID: session.id })
+      expect(full).toHaveLength(4)
+      // Mixed user/assistant page: every assistant carries its own activity's marker.
+      const assistants = full.filter((message) => message.info.role === "assistant")
+      expect(assistants).toHaveLength(2)
+      const activityIDs = new Set(assistants.map((message) => markerOf(message.info)?.activityID))
+      expect(activityIDs.size).toBe(2)
+      for (const message of assistants) expect(markerOf(message.info)).toMatchObject({ state: "final" })
+
+      // N+1 guard: a full page hydrate touches the progress authority through exactly one
+      // batched query, regardless of how many assistant messages it contains.
+      const dbAny = db as unknown as { session: { prepareQuery: (...args: never[]) => unknown } }
+      const sessionAny = dbAny.session
+      const original = sessionAny.prepareQuery
+      let progressQueryCount = 0
+      sessionAny.prepareQuery = function (this: unknown, query: { sql: string }, ...rest: never[]) {
+        if (query.sql.includes("session_activity_progress")) progressQueryCount += 1
+        return original.apply(this, [query, ...rest] as never[])
+      } as typeof original
+      try {
+        const page = yield* sessions.messagesPage({ sessionID: session.id, limit: 100 })
+        // sessions.messages walks pages newest-first, so the full list is already desc-ordered.
+        expect(page.items.map((item) => item.info.id)).toEqual(full.map((message) => message.info.id))
+        expect(page.more).toBe(false)
+        for (const item of page.items)
+          if (item.info.role === "assistant") expect(markerOf(item.info)).toBeDefined()
+      } finally {
+        sessionAny.prepareQuery = original
+      }
+      expect(progressQueryCount).toBeLessThanOrEqual(1)
+      expect(progressQueryCount).toBeGreaterThanOrEqual(1)
+
+      // Cursor walk with limit 2 reassembles the full history exactly.
+      const walked: string[] = []
+      let cursor: string | undefined
+      do {
+        const page = yield* sessions.messagesPage({ sessionID: session.id, limit: 2, before: cursor })
+        walked.push(...page.items.map((item) => item.info.id))
+        cursor = page.more ? page.cursor : undefined
+      } while (cursor)
+      // The backward walk reassembles the exact same message set (page order is newest-first).
+      expect([...walked].sort()).toEqual([...full.map((message) => message.info.id)].sort())
+    }),
+  { git: true },
+  90_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #15 — MessageV2.get and every single-message/page/full HTTP read return
+// the exact same computed projection.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #15: get and all single-message read paths agree on the computed projection",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const session = yield* sessions.create({ title: "read-path agreement", permission: allowAll })
+
+      yield* llm.push(
+        reply()
+          .reason("tool turn")
+          .tool("bash", { command: "echo agreement", description: "tool", workdir: path.resolve(dir) }),
+      )
+      yield* llm.text("closing answer")
+      yield* awaitWithTimeout(
+        prompt.prompt({ sessionID: session.id, agent: "build", parts: [{ type: "text", text: "agree" }] }),
+        "timed out running the turn",
+        "20 seconds",
+      )
+
+      const msgs = yield* sessions.messages({ sessionID: session.id })
+      const toolAssistant = msgs.find(
+        (message) => message.info.role === "assistant" && message.parts.some((part) => part.type === "tool"),
+      )!
+      const messageID = toolAssistant.info.id
+
+      const viaGet = markerOf(
+        (yield* MessageV2.get({ sessionID: session.id, messageID }).pipe(
+          Effect.provideService(Database.Service, database),
+        )).info,
+      )
+      expect(viaGet).toBeDefined()
+      expect(markerOf((yield* sessions.getMessage({ sessionID: session.id, messageID })).info)).toEqual(viaGet)
+      expect(markerOf((yield* sessions.getClientMessage({ sessionID: session.id, messageID })).info)).toEqual(viaGet)
+      const page = yield* MessageV2.page({ sessionID: session.id, limit: 100 }).pipe(
+        Effect.provideService(Database.Service, database),
+      )
+      expect(markerOf(page.items.find((item) => item.info.id === messageID)!.info)).toEqual(viaGet)
+      const clientPage = yield* sessions.messagesPage({ sessionID: session.id, limit: 100 })
+      expect(markerOf(clientPage.items.find((item) => item.info.id === messageID)!.info)).toEqual(viaGet)
+      expect(markerOf(msgs.find((message) => message.info.id === messageID)!.info)).toEqual(viaGet)
+    }),
+  { git: true },
+  60_000,
+)
+
+// ---------------------------------------------------------------------------
+// §7.1 #16 — incident-fixture read-only projection (revision 8/9/10).
+// The incident activity a6d06b2a… (session ses_0149b8…, revisions 0-10, terminal
+// state=interrupted/AbortError) lives in a 1.4.6 production DB COPY. Resolve it via
+// DEEPAGENT_CODE_INCIDENT_DB_PATH or the known snapshot path; SKIP when absent (the 4.8GB
+// production snapshot is never committed). Opened READ-ONLY with NO migration applied, verifying the
+// computed projection + integrity + ownership directly on the production schema.
+// ---------------------------------------------------------------------------
+const INCIDENT_ACTIVITY_ID = "a6d06b2a82ef234ab9dc71e3fd940292a21b34f4732f28aa19ba8416c4c5e5a9"
+const incidentDbPath = () =>
+  process.env.DEEPAGENT_CODE_INCIDENT_DB_PATH ??
+  path.join(os.homedir(), ".deepagent", "code", "deepagent-code-production-snapshot-20260814-162627.db")
+
+test("BUG-407-008 #16: incident DB copy opens read-only without migration and yields revision 8/9/10 projections", () => {
+  const dbPath = incidentDbPath()
+  if (!existsSync(dbPath)) return // no production DB copy here — skip rather than fabricate
+  const db = new BunSQLite(dbPath, { readonly: true })
+  try {
+    // 1. Computed projection (latestRevision ⋈ activity state) derives effective states on the
+    //    production schema WITHOUT any migration applied. rev 8/9 stay `progress`; the terminal
+    //    rev 10 projects `interrupted` from the activity state.
+    const rows = db
+      .query(
+        `SELECT p.revision,
+                p.assistant_message_id,
+                p.state AS progress_state,
+                p.text_part_id AS text_part_id,
+                a.state AS activity_state,
+                CASE WHEN p.revision <> (SELECT max(revision) FROM session_activity_progress WHERE activity_id = p.activity_id)
+                          OR a.state = 'active' THEN p.state
+                     WHEN a.state = 'settled' THEN 'final'
+                     ELSE a.state END AS effective_state
+             FROM session_activity_progress p
+             JOIN session_legacy_activity a ON a.activity_id = p.activity_id
+            WHERE p.activity_id = ?
+         ORDER BY p.revision`,
+      )
+      .all(INCIDENT_ACTIVITY_ID) as Array<{
+      revision: number
+      assistant_message_id: string
+      progress_state: string
+      text_part_id: string | null
+      activity_state: string
+      effective_state: string
+    }>
+    expect(rows.length).toBe(11)
+    const byRevision = new Map(rows.map((row) => [row.revision, row]))
+    expect(byRevision.get(8)?.effective_state).toBe("progress")
+    expect(byRevision.get(9)?.effective_state).toBe("progress")
+    expect(byRevision.get(10)?.effective_state).toBe("interrupted")
+    expect(byRevision.get(10)?.activity_state).toBe("interrupted")
+    // reasoning-only revisions keep text_part_id NULL (projection never fabricates a text part).
+    expect(byRevision.get(8)?.text_part_id).toBeNull()
+    expect(byRevision.get(9)?.text_part_id).toBeNull()
+    // 2. Integrity check passes on the read-only copy (quick_check = the fast integrity scan).
+    const integrity = db.query("PRAGMA quick_check").get() as Record<string, unknown>
+    expect(Object.values(integrity ?? {})[0]).toBe("ok")
+    // 3. Ownership consistency: every progress row's assistant message lives in the activity's session.
+    const ownership = db
+      .query(
+        `SELECT count(*) AS n
+           FROM session_activity_progress p
+           JOIN message m ON m.id = p.assistant_message_id
+           JOIN session_legacy_activity a ON a.activity_id = p.activity_id
+          WHERE p.activity_id = ? AND m.session_id <> a.session_id`,
+      )
+      .get(INCIDENT_ACTIVITY_ID) as { n: number }
+    expect(ownership.n).toBe(0)
+  } finally {
+    db.close()
+  }
+})
+
+// ---------------------------------------------------------------------------
+// §7.1 #17 — per-caller validation: settleProgress terminal / interruptActivity
+// / recoverActiveActivities / retireDisabledSteerActivity return the message ID
+// and publish exactly once when progress exists, and never publish without it.
+// ---------------------------------------------------------------------------
+it.instance(
+  "BUG-407-008 #17: settlement/interrupt/recovery/retiral callers publish once with progress, never without",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const database = yield* Database.Service
+      const { db } = database
+
+      // (A) settleProgress terminal: a healthy turn settles and the terminal marker
+      // is published exactly once for the owning message.
+      const settledSession = yield* sessions.create({ title: "caller: settleProgress", permission: allowAll })
+      yield* llm.text("settled once")
+      yield* awaitWithTimeout(
+        prompt.prompt({
+          sessionID: settledSession.id,
+          agent: "build",
+          parts: [{ type: "text", text: "settle terminal" }],
+        }),
+        "timed out running the settle turn",
+        "20 seconds",
+      )
+      const settledAssistant = (yield* sessions.messages({ sessionID: settledSession.id })).findLast(
+        (message) => message.info.role === "assistant",
+      )!
+      const finals = markerEventsForMessage(
+        yield* messageUpdatedEvents(db, settledSession.id),
+        settledAssistant.info.id,
+      ).filter(
+        (row) => ((row.data as MessageUpdatedPayload).info?.activityProgress?.state ?? "") === "final",
+      )
+      expect(finals).toHaveLength(1)
+
+      // (B) interruptActivity WITH latest progress: returns the owning message ID,
+      // and the dedicated publisher emits exactly one more canonical marker.
+      const interruptSession = yield* sessions.create({ title: "caller: interruptActivity", permission: allowAll })
+      const interruptMarker = path.join(dir, "bug407008-p17-interrupt.json")
+      yield* llm.push(
+        reply()
+          .reason("settle then park")
+          .tool("bash", { command: "echo p17", description: "settle tool", workdir: path.resolve(dir) }),
+      )
+      const parked = yield* crashScoped(
+        { dir, point: "after_progress_settle_before_next_admission", marker: interruptMarker },
+        Effect.gen(function* () {
+          const fiber = yield* prompt
+            .prompt({
+              sessionID: interruptSession.id,
+              agent: "build",
+              parts: [{ type: "text", text: "settle then interrupt" }],
+            })
+            .pipe(Effect.forkChild)
+          yield* waitMarker(interruptMarker, "timed out waiting for the post-settlement crash point")
+
+          const activityID = (yield* activityForSession(db, interruptSession.id))[0]!.activity_id
+          const assistantID = MessageID.make((yield* progressRows(db, activityID))[0]!.assistant_message_id)
+          const before = markerEventsForMessage(
+            yield* messageUpdatedEvents(db, interruptSession.id),
+            assistantID,
+          ).length
+
+          const invalidation = yield* SessionPromptIntent.interruptActivity(activityID).pipe(
+            Effect.provideService(Database.Service, database),
+          )
+          expect(invalidation).toMatchObject({ activityID, assistantMessageID: assistantID })
+
+          yield* sessions.publishMessageProjection({ sessionID: interruptSession.id, messageID: assistantID })
+          const after = markerEventsForMessage(
+            yield* messageUpdatedEvents(db, interruptSession.id),
+            assistantID,
+          )
+          expect(after.length).toBe(before + 1)
+          expect((after.at(-1)!.data as MessageUpdatedPayload).info?.activityProgress).toMatchObject({
+            revision: 0,
+            state: "interrupted",
+            terminalReason: "aborted_before_provider_settlement",
+          })
+
+          // The physical settled row is untouched.
+          expect(yield* progressRows(db, activityID)).toMatchObject([{ revision: 0, state: "progress" }])
+
+          yield* prompt.cancel(interruptSession.id)
+          // Exit status intentionally not asserted (terminal replay divergence, see #4/#7).
+          yield* awaitWithTimeout(Fiber.await(fiber), "timed out joining the parked turn", "10 seconds")
+        }),
+      )
+      void parked
+
+      // (C) retireDisabledSteerActivity WITHOUT progress: no message ID, no publish.
+      const retireSession = yield* sessions.create({ title: "caller: retireDisabledSteerActivity" })
+      const placeholderID = yield* makeSteerPlaceholder(retireSession.id, dir)
+      const retireBefore = (yield* messageUpdatedEvents(db, retireSession.id)).length
+      const retired = yield* SessionPromptIntent.retireDisabledSteerActivity(retireSession.id).pipe(
+        Effect.provideService(Database.Service, database),
+      )
+      expect(retired).toMatchObject({ activityID: placeholderID })
+      expect(retired && "assistantMessageID" in retired).toBe(false)
+      expect((yield* messageUpdatedEvents(db, retireSession.id)).length).toBe(retireBefore)
+
+      // (D) interruptActivity WITHOUT progress: no message ID, no publish.
+      const bareSession = yield* sessions.create({ title: "caller: interruptActivity (no progress)" })
+      const barePlaceholderID = yield* makeSteerPlaceholder(bareSession.id, dir)
+      const bareBefore = (yield* messageUpdatedEvents(db, bareSession.id)).length
+      const bare = yield* SessionPromptIntent.interruptActivity(barePlaceholderID).pipe(
+        Effect.provideService(Database.Service, database),
+      )
+      expect(bare).toMatchObject({ activityID: barePlaceholderID })
+      expect(bare && "assistantMessageID" in bare).toBe(false)
+      expect((yield* messageUpdatedEvents(db, bareSession.id)).length).toBe(bareBefore)
+
+      // (E) recoverActiveActivities WITHOUT progress (placeholder shape): skipped by
+      // design, returns [] and publishes nothing.
+      expect(
+        yield* SessionPromptIntent.recoverActiveActivities("bug407008-p17-owner", {
+          includeCurrentOwner: true,
+          sessionID: bareSession.id,
+          source: "same_process_recovery",
+        }).pipe(Effect.provideService(Database.Service, database)),
+      ).toHaveLength(0)
+      expect((yield* messageUpdatedEvents(db, bareSession.id)).length).toBe(bareBefore)
+    }),
+  { git: true },
+  120_000,
+)
diff --git a/packages/deepagent-code/test/session/compacted-fork.test.ts b/packages/deepagent-code/test/session/compacted-fork.test.ts
index 12c5e49b..73001f78 100644
--- a/packages/deepagent-code/test/session/compacted-fork.test.ts
+++ b/packages/deepagent-code/test/session/compacted-fork.test.ts
@@ -15,10 +15,15 @@ import { eq, sql } from "drizzle-orm"
 import { MessageV2 } from "@/session/message-v2"
 import { contextStoreRoot, loadForkOrigin } from "@/session/context-ledger"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { MessageID, PartID, type SessionID } from "@/session/schema"
 import { testEffect } from "../lib/effect"
 
-const it = testEffect(Layer.mergeAll(Session.defaultLayer, Database.defaultLayer))
+// QUAL-007: the core SessionProjector is the canonical V1-event projection path (session/message/part
+// rows); without it the minimal layer never materializes sessions created through events.
+const it = testEffect(
+  Layer.mergeAll(Session.defaultLayer.pipe(Layer.provide(SessionProjector.defaultLayer)), Database.defaultLayer),
+)
 
 const addUser = Effect.fn("CompactedForkTest.addUser")(function* (sessionID: SessionID, text?: string) {
   const sessions = yield* Session.Service
diff --git a/packages/deepagent-code/test/session/compaction.test.ts b/packages/deepagent-code/test/session/compaction.test.ts
index 852eaf91..7af08fba 100644
--- a/packages/deepagent-code/test/session/compaction.test.ts
+++ b/packages/deepagent-code/test/session/compaction.test.ts
@@ -7,6 +7,7 @@ import { PartTable, SessionHistoryStateTable, SessionWorldStateBaselineTable } f
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { APICallError } from "ai"
 import { Cause, Deferred, Effect, Exit, Fiber, Layer, Schema } from "effect"
+import { HttpClientResponse } from "effect/unstable/http"
 import * as Stream from "effect/Stream"
 import { and, eq, inArray } from "drizzle-orm"
 import { Config } from "@/config/config"
@@ -27,6 +28,7 @@ import { SessionStatus } from "../../src/session/status"
 import { SessionSummary } from "../../src/session/summary"
 import { SessionV2 } from "@deepagent-code/core/session"
 import { SessionExecution } from "@deepagent-code/core/session/execution"
+import { Hash } from "@deepagent-code/core/util/hash"
 
 import type { Provider } from "@/provider/provider"
 import * as SessionProcessorModule from "../../src/session/processor"
@@ -37,11 +39,16 @@ import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
 import { TestConfig } from "../fixture/config"
 import { RuntimeFlags } from "@/effect/runtime-flags"
 import { PromptEpoch } from "@/session/prompt-epoch"
-import { CompactionArtifactTable, CompactionRunTable, CompactionSummaryAttemptTable } from "@/session/compaction-sql"
+import { CompactionArtifactTable, CompactionRunTable, CompactionSummaryAttemptTable, SessionCompactionEncryptedContentTable } from "@/session/compaction-sql"
 import { SessionPromptEpochTable } from "@/session/prompt-epoch.sql"
 import { LLMEvent, Usage } from "@deepagent-code/llm"
+import { RequestExecutor } from "@deepagent-code/llm/route"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
+import { EncryptedContentStore } from "@/session/remote-compact"
 import { ProviderV2 } from "@deepagent-code/core/provider"
 import { ModelV2 } from "@deepagent-code/core/model"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 
 void Log.init({ print: false })
 
@@ -238,6 +245,7 @@ function fake(
     get message() {
       return msg
     },
+    snapshotOutcome: {} satisfies Snapshot.TrackOutcome,
     updateToolCall: Effect.fn("TestSessionProcessor.updateToolCall")(() => Effect.succeed(undefined)),
     completeToolCall: Effect.fn("TestSessionProcessor.completeToolCall")(() => Effect.void),
     process: Effect.fn("TestSessionProcessor.process")(() => Effect.succeed(decision)),
@@ -265,6 +273,19 @@ function cfg(compaction?: ConfigV1.Info["compaction"]) {
   })
 }
 
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Layer it over the tracked
+// history so compaction_run carries the mode columns the drizzle schema
+// already declares. applyOnly is tracked, hence idempotent.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
 const deps = Layer.mergeAll(
   wide().layer,
   layer("continue"),
@@ -273,25 +294,33 @@ const deps = Layer.mergeAll(
   EventV2Bridge.defaultLayer,
   Config.defaultLayer,
   RuntimeFlags.layer({ experimentalEventSystem: true }),
-  Database.defaultLayer,
+  database,
   EventV2Bridge.defaultLayer,
   PromptEpoch.defaultLayer,
 )
 
 const env = Layer.mergeAll(
   SessionNs.defaultLayer,
-  Database.defaultLayer,
+  // QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+  // writes hit the session FK.
+  SessionProjector.defaultLayer,
+  database,
   EventV2Bridge.defaultLayer,
   CrossSpawnSpawner.defaultLayer,
   PromptEpoch.defaultLayer,
-  SessionCompaction.layer.pipe(Layer.provide(SessionNs.defaultLayer), Layer.provideMerge(deps)),
+  SessionCompaction.layer.pipe(
+    Layer.provide(SessionNs.defaultLayer),
+    Layer.provide(RequestExecutor.defaultLayer),
+    Layer.provideMerge(deps),
+  ),
 )
 
 const it = testEffect(env)
 
 const compactionEnv = Layer.mergeAll(
   SessionNs.defaultLayer,
-  Database.defaultLayer,
+  SessionProjector.defaultLayer,
+  database,
   EventV2Bridge.defaultLayer,
   CrossSpawnSpawner.defaultLayer,
   PromptEpoch.defaultLayer,
@@ -304,6 +333,8 @@ type CompactionProcessOptions = {
   plugin?: Layer.Layer<Plugin.Service>
   provider?: ReturnType<typeof ProviderTest.fake>
   config?: Layer.Layer<Config.Service>
+  flags?: Partial<RuntimeFlags.Info>
+  executor?: Layer.Layer<RequestExecutor.Service>
 }
 
 function withCompaction(options?: CompactionProcessOptions) {
@@ -317,11 +348,19 @@ function compactionProcessLayer(options?: CompactionProcessOptions) {
     ? SessionProcessorModule.SessionProcessor.layer.pipe(
         Layer.provide(summary),
         Layer.provide(Image.defaultLayer),
-        Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true })),
+        Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true, ...options?.flags })),
         Layer.provide(status),
       )
     : layer(options?.result ?? "continue")
-  return Layer.mergeAll(SessionCompaction.layer.pipe(Layer.provide(processor)), processor, events, status).pipe(
+  return Layer.mergeAll(
+    SessionCompaction.layer.pipe(
+      Layer.provide(processor),
+      Layer.provide(options?.executor ?? RequestExecutor.defaultLayer),
+    ),
+    processor,
+    events,
+    status,
+  ).pipe(
     Layer.provide(SessionNs.defaultLayer),
     Layer.provide((options?.provider ?? wide()).layer),
     Layer.provide(Snapshot.defaultLayer),
@@ -332,9 +371,9 @@ function compactionProcessLayer(options?: CompactionProcessOptions) {
     Layer.provide(status),
     Layer.provide(events),
     Layer.provide(options?.config ?? Config.defaultLayer),
-    Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true })),
+    Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true, ...options?.flags })),
     Layer.provide(EventV2Bridge.defaultLayer),
-    Layer.provide(Database.defaultLayer),
+    Layer.provide(database),
     Layer.provide(PromptEpoch.defaultLayer),
   )
 }
@@ -891,6 +930,161 @@ describe("session.compaction.prune", () => {
       }),
     ),
   )
+
+  // UPD-005 — seeds a session whose history carries one completed non-protected tool result per
+  // user/assistant turn, followed by two trailing user messages so the prune scan's turns >= 2
+  // gate admits them.
+  const seedToolOutputs = (dir: string, outputs: string[]) =>
+    Effect.gen(function* () {
+      const ssn = yield* SessionNs.Service
+      const info = yield* ssn.create({})
+      const mkUser = () =>
+        ssn.updateMessage({
+          id: MessageID.ascending(),
+          role: "user",
+          sessionID: info.id,
+          agent: "build",
+          model: ref,
+          time: { created: Date.now() },
+        })
+      for (const output of outputs) {
+        const user = yield* mkUser()
+        const assistant: SessionV1.Assistant = {
+          id: MessageID.ascending(),
+          role: "assistant",
+          sessionID: info.id,
+          mode: "build",
+          agent: "build",
+          path: { cwd: dir, root: dir },
+          cost: 0,
+          tokens: { output: 0, input: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          modelID: ref.modelID,
+          providerID: ref.providerID,
+          parentID: user.id,
+          time: { created: Date.now() },
+          finish: "end_turn",
+        }
+        yield* ssn.updateMessage(assistant)
+        yield* ssn.updatePart({
+          id: PartID.ascending(),
+          messageID: assistant.id,
+          sessionID: info.id,
+          type: "tool",
+          callID: crypto.randomUUID(),
+          tool: "bash",
+          state: {
+            status: "completed",
+            input: {},
+            output,
+            title: "done",
+            metadata: {},
+            time: { start: Date.now(), end: Date.now() },
+          },
+        })
+      }
+      yield* mkUser()
+      yield* mkUser()
+      return info.id
+    })
+
+  const toolCompactionStamps = (msgs: SessionV1.WithParts[]) =>
+    msgs
+      .flatMap((msg) => msg.parts)
+      .filter((part): part is SessionV1.ToolPart => part.type === "tool")
+      .map((part) => (part.state.status === "completed" ? (part.state.time.compacted ?? null) : null))
+
+  it.live(
+    "protect is parameterized: a smaller protect window truncates more older tool results",
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          const compact = yield* SessionCompaction.Service
+          const ssn = yield* SessionNs.Service
+          // 3 × 100_000 chars = 25k tokens each (Token.estimate = chars/4). Backwards scan with
+          // the DEFAULT protect (40k) keeps the newest (cumulative 25k ≤ 40k) and truncates the
+          // two older ones; the MICRO protect (10k) keeps none and truncates all three.
+          const output = "x".repeat(100_000)
+
+          const defaultID = yield* seedToolOutputs(dir, [output, output, output])
+          yield* compact.prune({ sessionID: defaultID })
+          const defaultStamps = toolCompactionStamps(yield* ssn.messages({ sessionID: defaultID }))
+          expect(defaultStamps.filter((stamp) => stamp !== null)).toHaveLength(2)
+          expect(defaultStamps).toEqual([expect.any(Number), expect.any(Number), null])
+
+          const microID = yield* seedToolOutputs(dir, [output, output, output])
+          yield* compact.prune({ sessionID: microID, protect: SessionCompaction.MICRO_COMPACT_PROTECT })
+          const microStamps = toolCompactionStamps(yield* ssn.messages({ sessionID: microID }))
+          expect(microStamps.filter((stamp) => stamp !== null)).toHaveLength(3)
+        }),
+      {
+        config: {
+          compaction: { prune: true },
+        },
+      },
+    ),
+  )
+
+  it.live(
+    "repeated prune is idempotent: the time.compacted guard prevents double truncation",
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          const compact = yield* SessionCompaction.Service
+          const ssn = yield* SessionNs.Service
+          const output = "x".repeat(100_000)
+          const sessionID = yield* seedToolOutputs(dir, [output, output, output])
+
+          yield* compact.prune({ sessionID, protect: SessionCompaction.MICRO_COMPACT_PROTECT })
+          const firstStamps = toolCompactionStamps(yield* ssn.messages({ sessionID }))
+          expect(firstStamps.filter((stamp) => stamp !== null)).toHaveLength(3)
+
+          // Re-trigger with the SAME micro protect (repeated fallback entry) and then with the
+          // DEFAULT protect (hard-phase / turn-end prune): neither may re-truncate — the stamps
+          // must be byte-identical, proving the time.compacted guard short-circuits the scan.
+          yield* compact.prune({ sessionID, protect: SessionCompaction.MICRO_COMPACT_PROTECT })
+          yield* compact.prune({ sessionID })
+          const secondStamps = toolCompactionStamps(yield* ssn.messages({ sessionID }))
+          expect(secondStamps).toEqual(firstStamps)
+        }),
+      {
+        config: {
+          compaction: { prune: true },
+        },
+      },
+    ),
+  )
+
+  it.live(
+    "prune is deterministic: same messages + same protect ⇒ same truncated set",
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          const compact = yield* SessionCompaction.Service
+          const ssn = yield* SessionNs.Service
+          // Heterogeneous sizes so the truncation set is non-trivial: newest (22.5k) stays under
+          // the 40k protect window, the two older ones (35k + 15k cumulative beyond it) are cut.
+          const outputs = ["a".repeat(60_000), "b".repeat(140_000), "c".repeat(90_000)]
+
+          const firstID = yield* seedToolOutputs(dir, outputs)
+          const secondID = yield* seedToolOutputs(dir, outputs)
+          yield* compact.prune({ sessionID: firstID })
+          yield* compact.prune({ sessionID: secondID })
+
+          const mask = (stamps: (number | null)[]) => stamps.map((stamp) => stamp !== null)
+          const firstMask = mask(toolCompactionStamps(yield* ssn.messages({ sessionID: firstID })))
+          const secondMask = mask(toolCompactionStamps(yield* ssn.messages({ sessionID: secondID })))
+          // The compaction summary-attempt requestHash is computed over the compacted projection;
+          // a divergent truncated set between replays would desync the durable attempt record.
+          expect(firstMask).toEqual(secondMask)
+          expect(firstMask).toEqual([true, true, false])
+        }),
+      {
+        config: {
+          compaction: { prune: true },
+        },
+      },
+    ),
+  )
 })
 
 describe("session.compaction.process", () => {
@@ -2072,9 +2266,11 @@ describe("session.compaction.process", () => {
         expect(captured).toContain("<previous-summary>")
         expect(captured).toContain("summary one")
         expect(captured.match(/summary one/g)?.length).toBe(1)
-        expect(captured).toContain("## Constraints & Preferences")
-        expect(captured).toContain("## Progress")
-      }).pipe(withCompaction({ llm: stub.layer }))
+        // UPD-005: the legacy worldStateReinjection=false path renders the structured nine-section
+        // template (replaces the pre-UPD-005 "## Constraints & Preferences" / "## Progress" markers).
+        expect(captured).toContain("1. Primary Request and Intent")
+        expect(captured).toContain("9. Next Steps")
+      }).pipe(withCompaction({ llm: stub.layer, flags: { worldStateReinjection: false } }))
     },
     { git: true },
   )
@@ -2177,6 +2373,227 @@ describe("session.compaction.process", () => {
       expect(part?.tail_start_id).toBeUndefined()
     }).pipe(withCompaction({ llm: stub.layer, config: cfg({ tail_turns: 2, preserve_recent_tokens: 500 }) }))
   })
+
+  itCompaction.instance(
+    "renders the structured nine-section summary prompt on the legacy path",
+    () => {
+      const stub = llm()
+      let captured = ""
+      stub.push(reply("summary", (input) => (captured = JSON.stringify(input.messages))))
+      return Effect.gen(function* () {
+        const ssn = yield* SessionNs.Service
+        const session = yield* ssn.create({})
+        yield* createUserMessage(session.id, "older context")
+        yield* createSummaryCompaction(session.id)
+
+        const msgs = yield* ssn.messages({ sessionID: session.id })
+        const parent = msgs.at(-1)?.info.id
+        expect(parent).toBeTruthy()
+        yield* SessionCompaction.use.process({ parentID: parent!, messages: msgs, sessionID: session.id, auto: false })
+
+        expect(captured).toContain("1. Primary Request and Intent")
+        expect(captured).toContain("9. Next Steps")
+        expect(captured).toContain("<analysis>")
+        expect(captured).toContain("Respond with TEXT ONLY")
+        // Determinism: the template is a module-level constant, never the legacy free-form markers.
+        expect(SessionCompaction.STRUCTURED_SUMMARY_TEMPLATE).toContain("6. All User Messages")
+        expect(captured).not.toContain("## Goal")
+      }).pipe(withCompaction({ llm: stub.layer, flags: { worldStateReinjection: false } }))
+    },
+    { git: true },
+  )
+
+  itCompaction.instance(
+    "strips the analysis scratchpad before committing the summary",
+    () => {
+      const stub = llm()
+      stub.push(
+        reply(
+          "<analysis>scratch notes that must not survive</analysis>\n\n<summary>\n1. Primary Request and Intent:\n   - fix login\n</summary>",
+        ),
+      )
+      return Effect.gen(function* () {
+        const ssn = yield* SessionNs.Service
+        const session = yield* ssn.create({})
+        yield* createUserMessage(session.id, "older context")
+        yield* createSummaryCompaction(session.id)
+
+        const msgs = yield* ssn.messages({ sessionID: session.id })
+        const parent = msgs.at(-1)?.info.id
+        expect(parent).toBeTruthy()
+        const result = yield* SessionCompaction.use.process({
+          parentID: parent!,
+          messages: msgs,
+          sessionID: session.id,
+          auto: false,
+        })
+        expect(result).toBe("continue")
+
+        const summaryMessage = (yield* ssn.messages({ sessionID: session.id })).find(
+          (message) => message.info.role === "assistant" && message.info.summary,
+        )
+        const text = summaryMessage?.parts
+          .filter((part): part is SessionV1.TextPart => part.type === "text")
+          .map((part) => part.text)
+          .join("\n")
+        expect(text).toBeDefined()
+        expect(text).not.toContain("<analysis>")
+        expect(text).not.toContain("scratch notes")
+        expect(text).toContain("Summary:")
+        expect(text).toContain("fix login")
+
+        const { db } = yield* Database.Service
+        const run = yield* db
+          .select({ summary: CompactionRunTable.summary_text, state: CompactionRunTable.state })
+          .from(CompactionRunTable)
+          .where(eq(CompactionRunTable.session_id, session.id))
+          .get()
+          .pipe(Effect.orDie)
+        expect(run?.state).toBe("committed")
+        expect(run?.summary).not.toContain("scratch notes")
+        expect(run?.summary).toContain("fix login")
+      }).pipe(withCompaction({ llm: stub.layer }))
+    },
+    { git: true },
+  )
+})
+
+describe("session.compaction.stripSummaryAnalysis", () => {
+  test("strips the analysis scratchpad and unwraps the summary envelope", () => {
+    const out = SessionCompaction.stripSummaryAnalysis(
+      "<analysis>draft thoughts</analysis>\n\n<summary>\n1. Primary Request and Intent:\n   - fix login\n</summary>",
+    )
+    expect(out).not.toContain("draft thoughts")
+    expect(out).not.toContain("<summary>")
+    expect(out.startsWith("Summary:")).toBe(true)
+    expect(out).toContain("1. Primary Request and Intent:")
+  })
+
+  test("strips every analysis block when multiple are present", () => {
+    const out = SessionCompaction.stripSummaryAnalysis(
+      "<analysis>one</analysis>\n<summary>body</summary>\n<analysis>two</analysis>",
+    )
+    expect(out).not.toContain("one")
+    expect(out).not.toContain("two")
+    expect(out).toContain("body")
+  })
+
+  test("returns untagged text byte-for-byte unchanged", () => {
+    const text = "## Goal\n- legacy summary text"
+    expect(SessionCompaction.stripSummaryAnalysis(text)).toBe(text)
+  })
+
+  test("collapses blank lines left behind by stripping", () => {
+    const out = SessionCompaction.stripSummaryAnalysis(
+      "intro\n\n\n<analysis>x</analysis>\n\n\n<summary>kept</summary>",
+    )
+    expect(out).not.toMatch(/\n{3,}/)
+    expect(out).toContain("kept")
+  })
+})
+
+describe("session.compaction.selectPostCompactFileCandidates", () => {
+  const sessionID = SessionID.make("ses_post_compact_candidates")
+
+  const userMessage = (messageID: MessageID): SessionV1.WithParts => ({
+    info: {
+      id: messageID,
+      role: "user",
+      sessionID,
+      agent: "build",
+      model: ref,
+      time: { created: 0 },
+    },
+    parts: [],
+  })
+
+  const readMessage = (
+    messageID: MessageID,
+    reads: readonly { filePath: string; tool?: string; completed?: boolean }[],
+  ): SessionV1.WithParts => ({
+    info: userMessage(messageID).info,
+    parts: reads.map(
+      (read): SessionV1.ToolPart => ({
+        id: PartID.make(`prt_${Hash.sha256(`candidate-test:${messageID}:${read.filePath}`)}`),
+        messageID,
+        sessionID,
+        type: "tool",
+        callID: `call_${read.filePath}`,
+        tool: read.tool ?? "read",
+        state:
+          read.completed === false
+            ? {
+                status: "error",
+                input: { filePath: read.filePath },
+                error: "boom",
+                time: { start: 0, end: 0 },
+              }
+            : {
+                status: "completed",
+                input: { filePath: read.filePath },
+                output: "content",
+                title: "",
+                metadata: {},
+                time: { start: 0, end: 0 },
+              },
+      }),
+    ),
+  })
+
+  test("caps at POST_COMPACT_MAX_FILES_TO_RESTORE with most recent read first", () => {
+    const messages = [
+      readMessage(MessageID.make("msg_c1"), [{ filePath: "/repo/a.ts" }, { filePath: "/repo/b.ts" }]),
+      readMessage(MessageID.make("msg_c2"), [{ filePath: "/repo/c.ts" }, { filePath: "/repo/d.ts" }]),
+      readMessage(MessageID.make("msg_c3"), [
+        { filePath: "/repo/e.ts" },
+        { filePath: "/repo/f.ts" },
+        { filePath: "/repo/g.ts" },
+      ]),
+    ]
+    const candidates = SessionCompaction.selectPostCompactFileCandidates(messages)
+    expect(SessionCompaction.POST_COMPACT_MAX_FILES_TO_RESTORE).toBe(5)
+    expect(candidates.map((candidate) => candidate.filePath)).toEqual([
+      "/repo/g.ts",
+      "/repo/f.ts",
+      "/repo/e.ts",
+      "/repo/d.ts",
+      "/repo/c.ts",
+    ])
+  })
+
+  test("deduplicates by path keeping the most recent read", () => {
+    const messages = [
+      readMessage(MessageID.make("msg_d1"), [{ filePath: "/repo/old.ts" }]),
+      readMessage(MessageID.make("msg_d2"), [{ filePath: "/repo/new.ts" }]),
+      readMessage(MessageID.make("msg_d3"), [{ filePath: "/repo/old.ts" }]),
+    ]
+    const candidates = SessionCompaction.selectPostCompactFileCandidates(messages)
+    expect(candidates.map((candidate) => candidate.filePath)).toEqual(["/repo/old.ts", "/repo/new.ts"])
+    expect(candidates[0]?.messageID).toBe(MessageID.make("msg_d3"))
+  })
+
+  test("skips incomplete reads and non-read tools", () => {
+    const messages = [
+      readMessage(MessageID.make("msg_s1"), [
+        { filePath: "/repo/failed.ts", completed: false },
+        { filePath: "/repo/grep.ts", tool: "grep" },
+        { filePath: "/repo/kept.ts" },
+      ]),
+    ]
+    const candidates = SessionCompaction.selectPostCompactFileCandidates(messages)
+    expect(candidates.map((candidate) => candidate.filePath)).toEqual(["/repo/kept.ts"])
+  })
+
+  test("is a pure function (same input yields same output)", () => {
+    const messages = [
+      readMessage(MessageID.make("msg_p1"), [{ filePath: "/repo/a.ts" }]),
+      userMessage(MessageID.make("msg_p2")),
+    ]
+    expect(SessionCompaction.selectPostCompactFileCandidates(messages)).toEqual(
+      SessionCompaction.selectPostCompactFileCandidates(messages),
+    )
+    expect(SessionCompaction.selectPostCompactFileCandidates([])).toEqual([])
+  })
 })
 
 describe("util.token.estimate", () => {
@@ -2474,3 +2891,153 @@ describe("SessionNs.getUsage", () => {
     expect(result.tokens.cache.write).toBe(300)
   })
 })
+
+// =============================================================================
+// UPD-005 Gap 2 (§4.2/§5): the remote compaction commit path.
+// =============================================================================
+describe("session.compaction.process remote mode (UPD-005 Gap 2)", () => {
+  const remoteModel = ProviderTest.model({
+    id: ModelV2.ID.make("gpt-5-mini"),
+    limit: { context: 100_000, output: 32_000 },
+  })
+  const remoteProvider = ProviderTest.fake({
+    model: remoteModel,
+    info: ProviderTest.info({ options: { apiKey: "test-openai-key" } }, remoteModel),
+  })
+  const remoteRef = {
+    providerID: ProviderV2.ID.make("openai"),
+    modelID: ModelV2.ID.make("gpt-5-mini"),
+  }
+
+  // Mock /responses/compact executor: a direct service stub (no HttpClient in
+  // the loop) answering every request with a compaction item.
+  const compactExecutor = (encryptedContent: string): Layer.Layer<RequestExecutor.Service> =>
+    Layer.succeed(
+      RequestExecutor.Service,
+      RequestExecutor.Service.of({
+        execute: (request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(
+                JSON.stringify({ output: [{ type: "compaction", id: "cmp_1", encrypted_content: encryptedContent }] }),
+                { headers: { "content-type": "application/json" } },
+              ),
+            ),
+          ),
+      }),
+    )
+
+  function createRemoteUserMessage(sessionID: SessionID, text: string) {
+    return Effect.gen(function* () {
+      const ssn = yield* SessionNs.Service
+      const msg = yield* ssn.updateMessage({
+        id: MessageID.ascending(),
+        role: "user",
+        sessionID,
+        agent: "build",
+        model: remoteRef,
+        time: { created: Date.now() },
+      })
+      yield* ssn.updatePart({
+        id: PartID.ascending(),
+        messageID: msg.id,
+        sessionID,
+        type: "text",
+        text,
+      })
+      return msg
+    })
+  }
+
+  itCompaction.instance(
+    "commits remote compaction: mode columns, durable blob, no summary and no marker part",
+    Effect.gen(function* () {
+      const db = (yield* Database.Service).db
+      // The migration is not registered in migration.gen.ts yet (mainline does
+      // that), so apply it explicitly — tracked, hence idempotent.
+      yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistenceMigration])
+      const ssn = yield* SessionNs.Service
+      const session = yield* ssn.create({})
+      const msg = yield* createRemoteUserMessage(session.id, "compact me")
+      const msgs = yield* ssn.messages({ sessionID: session.id })
+
+      const result = yield* SessionCompaction.use.process({
+        parentID: msg.id,
+        messages: msgs,
+        sessionID: session.id,
+        auto: false,
+      }).pipe(withCompaction({ provider: remoteProvider, executor: compactExecutor("enc-remote-commit") }))
+      expect(result).toBe("stop")
+
+      // Run columns (§4.2): committed remote mode, blob pointer, no summary text.
+      const runs = yield* db.select().from(CompactionRunTable).all()
+      expect(runs).toHaveLength(1)
+      const run = runs[0]!
+      expect(run.state).toBe("committed")
+      expect(run.compaction_mode).toBe("remote_compact")
+      expect(run.encrypted_content_session).toBe(session.id)
+      expect(run.summary_text).toBeNull()
+      expect(run.completion_reason).toBe("manual")
+
+      // Store persistence (Gap 1): the blob is durably attributed.
+      const blob = yield* db
+        .select()
+        .from(SessionCompactionEncryptedContentTable)
+        .where(eq(SessionCompactionEncryptedContentTable.session_id, session.id))
+        .get()
+      expect(blob?.encrypted_content).toBe("enc-remote-commit")
+      expect(blob?.provider_id).toBe("openai")
+      expect(blob?.model_id).toBe("gpt-5-mini")
+      expect(blob?.source_run_id).toBe(run.run_id)
+      // A freshly bound store (i.e. after a restart) reads the blob back from the
+      // table — the compaction layer above has already finalized and unbound.
+      EncryptedContentStore.bind(db)
+      expect(EncryptedContentStore.get(session.id)).toBe("enc-remote-commit")
+      EncryptedContentStore.bind(undefined)
+
+      // No TEXT summary, no marker part: remote mode commits invisibly.
+      const after = yield* ssn.messages({ sessionID: session.id })
+      expect(after.some((message) => message.parts.some((part) => part.type === "compaction"))).toBe(false)
+      expect(after.some((message) => message.info.role === "assistant")).toBe(false)
+    }),
+  )
+})
+
+describe("remote compaction information-hole exemption", () => {
+  test("exempts committed remote runs that carry a blob pointer", () => {
+    expect(
+      SessionCompaction.remoteCompactionInformationHoleExempt({
+        compaction_mode: "remote_compact",
+        encrypted_content_session: "ses_remote",
+      }),
+    ).toBe(true)
+  })
+
+  test("keeps every other shape subject to the information-hole check", () => {
+    expect(
+      SessionCompaction.remoteCompactionInformationHoleExempt({
+        compaction_mode: "local_summary",
+        encrypted_content_session: "ses_remote",
+      }),
+    ).toBe(false)
+    expect(
+      SessionCompaction.remoteCompactionInformationHoleExempt({
+        compaction_mode: "remote_compact",
+        encrypted_content_session: null,
+      }),
+    ).toBe(false)
+    expect(
+      SessionCompaction.remoteCompactionInformationHoleExempt({
+        compaction_mode: "remote_compact",
+        encrypted_content_session: "",
+      }),
+    ).toBe(false)
+    expect(
+      SessionCompaction.remoteCompactionInformationHoleExempt({
+        compaction_mode: null,
+        encrypted_content_session: null,
+      }),
+    ).toBe(false)
+  })
+})
diff --git a/packages/deepagent-code/test/session/context-window.test.ts b/packages/deepagent-code/test/session/context-window.test.ts
index 10dee3d2..999aa1a5 100644
--- a/packages/deepagent-code/test/session/context-window.test.ts
+++ b/packages/deepagent-code/test/session/context-window.test.ts
@@ -16,10 +16,13 @@ import { and, eq } from "drizzle-orm"
 import { MessageV2 } from "@/session/message-v2"
 import { SessionPromptEpochTable } from "@/session/prompt-epoch.sql"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { MessageID, PartID, type SessionID } from "@/session/schema"
 import { testEffect } from "../lib/effect"
 
-const it = testEffect(Layer.mergeAll(Session.defaultLayer, Database.defaultLayer))
+// QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+// writes hit the session FK.
+const it = testEffect(Layer.mergeAll(Session.defaultLayer, SessionProjector.defaultLayer, Database.defaultLayer))
 
 const addUser = Effect.fn("ContextWindowTest.addUser")(function* (sessionID: SessionID, text: string) {
   const sessions = yield* Session.Service
diff --git a/packages/deepagent-code/test/session/diff-artifact.test.ts b/packages/deepagent-code/test/session/diff-artifact.test.ts
index 81b8fc90..f427b92e 100644
--- a/packages/deepagent-code/test/session/diff-artifact.test.ts
+++ b/packages/deepagent-code/test/session/diff-artifact.test.ts
@@ -18,7 +18,11 @@ import { MessageV2 } from "@/session/message-v2"
 import { MessageID } from "@/session/schema"
 import { Session } from "@/session/session"
 import { SessionDiffArtifact } from "@/session/diff-artifact"
-import { SessionDiffArtifactFileChunkTable, SessionDiffMigrationReceiptTable } from "@/session/diff-artifact.sql"
+import {
+  SessionDiffArtifactFileChunkTable,
+  SessionDiffArtifactFileTable,
+  SessionDiffMigrationReceiptTable,
+} from "@/session/diff-artifact.sql"
 import { SessionPromptEpochTable } from "@/session/prompt-epoch.sql"
 import { SessionPaths } from "@/server/routes/instance/httpapi/groups/session"
 import { and, asc, eq, sql } from "drizzle-orm"
@@ -632,3 +636,186 @@ describe("Session legacy diff physical migration", () => {
     30_000,
   )
 })
+
+describe("Session runtime diff artifact capture", () => {
+  it.instance(
+    "capture converges a runtime user summary diff onto session_diff_artifact (direct invocation; updateMessage wiring is staged behind DEEPAGENT_CODE_SESSION_DIFF_ARTIFACT_CAPTURE)",
+    () =>
+      Effect.gen(function* () {
+        const sessions = yield* Session.Service
+        const { db } = yield* Database.Service
+        const session = yield* sessions.create({ title: "runtime capture" })
+        const patch = "@@ -1 +1 @@\n-legacy\n+canonical"
+        const info = {
+          id: MessageID.ascending(),
+          sessionID: session.id,
+          role: "user" as const,
+          agent: "build",
+          model: { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("model") },
+          time: { created: Date.now() },
+          summary: {
+            diffs: [{ file: "src/runtime.ts", patch, additions: 1, deletions: 1, status: "modified" as const }],
+          },
+        } as unknown as SessionV1.User
+        const before = HistoryAuthority.hash([{ info, parts: [] }])
+
+        yield* sessions.updateMessage(info)
+
+        // The updateMessage wiring is staged behind DEEPAGENT_CODE_SESSION_DIFF_ARTIFACT_CAPTURE
+        // (default OFF: the bug-407-010 hotfix contract holds until the §14 evidence chain lands),
+        // so invoke capture directly against the committed message.updated event to lock the
+        // converged path itself.
+        const sourceEvent = yield* db
+          .select({ id: EventTable.id })
+          .from(EventTable)
+          .where(and(eq(EventTable.aggregate_id, session.id), sql`${EventTable.type} LIKE 'message.updated.%'`))
+          .orderBy(sql`${EventTable.seq} DESC`)
+          .get()
+          .pipe(Effect.orDie)
+        if (!sourceEvent) return yield* Effect.die(new Error("expected a message.updated event for capture"))
+        yield* SessionDiffArtifact.capture({
+          sessionID: session.id,
+          messageID: info.id,
+          sourceEventID: sourceEvent.id,
+        }).pipe(Effect.orDie)
+
+        const raw = yield* db.get<{ data: string }>(
+          sql`SELECT CAST(data AS TEXT) AS data FROM message WHERE id = ${info.id}`,
+        )
+        expect(raw?.data).not.toContain('"patch"')
+        expect(raw?.data).not.toContain('"diffs"')
+        const stored = yield* MessageV2.get({ sessionID: session.id, messageID: info.id })
+        expect(stored.info.role === "user" ? stored.info.summary?.diffs : undefined).toEqual([])
+        const artifactID = stored.info.role === "user" ? stored.info.summary?.diffArtifact?.id : undefined
+        expect(artifactID).toBeDefined()
+        expect(stored.info.role === "user" ? stored.info.summary?.diffArtifact?.hash : undefined).toBe(
+          Hash.sha256(Buffer.from(JSON.stringify({ diffs: [{ file: "src/runtime.ts", patch, additions: 1, deletions: 1, status: "modified" }] }))),
+        )
+        expect(HistoryAuthority.hash([stored])).toBe(before)
+        const receipt = yield* db
+          .select()
+          .from(SessionDiffMigrationReceiptTable)
+          .where(eq(SessionDiffMigrationReceiptTable.message_id, info.id))
+          .get()
+          .pipe(Effect.orDie)
+        expect(receipt).toMatchObject({
+          state: "committed",
+          artifact_id: artifactID,
+          canonicalizer_version: 2,
+        })
+        expect(receipt?.committed_session_summary_hash).toBe(Hash.sha256("null"))
+        const eventArtifact = yield* db
+          .select()
+          .from(EventArtifactTable)
+          .where(eq(EventArtifactTable.artifact_id, receipt!.artifact_id))
+          .get()
+          .pipe(Effect.orDie)
+        expect(eventArtifact).toMatchObject({
+          kind: "legacy_message_diff",
+          codec_version: 2,
+          aggregate_id: session.id,
+          event_id: receipt!.source_event_id,
+        })
+        const files = yield* db
+          .select()
+          .from(SessionDiffArtifactFileTable)
+          .where(eq(SessionDiffArtifactFileTable.artifact_id, receipt!.artifact_id))
+          .all()
+          .pipe(Effect.orDie)
+        expect(files).toHaveLength(1)
+        expect(files[0]).toMatchObject({
+          path: "src/runtime.ts",
+          additions: 1,
+          deletions: 1,
+          status: "modified",
+          patch_hash: Hash.sha256(Buffer.from(patch)),
+        })
+        const chunks = yield* db
+          .select()
+          .from(SessionDiffArtifactFileChunkTable)
+          .where(eq(SessionDiffArtifactFileChunkTable.artifact_id, receipt!.artifact_id))
+          .orderBy(asc(SessionDiffArtifactFileChunkTable.chunk_index))
+          .all()
+          .pipe(Effect.orDie)
+        expect(Buffer.concat(chunks.map((chunk) => chunk.data)).toString()).toBe(patch)
+        // exact-retry parity: a second capture observes the committed receipt and skips.
+        expect(
+          yield* SessionDiffArtifact.capture({
+            sessionID: session.id,
+            messageID: info.id,
+            sourceEventID: receipt!.source_event_id as EventV2.ID,
+            now: 500,
+          }),
+        ).toEqual({ state: "skipped" })
+        const manifestResponse = yield* request(
+          `${pathFor(SessionPaths.diffArtifactManifest, session.id)}?${new URLSearchParams({
+            messageID: info.id,
+            artifactID: artifactID!,
+          })}`,
+        )
+        expect(manifestResponse.status).toBe(200)
+        const manifest = yield* json<typeof SessionDiffArtifact.Manifest.Type>(manifestResponse)
+        expect(manifest.files).toEqual([
+          expect.objectContaining({ file: "src/runtime.ts", patchBytes: Buffer.byteLength(patch) }),
+        ])
+        const fileResponse = yield* request(
+          `${pathFor(SessionPaths.diffArtifactFile, session.id)}?${new URLSearchParams({
+            messageID: info.id,
+            artifactID: artifactID!,
+            path: "src/runtime.ts",
+          })}`,
+        )
+        expect(fileResponse.status).toBe(200)
+        expect(yield* json<typeof SessionDiffArtifact.File.Type>(fileResponse)).toMatchObject({
+          patch,
+          truncated: false,
+        })
+      }),
+    { git: true },
+    30_000,
+  )
+
+  it.instance(
+    "leaves a runtime message that already carries a diffArtifact descriptor uncaptured",
+    () =>
+      Effect.gen(function* () {
+        const sessions = yield* Session.Service
+        const { db } = yield* Database.Service
+        const session = yield* sessions.create({ title: "runtime captured upstream" })
+        const info = {
+          id: MessageID.ascending(),
+          sessionID: session.id,
+          role: "user" as const,
+          agent: "build",
+          model: { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("model") },
+          time: { created: Date.now() },
+          summary: {
+            diffs: [],
+            diffArtifact: {
+              id: "evtart_upstream_descriptor",
+              hash: Hash.sha256("upstream"),
+              codec: "legacy-message-diff.v2",
+              fileCount: 1,
+              previewFileCount: 1,
+              previewTruncated: false,
+            },
+          },
+        } as unknown as SessionV1.User
+        yield* sessions.updateMessage(info)
+        expect(
+          yield* db
+            .select()
+            .from(SessionDiffMigrationReceiptTable)
+            .where(eq(SessionDiffMigrationReceiptTable.message_id, info.id))
+            .all()
+            .pipe(Effect.orDie),
+        ).toEqual([])
+        const stored = yield* MessageV2.get({ sessionID: session.id, messageID: info.id })
+        expect(stored.info.role === "user" ? stored.info.summary?.diffArtifact?.id : undefined).toBe(
+          "evtart_upstream_descriptor",
+        )
+      }),
+    { git: true },
+    30_000,
+  )
+})
diff --git a/packages/deepagent-code/test/session/facade-activity.test.ts b/packages/deepagent-code/test/session/facade-activity.test.ts
new file mode 100644
index 00000000..040eb21d
--- /dev/null
+++ b/packages/deepagent-code/test/session/facade-activity.test.ts
@@ -0,0 +1,491 @@
+/**
+ * FEAT-011 T3/T6 — FacadeActivity dispatcher tests.
+ *
+ * Covers: budget min-clamping + result bound (pure), goal delegation lifecycle (start/status/
+ * result/control + lazy convergence settle), the partial-unique-index fail-closed admission
+ * fence, delegation-failure settlement (active rows never linger without a runner), task/panel
+ * runner-unavailable honesty (no fabricated control), panel stop + convergence via a fake
+ * background-job surface, and the status list bound.
+ */
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { eq } from "drizzle-orm"
+import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
+import { Database } from "@deepagent-code/core/database/database"
+import { SessionFacadeActivityTable } from "@deepagent-code/core/deepagent/activity-authority.sql"
+import { ProjectV2 } from "@deepagent-code/core/project"
+import { ProjectTable } from "@deepagent-code/core/project/sql"
+import { AbsolutePath } from "@deepagent-code/core/schema"
+import { SessionTable } from "@deepagent-code/core/session/sql"
+import { BackgroundJob } from "@/background/job"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { GoalManager } from "@/session/goal-manager"
+import { SessionID } from "@/session/schema"
+import {
+  applyResultBound,
+  clampFacadeBudget,
+  FACADE_POLICY_LIMITS,
+  FacadeActivity,
+  FacadeActivityConflict,
+  FacadeActivityInvalidInput,
+  FacadeActivityNotFound,
+  FacadeActivityRunnerUnavailable,
+  FacadeActivityUnsupportedControl,
+} from "@/session/facade-activity"
+import { testEffect } from "../lib/effect"
+
+const database = Layer.mergeAll(Database.layerFromPath(":memory:"), CrossSpawnSpawner.defaultLayer)
+const facadeLayer = Layer.effect(FacadeActivity.Service, FacadeActivity.build)
+
+const parentSessionID = SessionID.make("ses_facade_parent")
+const otherSessionID = SessionID.make("ses_facade_other")
+
+// Seed the FK parents (session_facade_activity.parent_session_id references session.id).
+const setup = Effect.gen(function* () {
+  const { db } = yield* Database.Service
+  yield* db
+    .insert(ProjectTable)
+    .values({ id: ProjectV2.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+  for (const id of [parentSessionID, otherSessionID]) {
+    yield* db
+      .insert(SessionTable)
+      .values({
+        id,
+        project_id: ProjectV2.ID.global,
+        slug: `facade-${id}`,
+        directory: "/project",
+        title: "facade parent",
+        version: "test",
+      })
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+  }
+})
+
+const latestRow = (sessionID: SessionID, subkind: "task" | "goal" | "panel") =>
+  Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    return yield* db
+      .select()
+      .from(SessionFacadeActivityTable)
+      .where(eq(SessionFacadeActivityTable.parent_session_id, sessionID))
+      .all()
+      .pipe(
+        Effect.orDie,
+        Effect.map((rows) => rows.filter((row) => row.subkind === subkind).at(-1)),
+      )
+  })
+
+// ── fake GoalManager (records calls; phase is steerable per test) ─────────────────────────────
+
+const goalFakeState: {
+  phase: string
+  started: Array<{ objective?: string; limits?: { maxTicks?: number; maxTokens?: number; maxWallclockMs?: number } }>
+} = { phase: "running", started: [] }
+
+const fakeGoals = {
+  start: (input: { objective?: string; limits?: { maxTicks?: number; maxTokens?: number; maxWallclockMs?: number } }) =>
+    Effect.sync(() => {
+      goalFakeState.started.push(input)
+      return { goalId: "goal_1", planDocId: "plan_1", phase: "running", running: true } as const
+    }),
+  pause: () => Effect.succeed(true),
+  resume: () => Effect.succeed(true),
+  stop: () => Effect.succeed(true),
+  status: () =>
+    Effect.succeed({ goalId: "goal_1", planDocId: "plan_1", phase: goalFakeState.phase, running: goalFakeState.phase === "running" }),
+  startable: () => Effect.succeed({ startable: true, source: "plan" as const }),
+  editPlan: () => Effect.die("unused in facade tests"),
+} as unknown as GoalManager.Interface
+
+const resetGoalFake = () => {
+  goalFakeState.phase = "running"
+  goalFakeState.started = []
+}
+
+// ── fake BackgroundJob (only the surface the panel branch touches) ─────────────────────────────
+
+const panelJobs = new Map<string, { status: string }>()
+
+const fakeBackground = {
+  get: (id: string) => Effect.succeed(panelJobs.has(id) ? ({ id, status: panelJobs.get(id)!.status } as any) : undefined),
+  cancel: (id: string) =>
+    Effect.sync(() => {
+      const job = panelJobs.get(id)
+      if (!job || job.status !== "running") return undefined
+      job.status = "cancelled"
+      return { id, status: "cancelled" } as any
+    }),
+} as unknown as BackgroundJob.Interface
+
+// ── layer variants ─────────────────────────────────────────────────────────────────────────────
+
+const it = testEffect(facadeLayer.pipe(Layer.provideMerge(Layer.mergeAll(database, RuntimeFlags.layer({})))))
+const itGoal = testEffect(
+  facadeLayer.pipe(
+    Layer.provideMerge(Layer.mergeAll(database, RuntimeFlags.layer({}), Layer.succeed(GoalManager.Service, fakeGoals))),
+  ),
+)
+const itPanel = testEffect(
+  facadeLayer.pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(database, RuntimeFlags.layer({}), Layer.succeed(BackgroundJob.Service, fakeBackground)),
+    ),
+  ),
+)
+const itDurable = testEffect(
+  facadeLayer.pipe(
+    Layer.provideMerge(Layer.mergeAll(database, RuntimeFlags.layer({ subagentControlPlane: "durable" }))),
+  ),
+)
+
+describe("facade-activity.budget", () => {
+  it.effect("clamps model limits with min against the policy ceiling", () =>
+    Effect.gen(function* () {
+      // No request ⇒ the ceiling itself (never looser, never invented tighter).
+      expect(clampFacadeBudget()).toEqual(FACADE_POLICY_LIMITS)
+      // Oversized request ⇒ clamped down to the ceiling.
+      expect(
+        clampFacadeBudget({ maxTicks: 999_999, maxTokens: 999_999_999, maxWallclockMs: Number.MAX_SAFE_INTEGER }),
+      ).toEqual(FACADE_POLICY_LIMITS)
+      // Tighter request ⇒ kept verbatim (floor semantics).
+      expect(clampFacadeBudget({ maxTicks: 3, maxTokens: 1000, maxWallclockMs: 5000 })).toEqual({
+        maxTicks: 3,
+        maxTokens: 1000,
+        maxWallclockMs: 5000,
+      })
+      // Invalid fields (0/negative/NaN/non-integral) fall back to the ceiling per field.
+      expect(clampFacadeBudget({ maxTicks: 0, maxTokens: -5, maxWallclockMs: Number.NaN })).toEqual(
+        FACADE_POLICY_LIMITS,
+      )
+      expect(clampFacadeBudget({ maxTicks: 7.9 }).maxTicks).toBe(7)
+    }),
+  )
+
+  it.effect("applyResultBound truncates code-point-safely with a marker", () =>
+    Effect.gen(function* () {
+      expect(applyResultBound("short", 10)).toEqual({ text: "short", truncated: false })
+      const bounded = applyResultBound("a".repeat(50), 10)
+      expect(bounded.truncated).toBe(true)
+      expect(bounded.text.endsWith("…[truncated]")).toBe(true)
+      expect(Array.from(bounded.text.replace("…[truncated]", "")).length).toBe(10)
+      // Never splits a surrogate pair: bound between the two units of one code point.
+      const emoji = "😀".repeat(5) // 5 astral chars = 10 utf16 units
+      const pair = applyResultBound(emoji, 3)
+      expect(pair.truncated).toBe(true)
+      expect(pair.text.startsWith("😀😀😀")).toBe(true)
+    }),
+  )
+})
+
+describe("facade-activity.goal delegation", () => {
+  itGoal.instance("start writes the active row, min-clamps the budget, and returns the goal ref", () =>
+    Effect.gen(function* () {
+      resetGoalFake()
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const started = yield* facade.start({
+        sessionID: parentSessionID,
+        subkind: "goal",
+        objective: "make the widget green",
+        budget: { maxTicks: 999_999, maxTokens: 42 },
+      })
+      expect(started.subkind).toBe("goal")
+      expect(started.ref.goalID).toBe("goal_1")
+      expect(started.budget).toEqual({
+        maxTicks: FACADE_POLICY_LIMITS.maxTicks,
+        maxTokens: 42,
+        maxWallclockMs: FACADE_POLICY_LIMITS.maxWallclockMs,
+      })
+      // The delegated GoalManager.start received the CLAMPED limits (min semantics).
+      expect(goalFakeState.started).toHaveLength(1)
+      expect(goalFakeState.started[0]!.limits).toEqual(started.budget)
+
+      const row = yield* latestRow(parentSessionID, "goal")
+      expect(row?.state).toBe("active")
+      expect(row?.objective_text).toBe("make the widget green")
+      expect(row?.source).toBe("activity_facade")
+    }),
+  )
+
+  itGoal.instance("fail-closed: a second active goal facade for the same session is refused", () =>
+    Effect.gen(function* () {
+      resetGoalFake()
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      yield* facade.start({ sessionID: parentSessionID, subkind: "goal", objective: "first" })
+      const second = yield* facade
+        .start({ sessionID: parentSessionID, subkind: "goal", objective: "second" })
+        .pipe(Effect.flip)
+      expect(second).toBeInstanceOf(FacadeActivityConflict)
+      // A DIFFERENT session is unaffected by the per-session fence.
+      yield* facade.start({ sessionID: otherSessionID, subkind: "goal", objective: "other session" })
+    }),
+  )
+
+  itGoal.instance("status/result stay bounded while active; terminal phase converges via settle", () =>
+    Effect.gen(function* () {
+      resetGoalFake()
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const started = yield* facade.start({ sessionID: parentSessionID, subkind: "goal", objective: "long goal" })
+
+      // While running: status is active with the goal ref; result refuses the terminal projection.
+      const active = yield* facade.status({ sessionID: parentSessionID })
+      expect(active).toHaveLength(1)
+      expect(active[0]!.state).toBe("active")
+      expect(active[0]!.ref.goalID).toBe("goal_1")
+      const pending = yield* facade.result({ sessionID: parentSessionID, subkind: "goal" })
+      expect(pending.terminal).toBe(false)
+      expect(pending.state).toBe("active")
+
+      // control delegates pause/resume/stop to GoalManager.
+      expect((yield* facade.control({ sessionID: parentSessionID, subkind: "goal", action: "pause" })).applied).toBe(true)
+      expect((yield* facade.control({ sessionID: parentSessionID, subkind: "goal", action: "resume" })).applied).toBe(true)
+
+      // steer without a message fails closed (and no steer buffer exists in this graph).
+      const noMessage = yield* facade
+        .control({ sessionID: parentSessionID, subkind: "goal", action: "steer" })
+        .pipe(Effect.flip)
+      expect(noMessage).toBeInstanceOf(FacadeActivityInvalidInput)
+      const steer = yield* facade
+        .control({ sessionID: parentSessionID, subkind: "goal", action: "steer", message: "go left" })
+        .pipe(Effect.flip)
+      expect(steer).toBeInstanceOf(FacadeActivityRunnerUnavailable)
+
+      // The domain reaches a terminal phase → the next touch settles the facade row (authority).
+      goalFakeState.phase = "done"
+      expect((yield* facade.control({ sessionID: parentSessionID, subkind: "goal", action: "stop" })).applied).toBe(true)
+      const settled = yield* facade.status({ sessionID: parentSessionID })
+      expect(settled[0]!.state).toBe("settled")
+      expect(settled[0]!.reason).toBe("goal_done")
+
+      // T6: the result now projects ONLY the terminal view.
+      const projection = yield* facade.result({ sessionID: parentSessionID, subkind: "goal" })
+      expect(projection.terminal).toBe(true)
+      expect(projection.state).toBe("settled")
+      expect(projection.phase).toBe("done")
+      expect(projection.activityID).toBe(started.activityID)
+
+      // A settled facade frees the unique index: a new goal start is admitted again.
+      const restarted = yield* facade.start({ sessionID: parentSessionID, subkind: "goal", objective: "next" })
+      expect(restarted.activityID).not.toBe(started.activityID)
+    }),
+  )
+
+  itGoal.instance("result for a session without a facade activity fails NotFound", () =>
+    Effect.gen(function* () {
+      resetGoalFake()
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const error = yield* facade.result({ sessionID: otherSessionID, subkind: "task" }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(FacadeActivityNotFound)
+      const controlError = yield* facade
+        .control({ sessionID: otherSessionID, subkind: "goal", action: "stop" })
+        .pipe(Effect.flip)
+      expect(controlError).toBeInstanceOf(FacadeActivityNotFound)
+    }),
+  )
+})
+
+describe("facade-activity.runner honesty (no fabricated runners)", () => {
+  it.instance("goal start without GoalManager settles the admitted row as failed (no lingering active)", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const error = yield* facade.start({ sessionID: parentSessionID, subkind: "goal", objective: "x" }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(FacadeActivityRunnerUnavailable)
+      // Delegation failure must settle the freshly-admitted row — an orphan active row would
+      // block the unique index forever.
+      const row = yield* latestRow(parentSessionID, "goal")
+      expect(row?.state).toBe("failed")
+      expect(row?.reason_code?.startsWith("start_failed:")).toBe(true)
+      // …and the failed row must NOT block a retry (fail-closed applies to ACTIVE rows only).
+      const retry = yield* facade.start({ sessionID: parentSessionID, subkind: "goal", objective: "y" }).pipe(Effect.flip)
+      expect(retry).toBeInstanceOf(FacadeActivityRunnerUnavailable)
+    }),
+  )
+
+  it.instance("empty objective is rejected before any row is written", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const error = yield* facade.start({ sessionID: parentSessionID, subkind: "goal", objective: "   " }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(FacadeActivityInvalidInput)
+      expect(yield* latestRow(parentSessionID, "goal")).toBeUndefined()
+    }),
+  )
+
+  it.instance("task start refuses unless the durable control plane is enabled", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const error = yield* facade.start({ sessionID: parentSessionID, subkind: "task", objective: "x" }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(FacadeActivityRunnerUnavailable)
+      expect((error as FacadeActivityRunnerUnavailable).reason).toContain("durable")
+    }),
+  )
+
+  itDurable.instance("task start under durable still refuses without session/agent/provider services", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const error = yield* facade.start({ sessionID: parentSessionID, subkind: "task", objective: "x" }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(FacadeActivityRunnerUnavailable)
+      const row = yield* latestRow(parentSessionID, "task")
+      expect(row?.state).toBe("failed")
+    }),
+  )
+
+  it.instance("panel start refuses without its runner dependencies", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const facade = yield* FacadeActivity.Service
+      const error = yield* facade.start({ sessionID: parentSessionID, subkind: "panel", objective: "x" }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(FacadeActivityRunnerUnavailable)
+    }),
+  )
+
+  it.instance("task/panel pause+resume are NOT fabricated — only stop is delegated", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      // Seed settled rows so control() finds a latest facade per subkind.
+      const now = Date.now()
+      for (const [index, subkind] of ["task", "panel"].entries()) {
+        yield* db
+          .insert(SessionFacadeActivityTable)
+          .values({
+            activity_id: `job_seed_${subkind}`,
+            subkind: subkind as "task" | "panel",
+            parent_session_id: parentSessionID,
+            objective_text: `seed ${subkind}`,
+            budget_json: clampFacadeBudget(),
+            state: "active",
+            source: "test",
+            created_at: now + index,
+            mutation_epoch: 0,
+          })
+          .run()
+          .pipe(Effect.orDie)
+      }
+      const facade = yield* FacadeActivity.Service
+      for (const subkind of ["task", "panel"] as const) {
+        for (const action of ["pause", "resume", "steer"] as const) {
+          const error = yield* facade.control({ sessionID: parentSessionID, subkind, action }).pipe(Effect.flip)
+          expect(error).toBeInstanceOf(FacadeActivityUnsupportedControl)
+        }
+      }
+    }),
+  )
+})
+
+describe("facade-activity.panel stop + convergence", () => {
+  itPanel.instance("panel stop cancels the job and converges the facade row to interrupted", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      const activityID = "job_panel_test"
+      yield* db
+        .insert(SessionFacadeActivityTable)
+        .values({
+          activity_id: activityID,
+          subkind: "panel",
+          parent_session_id: parentSessionID,
+          objective_text: "which design should we take?",
+          budget_json: clampFacadeBudget(),
+          state: "active",
+          source: "activity_facade",
+          created_at: Date.now(),
+          mutation_epoch: 0,
+        })
+        .run()
+        .pipe(Effect.orDie)
+      panelJobs.set(activityID, { status: "running" })
+
+      const facade = yield* FacadeActivity.Service
+      const outcome = yield* facade.control({ sessionID: parentSessionID, subkind: "panel", action: "stop" })
+      expect(outcome.applied).toBe(true)
+
+      const rows = yield* facade.status({ sessionID: parentSessionID, subkind: "panel" })
+      expect(rows).toHaveLength(1)
+      expect(rows[0]!.state).toBe("interrupted")
+      expect(rows[0]!.reason).toBe("panel_cancelled")
+
+      const projection = yield* facade.result({ sessionID: parentSessionID, subkind: "panel" })
+      expect(projection.terminal).toBe(true)
+      expect(projection.state).toBe("interrupted")
+      panelJobs.clear()
+    }),
+  )
+
+  itPanel.instance("panel stop without a running job reports applied=false but still converges if terminal", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      const activityID = "job_panel_idle"
+      yield* db
+        .insert(SessionFacadeActivityTable)
+        .values({
+          activity_id: activityID,
+          subkind: "panel",
+          parent_session_id: parentSessionID,
+          objective_text: "idle panel",
+          budget_json: clampFacadeBudget(),
+          state: "active",
+          source: "activity_facade",
+          created_at: Date.now(),
+          mutation_epoch: 0,
+        })
+        .run()
+        .pipe(Effect.orDie)
+      // No job registered at all: cancel is a no-op, convergence keeps the row active.
+      panelJobs.clear()
+      const facade = yield* FacadeActivity.Service
+      const outcome = yield* facade.control({ sessionID: parentSessionID, subkind: "panel", action: "stop" })
+      expect(outcome.applied).toBe(false)
+      const rows = yield* facade.status({ sessionID: parentSessionID, subkind: "panel" })
+      expect(rows[0]!.state).toBe("active")
+    }),
+  )
+})
+
+describe("facade-activity.status bound", () => {
+  it.instance("status never returns more than the ceiling and honors the requested limit", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      const now = Date.now()
+      for (let index = 0; index < 25; index++) {
+        yield* db
+          .insert(SessionFacadeActivityTable)
+          .values({
+            activity_id: `job_bound_${index}`,
+            subkind: "goal",
+            parent_session_id: parentSessionID,
+            objective_text: `objective ${index}`,
+            budget_json: clampFacadeBudget(),
+            state: "failed",
+            reason_code: "start_failed:test",
+            source: "test",
+            created_at: now + index,
+            settled_at: now + index,
+            mutation_epoch: 1,
+          })
+          .run()
+          .pipe(Effect.orDie)
+      }
+      const facade = yield* FacadeActivity.Service
+      const capped = yield* facade.status({ sessionID: parentSessionID, limit: 99 })
+      expect(capped).toHaveLength(20)
+      const bounded = yield* facade.status({ sessionID: parentSessionID, limit: 3 })
+      expect(bounded).toHaveLength(3)
+      // Newest first.
+      expect(bounded[0]!.activityID).toBe("job_bound_24")
+    }),
+  )
+})
diff --git a/packages/deepagent-code/test/session/goal-driver.test.ts b/packages/deepagent-code/test/session/goal-driver.test.ts
index d63d6d2b..a330f70c 100644
--- a/packages/deepagent-code/test/session/goal-driver.test.ts
+++ b/packages/deepagent-code/test/session/goal-driver.test.ts
@@ -192,6 +192,34 @@ describe("startGoal + runToCompletion", () => {
     expect(outcome).toBe("needs_human")
   })
 
+  test("BUG-004 lock: budget exhaustion halts the driver (never loops past maxTicks)", async () => {
+    // An executor that never completes the plan and never makes progress: the ONLY thing allowed to
+    // stop the drive is the budget ceiling (maxTicks). stallThreshold is set high so stall cannot fire
+    // first — this pins that the loop's hard budget is what halts the driver, and that it runs at most
+    // maxTicks executor turns (the pre-execution ceiling), never an unbounded continuation.
+    const planDocId = materializePlanDoc({ store, sessionId: SESSION, plan: plan([step("a", "pending")]) })
+    let execCount = 0
+    const deps = controllerDeps({
+      executor: () =>
+        Effect.sync(() => {
+          execCount += 1
+          return { tokensUsed: 10 }
+        }),
+    })
+    const { handle } = await Effect.runPromise(
+      startGoal({
+        deps,
+        planDocId,
+        criteria: [{ kind: "plan_complete" }],
+        limits: { maxTicks: 2, maxTokens: 10_000, maxWallclockMs: 10_000 },
+        stallThreshold: 99,
+      }),
+    )
+    const outcome = await Effect.runPromise(runToCompletion({ deps, handle }))
+    expect(outcome).toBe("needs_human")
+    expect(execCount).toBeLessThanOrEqual(2)
+  })
+
   test("shouldPause suspends without a terminal outcome (resumes on next run)", async () => {
     const planDocId = materializePlanDoc({ store, sessionId: SESSION, plan: plan([step("a", "pending")]) })
     const deps = controllerDeps()
diff --git a/packages/deepagent-code/test/session/goal-tick-consumer.test.ts b/packages/deepagent-code/test/session/goal-tick-consumer.test.ts
index ddf169c0..fbdfc6a9 100644
--- a/packages/deepagent-code/test/session/goal-tick-consumer.test.ts
+++ b/packages/deepagent-code/test/session/goal-tick-consumer.test.ts
@@ -34,7 +34,9 @@ const makeLayer = (opts: {
   return Layer.mergeAll(consumer, busLayer, flagLayer, database)
 }
 
-const seq0Command = (over?: Partial<{ sessionID: string; goalId: string; planDocId: string; seq: number }>) => ({
+const seq0Command = (
+  over?: Partial<{ sessionID: string; goalId: string; planDocId: string; seq: number; workspaceID: string }>,
+) => ({
   sessionID: "s1",
   goalId: "g1",
   planDocId: "plan-1",
@@ -77,6 +79,23 @@ describe("GoalTickConsumer — command identity", () => {
     })
     expect(recoverGoalTickRequest(request, { seq: 3, planVersion: 1, phase: "running" })).toBe("invalid")
   })
+
+  // FEATURE-003-407 residual: the durable event row's workspace_id drives groupsFor's workspace-scoped
+  // routing, so tickCommand must stamp the REAL workspace id there — never the sessionID.
+  test("tickCommand stamps the real workspaceID onto the event row (not the sessionID)", () => {
+    const cmd = GoalTickConsumer.tickCommand({ ...seq0Command(), workspaceID: "wrk_a" })
+    expect(cmd.workspaceID).toBe("wrk_a")
+    expect(cmd.workspaceID).not.toBe(cmd.payload && (cmd.payload as Record<string, unknown>).sessionID)
+    expect(cmd.payload).toMatchObject({ sessionID: "s1", workspaceID: "wrk_a" })
+    expect(cmd.actorID).toBe("s1") // the actor stays the session; only the routing column changes
+  })
+
+  test("tickCommand without a known workspace falls back to the bus global semantics (\"\")", () => {
+    const cmd = GoalTickConsumer.tickCommand(seq0Command())
+    expect(cmd.workspaceID).toBe("")
+    const resumed = GoalTickConsumer.resumeTickCommand(seq0Command())
+    expect(resumed.workspaceID).toBe("")
+  })
 })
 
 describe("GoalTickConsumer — command handling", () => {
@@ -105,6 +124,47 @@ describe("GoalTickConsumer — command handling", () => {
   )
 })
 
+describe("GoalTickConsumer — event row workspace routing (FEATURE-003-407)", () => {
+  const it = testEffect(
+    makeLayer({
+      runTick: () => Effect.succeed({ progress: "continue", nextSeq: 1, nextExpectedPlanVersion: 1 } as StubResult),
+    }),
+  )
+
+  it.effect("publish persists the real workspaceID on the event row and the chain propagates it", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const consumer = yield* GoalTickConsumer.Service
+      const cmd = yield* publishTick(seq0Command({ goalId: "gwrk", workspaceID: "wrk_a" }))
+      // the durable row carries the REAL workspace — pre-fix it was the sessionID.
+      expect(cmd.workspaceID).toBe("wrk_a")
+      yield* consumer.handle(cmd)
+      // the re-emitted successor (seq=1) keeps the same real workspace; the dedup probe returns the
+      // winner row the consumer already persisted, so its workspaceID proves chain propagation.
+      const next = yield* bus.publish(
+        GoalTickConsumer.tickCommand(seq0Command({ goalId: "gwrk", seq: 1, workspaceID: "wrk_a" })),
+      )
+      expect(next.idempotencyKey).toBe("goal:tick:gwrk:1")
+      expect(next.workspaceID).toBe("wrk_a")
+    }),
+  )
+
+  it.effect("a workspace-bound consumer group is owed only its own workspace's tick events", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      // groupsFor routes workspace-bound groups (workspace_id != "") by the event row's workspace_id.
+      yield* bus.registerConsumerGroup("scoped-grp", LMNEvents.GOAL_TICK_REQUESTED, "wrk_a")
+      const scoped = yield* publishTick(seq0Command({ goalId: "gscoped", workspaceID: "wrk_a" }))
+      const global = yield* publishTick(seq0Command({ goalId: "gglobal" })) // legacy command ⇒ "" row
+      expect(scoped.workspaceID).toBe("wrk_a")
+      expect(global.workspaceID).toBe("")
+      const due = yield* bus.dueRetries(2_000)
+      const ours = due.filter((d) => d.subscriptionGroup === "scoped-grp")
+      expect(ours.map((d) => d.eventID)).toEqual([scoped.id])
+    }),
+  )
+})
+
 describe("GoalTickConsumer — terminal stops the chain", () => {
   let calls = 0
   const it = testEffect(
diff --git a/packages/deepagent-code/test/session/incident-regression.test.ts b/packages/deepagent-code/test/session/incident-regression.test.ts
new file mode 100644
index 00000000..c7b9ebce
--- /dev/null
+++ b/packages/deepagent-code/test/session/incident-regression.test.ts
@@ -0,0 +1,1607 @@
+/**
+ * QUAL-002 incident regression suite for the BUG-407 family.
+ *
+ * BUG-407-010 (receipt startup recovery shape): a provider turn that reached
+ * dispatching/streaming before a process crash must be classified
+ * `indeterminate_after_crash` by recoverProviderReceiptsOnStartup, already
+ * settled turns must be untouched, and repeated startup recovery must be
+ * idempotent.
+ *
+ * BUG-407-011 (activity terminal authority shape): rejecting the pending
+ * question request terminalizes the legacy activity (terminal authority row),
+ * and the next prompt in the same session is admitted without being blocked
+ * by recovery_required. The Question service exposes a single `reject`
+ * dismissal path ("The user dismissed this question"); no separate dismiss
+ * API exists, so reject covers the dismissal shape.
+ *
+ * BUG-407-009 (abandoned resolution shape): an indeterminate receipt resolved
+ * as abandoned unblocks the session for newly admitted messages, keeps
+ * forking possible before the crashed turn cutoff, and repeated resolutions
+ * are idempotent.
+ *
+ * Fixtures follow the legal-lifecycle seeding pattern of
+ * provider-receipt-recovery.test.ts / legacy-provider-resolution.test.ts:
+ * authority rows are inserted in their initial non-terminal state and then
+ * advanced through trigger-legal transitions; `// fixture-exempt:` markers
+ * satisfy the QUAL-003 gate for the unavoidable authority inserts.
+ */
+import { describe, expect, test } from "bun:test"
+import { Effect, Fiber, Layer } from "effect"
+import { and, eq, sql } from "drizzle-orm"
+import path from "path"
+import { NodeFileSystem } from "@effect/platform-node"
+import { FetchHttpClient } from "effect/unstable/http"
+import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
+import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
+import {
+  LocationIdentityTable,
+  ProjectScopeIdentityTable,
+  SecurityNamespaceTable,
+} from "@deepagent-code/core/context-federation/sql"
+import { LocationKey, ProjectScopeKey, SecurityNamespaceID } from "@deepagent-code/core/context-federation/reference"
+import {
+  SessionActivityTable,
+  SessionContextSelectionTable,
+  SessionProviderAttemptResolutionTable,
+  SessionProviderAttemptTable,
+  SessionProviderOwnerLeaseTable,
+} from "@deepagent-code/core/context-federation/session-sql"
+import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { DeepAgentReleasedSnapshot } from "@deepagent-code/core/deepagent/released-snapshot"
+import { ProjectV2 } from "@deepagent-code/core/project"
+import { ProjectTable } from "@deepagent-code/core/project/sql"
+import { AbsolutePath } from "@deepagent-code/core/schema"
+import { SessionMessage } from "@deepagent-code/core/session/message"
+import { Prompt } from "@deepagent-code/core/session/prompt"
+import { SessionSchema } from "@deepagent-code/core/session/schema"
+import { SessionHistoryStateTable, SessionInputTable, SessionIntentTable, SessionTable } from "@deepagent-code/core/session/sql"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
+import { SessionV2 } from "@deepagent-code/core/session"
+import { Hash } from "@deepagent-code/core/util/hash"
+import { EffectFlock } from "@deepagent-code/core/util/effect-flock"
+import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
+import { Search } from "@deepagent-code/core/filesystem/search"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import * as Log from "@deepagent-code/core/util/log"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Agent as AgentSvc } from "../../src/agent/agent"
+import { Auth } from "../../src/auth"
+import { BackgroundJob } from "@/background/job"
+import { Command } from "../../src/command"
+import { Config } from "@/config/config"
+import { LSP } from "@/lsp/lsp"
+import { MCP } from "../../src/mcp"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import { Provider as ProviderSvc } from "@/provider/provider"
+import { Env } from "../../src/env"
+import { Git } from "../../src/git"
+import { Image } from "../../src/image/image"
+import { Question } from "../../src/question"
+import { Todo } from "../../src/session/todo"
+import { Session } from "@/session/session"
+import { LLM } from "../../src/session/llm"
+import { MessageV2 } from "../../src/session/message-v2"
+import { FSUtil } from "@deepagent-code/core/fs-util"
+import { SessionCompaction } from "../../src/session/compaction"
+import { RequestExecutor } from "@deepagent-code/llm/route"
+import { SessionSummary } from "../../src/session/summary"
+import { Instruction } from "../../src/session/instruction"
+import { SessionProcessor } from "../../src/session/processor"
+import { recoverProviderReceiptsOnStartup, SessionPrompt } from "../../src/session/prompt"
+import { SessionRevert } from "../../src/session/revert"
+import { SessionRunState } from "../../src/session/run-state"
+import { SessionSteer } from "../../src/session/steer"
+import { SessionStatus } from "../../src/session/status"
+import { MessageID, PartID } from "../../src/session/schema"
+import { Skill } from "../../src/skill"
+import { SystemPrompt } from "../../src/session/system"
+import { Snapshot } from "../../src/snapshot"
+import { ToolRegistry } from "@/tool/registry"
+import { DebugService } from "@/debug/service"
+import { RuntimeBase } from "@/runtime/base"
+import { Truncate } from "@/tool/truncate"
+import { Format } from "../../src/format"
+import { Reference } from "../../src/reference/reference"
+import { RepositoryCache } from "../../src/reference/repository-cache"
+import { PromptEpoch } from "@/session/prompt-epoch"
+import { SessionPromptEpochTable } from "@/session/prompt-epoch.sql"
+import { SessionToolRequestReceiptTable } from "@/session/tool-request-receipt.sql"
+import { SessionLegacyProviderResolution } from "@/session/legacy-provider-resolution"
+import { ContextActivationReceipt } from "@/context-federation/activation-receipt"
+import { ContextFederationReadiness } from "../../src/context-federation/readiness"
+import {
+  SessionActivityAdmissionTable,
+  SessionLegacyActivityRunTable,
+  SessionLegacyActivityTable,
+  SessionLegacyActivityTerminalTable,
+} from "@/session/activity-sql"
+import { TestInstance, testInstanceStoreLayer } from "../fixture/fixture"
+import { TestContextFacades } from "../fixture/context-facades"
+import { pollWithTimeout, testEffect } from "../lib/effect"
+import { TestLLMServer } from "../lib/llm-server"
+
+void Log.init({ print: false })
+
+// ---------------------------------------------------------------------------
+// BUG-407-010 shape: receipt startup recovery (crash after dispatch/stream)
+// ---------------------------------------------------------------------------
+
+const crashProjectId = ProjectV2.ID.make("project-incident-recovery")
+const crashSessionId = SessionSchema.ID.make("ses_incident_recovery")
+const crashInputId = SessionMessage.ID.make("msg_incident_recovery")
+const crashActivityId = "activity-incident-recovery"
+const crashSelectionId = "selection-incident-recovery"
+const crashNamespace = SecurityNamespaceID.make("sec_incident_recovery")
+const crashProjectScope = ProjectScopeKey.make("prjctx_incident_recovery")
+const crashLocation = LocationKey.make("loc_incident_recovery")
+const crashBinding = DeepAgentReleasedSnapshot.binding(undefined)
+const crashRecoveryOwner = "incident-recovery-owner"
+
+const crashSessionLayer = Layer.succeed(
+  Session.Service,
+  {
+    messages: () => Effect.succeed([]),
+    updateMessage: () => Effect.die("incident recovery fixture has no assistant message"),
+  } as unknown as Session.Interface,
+)
+
+function crashAttempt(providerTurnSeq: number) {
+  return {
+    attempt_id: `attempt-incident-${providerTurnSeq}`,
+    session_id: crashSessionId,
+    activity_id: crashActivityId,
+    provider_turn_seq: providerTurnSeq,
+    selection_id: crashSelectionId,
+    projection_hash: "projection",
+    request_hash: crashRequestHash(providerTurnSeq),
+    provider_id: "provider-test",
+    owner_token: "stale-owner",
+    state: "prepared" as const,
+    created_at: 100 + providerTurnSeq,
+  }
+}
+
+function crashRequestHash(providerTurnSeq: number) {
+  return Hash.sha256(`incident-request-${providerTurnSeq}`)
+}
+
+function crashPreparedTurnFields(providerTurnSeq: number) {
+  return {
+    final_request_hash: crashRequestHash(providerTurnSeq),
+    provider_request_hash: crashRequestHash(providerTurnSeq),
+    prepared_turn_hash: Hash.sha256(`incident-prepared-${providerTurnSeq}`),
+    system_stable_hash: Hash.sha256(`incident-stable-${providerTurnSeq}`),
+    system_volatile_hash: Hash.sha256(`incident-volatile-${providerTurnSeq}`),
+    wire_request_hash: crashRequestHash(providerTurnSeq),
+    tool_definition_hash: Hash.sha256("[]"),
+    tool_result_reference_ids: [],
+    tool_result_reference_count: 0,
+  }
+}
+
+function crashReceipt(requestOrdinal: number) {
+  return {
+    receipt_id: `receipt-incident-${requestOrdinal}`,
+    request_ordinal: requestOrdinal + 1,
+    session_id: crashSessionId,
+    user_message_id: crashInputId,
+    provider_attempt_id: `attempt-incident-${requestOrdinal}`,
+    context_selection_id: crashSelectionId,
+    context_eligibility: crashContextEligibility,
+    context_readiness: crashContextReadiness,
+    context_activation: crashContextActivation,
+    context_activation_fingerprint: crashContextActivationFingerprint,
+    released_knowledge_security_namespace_id: crashNamespace,
+    released_knowledge_project_scope_key: crashProjectScope,
+    released_knowledge_binding_state: crashBinding.state,
+    released_knowledge_exact_refs: crashBinding.exactRefs,
+    released_knowledge_exact_refs_fingerprint: crashBinding.exactRefsFingerprint,
+    provider_id: "provider-test",
+    model_id: "model-test",
+    registry_tool_ids: [],
+    permission_filtered_tool_ids: [],
+    final_offered_tool_ids: [],
+    call_ids: [],
+    final_request_hash: null,
+    provider_state: "preparing" as const,
+    adapter_prepared_at: null,
+    prompt_epoch: 0,
+    prompt_window_id: "window-incident-recovery",
+    effective_history_hash: "history-incident-recovery",
+    request_input_hash: crashRequestHash(requestOrdinal),
+    dispatching_at: null,
+    streaming_at: null,
+    owner_token: "stale-owner",
+    request_state: "prepared" as const,
+    created_at: 100,
+  }
+}
+
+const crashContextEligibility = ContextFederationRollout.resolveProject(
+  ContextFederationRollout.resolve(
+    {
+      contextFederationShadow: true,
+      locationIndexesV2Shadow: true,
+      contextProjectionV2: true,
+      contextQueryToolsV2: true,
+      coreV2ExecutionOwner: false,
+    },
+    { coreV2ParityVerified: false },
+  ),
+  "project_scope_incident_recovery",
+  { stage: "all", percentage: 100, internalProjectScopeKeys: [], killSwitch: false },
+)
+const crashContextReadiness = {
+  ...ContextFederationRollout.READINESS_READY_STUB,
+  revision: "readiness-incident-recovery",
+  observedAt: 50,
+  expiresAt: Number.MAX_SAFE_INTEGER,
+}
+const crashContextActivation = ContextActivationReceipt.make({
+  readiness: crashContextReadiness,
+  decision: ContextFederationRollout.activate(crashContextEligibility, crashContextReadiness),
+  recordedAt: 100,
+  projectionEnabled: true,
+  toolsEnabled: true,
+  selection: { selectionId: crashSelectionId, projectionHash: "projection" },
+})
+const crashContextActivationFingerprint = ContextActivationReceipt.fingerprint({
+  eligibility: crashContextEligibility,
+  readiness: crashContextReadiness,
+  activation: crashContextActivation,
+})
+
+/**
+ * Seeds a legal lifecycle (preparing -> prepared -> dispatching -> streaming)
+ * for two provider turns: turn 0 crashes while streaming (stale owner lease),
+ * turn 1 settles legally. Only trigger-legal UPDATE transitions are used to
+ * advance state after the initial non-terminal inserts.
+ */
+function seedCrashFixture(db: Database.Interface["db"]) {
+  return Effect.gen(function* () {
+    yield* db.run(sql`
+      INSERT INTO session_provider_owner_lease (
+        owner_token, registered_at, heartbeat_at, lease_expires_at
+      ) VALUES
+        (
+          ${crashRecoveryOwner},
+          CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+          CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+          CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER) + 60000
+        ),
+        (
+          'stale-owner',
+          CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+          CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER),
+          CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER) + 60000
+        )
+    `)
+    yield* db
+      .insert(SecurityNamespaceTable)
+      .values({ id: crashNamespace, kind: "implicit_local", binding_hash: "namespace-binding", created_at: 1 })
+      .run()
+    yield* db
+      .insert(ProjectScopeIdentityTable)
+      .values({
+        security_namespace_id: crashNamespace,
+        project_scope_key: crashProjectScope,
+        project_kind: "registered_root",
+        project_identity_hash: "project-identity",
+        observed_project_id: crashProjectId,
+        created_at: 1,
+      })
+      .run()
+    yield* db
+      .insert(LocationIdentityTable)
+      .values({
+        security_namespace_id: crashNamespace,
+        location_key: crashLocation,
+        project_scope_key: crashProjectScope,
+        canonical_root: "/tmp/incident-recovery",
+        observed_project_id: crashProjectId,
+        created_at: 1,
+      })
+      .run()
+    yield* db
+      .insert(ProjectTable)
+      .values({ id: crashProjectId, worktree: AbsolutePath.make("/tmp/incident-recovery"), sandboxes: [] })
+      .run()
+    yield* db
+      .insert(SessionTable)
+      .values({
+        id: crashSessionId,
+        project_id: crashProjectId,
+        slug: "incident-recovery",
+        directory: "/tmp/incident-recovery",
+        title: "Incident recovery",
+        version: "test",
+      })
+      .run()
+    yield* db
+      .insert(SessionInputTable)
+      .values({
+        id: crashInputId,
+        session_id: crashSessionId,
+        prompt: new Prompt({ text: "dispatch then crash" }),
+        delivery: "steer",
+        admitted_seq: 0,
+        promoted_seq: 0,
+      })
+      .run()
+    yield* db
+      .insert(SessionActivityTable) // fixture-exempt: seeds active activity for BUG-407-010 crash fixture
+      .values({
+        activity_id: crashActivityId,
+        session_id: crashSessionId,
+        ordinal: 0,
+        trigger_input_id: crashInputId,
+        delivery: "steer",
+        state: "active",
+        created_at: 100,
+      })
+      .run()
+    yield* db
+      .insert(SessionContextSelectionTable)
+      .values({
+        selection_id: crashSelectionId,
+        session_id: crashSessionId,
+        activity_id: crashActivityId,
+        revision: 0,
+        trigger_input_id: crashInputId,
+        location_key: crashLocation,
+        security_namespace_id: crashNamespace,
+        project_scope_key: crashProjectScope,
+        query_fingerprint: "query",
+        authorization_fingerprint: "authorization",
+        authorization_epoch: 1,
+        execution_fingerprint: "execution",
+        selected_source_fingerprint: "sources",
+        observed_location_mutation_epoch: 1,
+        next_revalidation_at: 100_000,
+        released_knowledge_binding_state: crashBinding.state,
+        released_knowledge_exact_refs: crashBinding.exactRefs,
+        released_knowledge_exact_refs_fingerprint: crashBinding.exactRefsFingerprint,
+        graph_revisions: "{}",
+        graph_statuses: "[]",
+        selected_refs: "[]",
+        projection: "",
+        projection_hash: "projection",
+        token_count: 0,
+        artifact_write_status: "degraded_unavailable",
+        inline_audit: "{}",
+        created_at: 100,
+      })
+      .run()
+    yield* db
+      .insert(SessionProviderAttemptTable) // fixture-exempt: seeds prepared attempts, advanced via legal transitions below
+      .values([crashAttempt(0), crashAttempt(1)])
+      .run()
+    for (const providerTurnSeq of [0, 1]) {
+      yield* db
+        .update(SessionProviderAttemptTable)
+        .set({
+          prepared_turn_hash: crashPreparedTurnFields(providerTurnSeq).prepared_turn_hash,
+          wire_request_hash: crashPreparedTurnFields(providerTurnSeq).wire_request_hash,
+        })
+        .where(eq(SessionProviderAttemptTable.attempt_id, `attempt-incident-${providerTurnSeq}`))
+        .run()
+    }
+    yield* db
+      .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds preparing receipts, advanced via legal transitions below
+      .values([crashReceipt(0), crashReceipt(1)])
+      .run()
+    yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        released_knowledge_selected_refs: [],
+        released_knowledge_selected_refs_fingerprint: crashBinding.exactRefsFingerprint,
+      })
+      .run()
+    for (const providerTurnSeq of [0, 1]) {
+      // Legal receipt lifecycle: preparing -> prepared.
+      yield* db
+        .update(SessionToolRequestReceiptTable)
+        .set({ provider_state: "prepared", ...crashPreparedTurnFields(providerTurnSeq), adapter_prepared_at: 100 })
+        .where(eq(SessionToolRequestReceiptTable.receipt_id, `receipt-incident-${providerTurnSeq}`))
+        .run()
+      // Legal attempt/receipt lifecycle: prepared -> dispatching -> streaming.
+      yield* db
+        .update(SessionProviderAttemptTable)
+        .set({ state: "dispatching" })
+        .where(eq(SessionProviderAttemptTable.attempt_id, `attempt-incident-${providerTurnSeq}`))
+        .run()
+      yield* db
+        .update(SessionToolRequestReceiptTable)
+        .set({ provider_state: "dispatching", request_state: "dispatched", dispatching_at: 101 })
+        .where(eq(SessionToolRequestReceiptTable.receipt_id, `receipt-incident-${providerTurnSeq}`))
+        .run()
+      yield* db
+        .update(SessionProviderAttemptTable)
+        .set({ state: "streaming", first_event_at: 102 })
+        .where(eq(SessionProviderAttemptTable.attempt_id, `attempt-incident-${providerTurnSeq}`))
+        .run()
+      yield* db
+        .update(SessionToolRequestReceiptTable)
+        .set({ provider_state: "streaming", streaming_at: 102 })
+        .where(eq(SessionToolRequestReceiptTable.receipt_id, `receipt-incident-${providerTurnSeq}`))
+        .run()
+    }
+    // Turn 1 settles legally before the crash: streaming -> settled.
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ state: "settled", settled_at: 110 })
+      .where(eq(SessionProviderAttemptTable.attempt_id, "attempt-incident-1"))
+      .run()
+    yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        provider_state: "settled",
+        terminal_at: 110,
+        response_fingerprint: Hash.sha256("incident-settled-response"),
+      })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt-incident-1"))
+      .run()
+    // Simulate the crash: the owner lease of the in-flight turn is lost.
+    yield* db.run(sql`
+      UPDATE session_provider_owner_lease
+      SET released_at = CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)
+      WHERE owner_token = 'stale-owner'
+    `)
+  })
+}
+
+describe("BUG-407-010 incident regression: provider receipt startup recovery", () => {
+  test("classifies a crashed streaming turn indeterminate_after_crash without touching settled turns", async () => {
+    const database = Database.layerFromPath(":memory:")
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        yield* seedCrashFixture(db)
+        const settledAttemptBefore = yield* db
+          .select()
+          .from(SessionProviderAttemptTable)
+          .where(eq(SessionProviderAttemptTable.attempt_id, "attempt-incident-1"))
+          .get()
+        const settledReceiptBefore = yield* db
+          .select()
+          .from(SessionToolRequestReceiptTable)
+          .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt-incident-1"))
+          .get()
+
+        yield* recoverProviderReceiptsOnStartup({ ownerToken: crashRecoveryOwner, now: 1_500 })
+
+        expect(
+          yield* db
+            .select({
+              state: SessionProviderAttemptTable.state,
+              errorCode: SessionProviderAttemptTable.error_code,
+            })
+            .from(SessionProviderAttemptTable)
+            .where(eq(SessionProviderAttemptTable.attempt_id, "attempt-incident-0"))
+            .get(),
+        ).toEqual({ state: "indeterminate_after_crash", errorCode: "process_recovery" })
+        expect(
+          yield* db
+            .select({
+              state: SessionToolRequestReceiptTable.provider_state,
+              terminalAt: SessionToolRequestReceiptTable.terminal_at,
+              errorCode: SessionToolRequestReceiptTable.request_error_code,
+            })
+            .from(SessionToolRequestReceiptTable)
+            .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt-incident-0"))
+            .get(),
+        ).toEqual({
+          state: "indeterminate_after_crash",
+          terminalAt: 1_500,
+          errorCode: "provider_started_outcome_unknown_after_process_restart",
+        })
+        // Settled turn must be untouched by the crash sweep.
+        expect(
+          yield* db
+            .select()
+            .from(SessionProviderAttemptTable)
+            .where(eq(SessionProviderAttemptTable.attempt_id, "attempt-incident-1"))
+            .get(),
+        ).toEqual(settledAttemptBefore)
+        expect(
+          yield* db
+            .select()
+            .from(SessionToolRequestReceiptTable)
+            .where(eq(SessionToolRequestReceiptTable.receipt_id, "receipt-incident-1"))
+            .get(),
+        ).toEqual(settledReceiptBefore)
+        expect(
+          yield* db
+            .select({ state: SessionHistoryStateTable.state })
+            .from(SessionHistoryStateTable)
+            .where(eq(SessionHistoryStateTable.session_id, crashSessionId))
+            .get(),
+        ).toEqual({ state: "recovery_required" })
+      }).pipe(Effect.provide(Layer.merge(database, crashSessionLayer))),
+    )
+  })
+
+  test("repeated startup recovery is idempotent", async () => {
+    const database = Database.layerFromPath(":memory:")
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const db = (yield* Database.Service).db
+        yield* seedCrashFixture(db)
+        yield* recoverProviderReceiptsOnStartup({ ownerToken: crashRecoveryOwner, now: 1_500 })
+        const attemptsAfterFirst = yield* db
+          .select()
+          .from(SessionProviderAttemptTable)
+          .orderBy(SessionProviderAttemptTable.provider_turn_seq)
+          .all()
+        const receiptsAfterFirst = yield* db
+          .select()
+          .from(SessionToolRequestReceiptTable)
+          .orderBy(SessionToolRequestReceiptTable.request_ordinal)
+          .all()
+        const historyAfterFirst = yield* db.select().from(SessionHistoryStateTable).all()
+
+        // Second restart with a different clock must not mutate any row.
+        yield* recoverProviderReceiptsOnStartup({ ownerToken: crashRecoveryOwner, now: 2_500 })
+
+        expect(
+          yield* db
+            .select()
+            .from(SessionProviderAttemptTable)
+            .orderBy(SessionProviderAttemptTable.provider_turn_seq)
+            .all(),
+        ).toEqual(attemptsAfterFirst)
+        expect(
+          yield* db
+            .select()
+            .from(SessionToolRequestReceiptTable)
+            .orderBy(SessionToolRequestReceiptTable.request_ordinal)
+            .all(),
+        ).toEqual(receiptsAfterFirst)
+        expect(yield* db.select().from(SessionHistoryStateTable).all()).toEqual(historyAfterFirst)
+        const leasesAfterSecond = yield* db
+          .select()
+          .from(SessionProviderOwnerLeaseTable)
+          .orderBy(SessionProviderOwnerLeaseTable.owner_token)
+          .all()
+        yield* recoverProviderReceiptsOnStartup({ ownerToken: crashRecoveryOwner, now: 3_500 })
+        expect(
+          yield* db
+            .select()
+            .from(SessionProviderOwnerLeaseTable)
+            .orderBy(SessionProviderOwnerLeaseTable.owner_token)
+            .all(),
+        ).toEqual(leasesAfterSecond)
+      }).pipe(Effect.provide(Layer.merge(database, crashSessionLayer))),
+    )
+  })
+})
+
+// ---------------------------------------------------------------------------
+// BUG-407-011 shape: question rejection terminalizes the legacy activity and
+// the next prompt admission is not blocked by recovery_required.
+// ---------------------------------------------------------------------------
+
+const summary = Layer.succeed(
+  SessionSummary.Service,
+  SessionSummary.Service.of({
+    summarize: () => Effect.void,
+    diff: () => Effect.succeed([]),
+    computeDiff: () => Effect.succeed([]),
+    computeManifest: () => Effect.succeed(SessionSummary.emptyManifest()),
+  }),
+)
+
+const mcp = Layer.succeed(
+  MCP.Service,
+  MCP.Service.of({
+    status: () => Effect.succeed({}),
+    clients: () => Effect.succeed({}),
+    tools: () => Effect.succeed({}),
+    prompts: () => Effect.succeed({}),
+    resources: () => Effect.succeed({}),
+    add: () => Effect.succeed({ status: { status: "disabled" as const } }),
+    connect: () => Effect.void,
+    disconnect: () => Effect.void,
+    getPrompt: () => Effect.succeed(undefined),
+    readResource: () => Effect.succeed(undefined),
+    startAuth: () => Effect.die("unexpected MCP auth in incident regression tests"),
+    authenticate: () => Effect.die("unexpected MCP auth in incident regression tests"),
+    finishAuth: () => Effect.die("unexpected MCP auth in incident regression tests"),
+    removeAuth: () => Effect.void,
+    supportsOAuth: () => Effect.succeed(false),
+    hasStoredTokens: () => Effect.succeed(false),
+    getAuthStatus: () => Effect.succeed("not_authenticated" as const),
+    catalog: () => Effect.succeed([]),
+    enableCatalogEntry: () => Effect.succeed({ status: {}, name: "x", config: { type: "local", command: [] } }),
+  }),
+)
+
+const lsp = Layer.succeed(
+  LSP.Service,
+  LSP.Service.of({
+    init: () => Effect.void,
+    status: () => Effect.succeed([]),
+    hasClients: () => Effect.succeed(false),
+    touchFile: () => Effect.void,
+    diagnostics: () => Effect.succeed({}),
+    hover: () => Effect.succeed(undefined),
+    definition: () => Effect.succeed([]),
+    references: () => Effect.succeed([]),
+    implementation: () => Effect.succeed([]),
+    documentSymbol: () => Effect.succeed([]),
+    workspaceSymbol: () => Effect.succeed([]),
+    prepareCallHierarchy: () => Effect.succeed([]),
+    incomingCalls: () => Effect.succeed([]),
+    outgoingCalls: () => Effect.succeed([]),
+    typeDefinition: () => Effect.succeed([]),
+    declaration: () => Effect.succeed([]),
+    prepareTypeHierarchy: () => Effect.succeed([]),
+    supertypes: () => Effect.succeed([]),
+    subtypes: () => Effect.succeed([]),
+    inlayHint: () => Effect.succeed([]),
+    codeAction: () => Effect.succeed([]),
+    executeCommand: () => Effect.succeed(null),
+    prepareRename: () => Effect.succeed(null),
+    rename: () => Effect.succeed(null),
+    documentHighlight: () => Effect.succeed([]),
+    foldingRange: () => Effect.succeed([]),
+    selectionRange: () => Effect.succeed([]),
+    completion: () => Effect.succeed(null),
+    signatureHelp: () => Effect.succeed(null),
+    serverCapabilities: () => Effect.succeed(undefined),
+    workspaceDiagnostics: () => Effect.succeed({}),
+  }),
+)
+
+const status = SessionStatus.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer))
+const run = SessionRunState.layer.pipe(Layer.provide(status))
+const infra = Layer.mergeAll(NodeFileSystem.layer, CrossSpawnSpawner.defaultLayer)
+
+// No-op RuntimeBase stub (debug/profile tools are never invoked here).
+const stubRuntimeBaseLayer = Layer.succeed(
+  RuntimeBase.Service,
+  RuntimeBase.Service.of({
+    gate: () => Effect.void,
+    withIsolation: (_input, body) => body(""),
+    checkPrivileges: () => Effect.succeed([]),
+  }),
+)
+
+const debugStubDie = <A>(): Effect.Effect<A, never> =>
+  Effect.die("DebugService stub (not used in incident regression tests)")
+const stubDebugServiceLayer = Layer.succeed(
+  DebugService.Service,
+  DebugService.Service.of({
+    start: debugStubDie,
+    setBreakpoints: debugStubDie,
+    continue: debugStubDie,
+    step: debugStubDie,
+    stackTrace: debugStubDie,
+    scopes: debugStubDie,
+    variables: debugStubDie,
+    evaluate: debugStubDie,
+    terminate: debugStubDie,
+    get: () => Effect.succeed(undefined),
+    list: () => Effect.succeed([]),
+  }),
+)
+
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Apply it over the tracked history
+// so compaction_run carries the mode columns the drizzle schema already declares.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
+function makeIncidentPromptLayer() {
+  const runtimeFlags = RuntimeFlags.layer({
+    experimentalEventSystem: true,
+    coreV2ExecutionOwner: false,
+  })
+  const deps = Layer.mergeAll(
+    Session.defaultLayer,
+    Snapshot.defaultLayer,
+    LLM.defaultLayer,
+    Env.defaultLayer,
+    AgentSvc.defaultLayer,
+    Command.defaultLayer,
+    Permission.defaultLayer,
+    Plugin.defaultLayer,
+    Config.defaultLayer,
+    Auth.defaultLayer,
+    ProviderSvc.defaultLayer,
+    lsp,
+    mcp,
+    FSUtil.defaultLayer,
+    BackgroundJob.defaultLayer,
+    status,
+    database,
+    EventV2Bridge.defaultLayer,
+    PromptEpoch.defaultLayer,
+  ).pipe(Layer.provideMerge(infra))
+  const question = Question.layer.pipe(Layer.provideMerge(deps))
+  const todo = Todo.layer.pipe(Layer.provideMerge(deps))
+  const registry = ToolRegistry.layer.pipe(
+    Layer.provide(TestContextFacades.layer),
+    Layer.provide(Skill.defaultLayer),
+    Layer.provide(FetchHttpClient.layer),
+    Layer.provide(CrossSpawnSpawner.defaultLayer),
+    Layer.provide(RepositoryCache.defaultLayer),
+    Layer.provide(Git.defaultLayer),
+    Layer.provide(EffectFlock.defaultLayer),
+    Layer.provide(Reference.defaultLayer),
+    Layer.provide(Search.defaultLayer),
+    Layer.provide(Format.defaultLayer),
+    Layer.provide(runtimeFlags),
+    Layer.provide(stubDebugServiceLayer),
+    Layer.provide(stubRuntimeBaseLayer),
+    Layer.provideMerge(todo),
+    Layer.provideMerge(question),
+    Layer.provideMerge(deps),
+  )
+  const trunc = Truncate.layer.pipe(Layer.provideMerge(deps))
+  const proc = SessionProcessor.layer.pipe(
+    Layer.provide(summary),
+    Layer.provide(Image.defaultLayer),
+    Layer.provide(runtimeFlags),
+    Layer.provideMerge(deps),
+  )
+  const compact = SessionCompaction.layer.pipe(
+    Layer.provide(runtimeFlags),
+    Layer.provide(RequestExecutor.defaultLayer),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(deps),
+  )
+  const steer = SessionSteer.layer.pipe(Layer.provideMerge(deps))
+  return SessionPrompt.layer.pipe(
+    Layer.provide(SessionV2.defaultLayer),
+    Layer.provide(SessionProviderOwner.layer.pipe(Layer.provide(deps))),
+    Layer.provide(testInstanceStoreLayer),
+    Layer.provide(SessionRevert.defaultLayer),
+    Layer.provide(Image.defaultLayer),
+    Layer.provide(Reference.defaultLayer),
+    Layer.provide(summary),
+    Layer.provideMerge(steer),
+    Layer.provideMerge(run),
+    Layer.provideMerge(compact),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(registry),
+    Layer.provideMerge(trunc),
+    Layer.provide(Instruction.defaultLayer),
+    Layer.provide(SystemPrompt.defaultLayer),
+    Layer.provide(LocationIdentity.layer.pipe(Layer.provide(deps))),
+    Layer.provide(
+      Layer.succeed(
+        ContextFederationReadiness.Service,
+        ContextFederationReadiness.Service.of({
+          snapshot: () => Effect.succeed(ContextFederationRollout.READINESS_READY_STUB),
+        }),
+      ),
+    ),
+    Layer.provide(runtimeFlags),
+    Layer.provideMerge(deps),
+    Layer.provide(summary),
+  )
+}
+
+const incidentPrompt = testEffect(Layer.mergeAll(TestLLMServer.layer, makeIncidentPromptLayer()))
+
+const incidentCfg = {
+  provider: {
+    test: {
+      name: "Test",
+      id: "test",
+      env: [],
+      npm: "@ai-sdk/openai-compatible",
+      models: {
+        "test-model": {
+          id: "test-model",
+          name: "Test Model",
+          attachment: false,
+          reasoning: false,
+          temperature: false,
+          tool_call: true,
+          release_date: "2025-01-01",
+          limit: { context: 100000, output: 10000 },
+          cost: { input: 0, output: 0 },
+          options: {},
+        },
+      },
+      options: {
+        apiKey: "test-key",
+        baseURL: "http://localhost:1/v1",
+        maxRetries: 0,
+      },
+    },
+  },
+}
+
+function incidentProviderCfg(url: string) {
+  return {
+    ...incidentCfg,
+    provider: {
+      ...incidentCfg.provider,
+      test: {
+        ...incidentCfg.provider.test,
+        options: { ...incidentCfg.provider.test.options, baseURL: url },
+      },
+    },
+  }
+}
+
+const writeIncidentConfig = Effect.fn("IncidentRegression.writeConfig")(function* (
+  dir: string,
+  config: Record<string, unknown>,
+) {
+  const fs = yield* FSUtil.Service
+  yield* fs.writeWithDirs(
+    path.join(dir, "deepagent-code.json"),
+    JSON.stringify({ $schema: "https://deepagent-code.ai/config.json", ...config }),
+  )
+})
+
+const useIncidentServerConfig = Effect.fn("IncidentRegression.useServerConfig")(
+  function* (config: (url: string) => Record<string, unknown>) {
+    const { directory: dir } = yield* TestInstance
+    const llm = yield* TestLLMServer
+    yield* writeIncidentConfig(dir, config(llm.url))
+    return { dir, llm }
+  },
+)
+
+incidentPrompt.instance(
+  "BUG-407-011: question dismissal terminalizes the activity authority and unblocks the next prompt admission",
+  () =>
+    Effect.gen(function* () {
+      const { llm } = yield* useIncidentServerConfig(incidentProviderCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const question = yield* Question.Service
+      const { db } = yield* Database.Service
+      const chat = yield* sessions.create({
+        title: "BUG-407-011 question dismissal",
+        permission: [{ permission: "*", pattern: "*", action: "allow" }],
+      })
+      yield* llm.tool("question", {
+        questions: [
+          {
+            question: "Continue with this approach?",
+            header: "Continue",
+            options: [{ label: "Yes", description: "Continue" }],
+          },
+        ],
+      })
+      yield* llm.text("post dismissal admission works")
+
+      const first = yield* prompt
+        .prompt({
+          sessionID: chat.id,
+          agent: "build",
+          parts: [{ type: "text", text: "ask before proceeding" }],
+        })
+        .pipe(Effect.forkChild)
+      const request = yield* pollWithTimeout(
+        Effect.gen(function* () {
+          const pending = yield* question.list()
+          return pending.find((item) => item.sessionID === chat.id)
+        }),
+        "timed out waiting for question request",
+      )
+      yield* question.reject(request.id)
+      const firstResult = yield* Fiber.join(first)
+      expect(firstResult.info.role).toBe("assistant")
+
+      // Terminal authority shape: the rejected run must leave terminal rows.
+      expect(yield* db.select().from(SessionLegacyActivityTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "interrupted", terminal_reason: "user_rejected_question" },
+      ])
+      expect(yield* db.select().from(SessionLegacyActivityRunTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "interrupted", terminal_reason: "user_rejected_question" },
+      ])
+      expect(yield* db.select().from(SessionLegacyActivityTerminalTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "interrupted", reason_code: "user_rejected_question", source: "host_stop" },
+      ])
+      // No recovery_required quarantine may linger after a clean dismissal.
+      expect(
+        yield* db
+          .select()
+          .from(SessionHistoryStateTable)
+          .where(
+            and(
+              eq(SessionHistoryStateTable.session_id, chat.id),
+              eq(SessionHistoryStateTable.state, "recovery_required"),
+            ),
+          )
+          .all()
+          .pipe(Effect.orDie),
+      ).toEqual([])
+      expect(
+        yield* db
+          .select()
+          .from(SessionPromptEpochTable)
+          .where(
+            and(
+              eq(SessionPromptEpochTable.session_id, chat.id),
+              eq(SessionPromptEpochTable.authority_state, "recovery_required"),
+            ),
+          )
+          .all()
+          .pipe(Effect.orDie),
+      ).toEqual([])
+
+      // The next prompt in the same session must be admitted and run.
+      const next = yield* prompt.prompt({
+        sessionID: chat.id,
+        agent: "build",
+        parts: [{ type: "text", text: "continue after dismissal" }],
+      })
+      expect(next.parts.some((part) => part.type === "text" && part.text === "post dismissal admission works")).toBeTrue()
+      expect(yield* llm.hits).toHaveLength(2)
+      expect(
+        yield* db
+          .select()
+          .from(SessionActivityAdmissionTable)
+          .where(eq(SessionActivityAdmissionTable.session_id, chat.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(2)
+      expect(yield* db.select().from(SessionLegacyActivityTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "interrupted", terminal_reason: "user_rejected_question" },
+        { state: "settled", terminal_reason: "assistant_completed" },
+      ])
+      expect(yield* db.select().from(SessionLegacyActivityTerminalTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "interrupted", reason_code: "user_rejected_question", source: "host_stop" },
+        { state: "settled", reason_code: "assistant_completed", source: "provider_final" },
+      ])
+    }),
+  15_000,
+)
+
+incidentPrompt.instance(
+  "BUG-407-011 residual: continue_loop_on_deny keeps the run alive after dismissal and still terminalizes the activity",
+  () =>
+    Effect.gen(function* () {
+      const { llm } = yield* useIncidentServerConfig((url) => ({
+        ...incidentProviderCfg(url),
+        experimental: { continue_loop_on_deny: true },
+      }))
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const question = yield* Question.Service
+      const { db } = yield* Database.Service
+      const chat = yield* sessions.create({
+        title: "BUG-407-011 continue_loop_on_deny",
+        permission: [{ permission: "*", pattern: "*", action: "allow" }],
+      })
+      yield* llm.tool("question", {
+        questions: [
+          {
+            question: "Continue with this approach?",
+            header: "Continue",
+            options: [{ label: "Yes", description: "Continue" }],
+          },
+        ],
+      })
+      yield* llm.text("loop continued after deny")
+      yield* llm.text("next prompt admitted after continue-on-deny")
+
+      const first = yield* prompt
+        .prompt({
+          sessionID: chat.id,
+          agent: "build",
+          parts: [{ type: "text", text: "ask before proceeding" }],
+        })
+        .pipe(Effect.forkChild)
+      const request = yield* pollWithTimeout(
+        Effect.gen(function* () {
+          const pending = yield* question.list()
+          return pending.find((item) => item.sessionID === chat.id)
+        }),
+        "timed out waiting for question request",
+      )
+      yield* question.reject(request.id)
+      const firstResult = yield* Fiber.join(first)
+      expect(firstResult.info.role).toBe("assistant")
+      // The loop must NOT stop at the dismissal: the SAME run completes with the continuation text
+      // (the rejection is a tool failure, not a typed stop reason, under continue_loop_on_deny).
+      expect(
+        firstResult.parts.some((part) => part.type === "text" && part.text === "loop continued after deny"),
+      ).toBeTrue()
+      // The rejection surfaced as a tool FAILURE carrying the failureCode, not a turn abort.
+      const msgs = yield* sessions.messages({ sessionID: chat.id })
+      const questionPart = msgs
+        .flatMap((m) => m.parts)
+        .find((p) => p.type === "tool") as
+        | { state: { status: string; metadata?: Record<string, unknown> } }
+        | undefined
+      expect(questionPart?.state.status).toBe("error")
+      expect(questionPart?.state.metadata?.failureCode).toBe("user_rejected_question")
+
+      // The SAME activity terminalizes at run end — settled, never interrupted, never left active.
+      // (The run row uses its own terminal vocabulary: "completed" for a settled outcome.)
+      expect(yield* db.select().from(SessionLegacyActivityTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "settled", terminal_reason: "assistant_completed" },
+      ])
+      expect(yield* db.select().from(SessionLegacyActivityRunTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "completed", terminal_reason: "assistant_completed" },
+      ])
+      expect(yield* db.select().from(SessionLegacyActivityTerminalTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "settled", reason_code: "assistant_completed", source: "provider_final" },
+      ])
+      // No recovery_required quarantine may linger after a continue-on-deny completion.
+      expect(
+        yield* db
+          .select()
+          .from(SessionHistoryStateTable)
+          .where(
+            and(
+              eq(SessionHistoryStateTable.session_id, chat.id),
+              eq(SessionHistoryStateTable.state, "recovery_required"),
+            ),
+          )
+          .all()
+          .pipe(Effect.orDie),
+      ).toEqual([])
+      expect(
+        yield* db
+          .select()
+          .from(SessionPromptEpochTable)
+          .where(
+            and(
+              eq(SessionPromptEpochTable.session_id, chat.id),
+              eq(SessionPromptEpochTable.authority_state, "recovery_required"),
+            ),
+          )
+          .all()
+          .pipe(Effect.orDie),
+      ).toEqual([])
+
+      // The next prompt in the same session must be admitted and run (no "requires recovery" conflict).
+      const next = yield* prompt.prompt({
+        sessionID: chat.id,
+        agent: "build",
+        parts: [{ type: "text", text: "continue after continue-on-deny" }],
+      })
+      expect(
+        next.parts.some((part) => part.type === "text" && part.text === "next prompt admitted after continue-on-deny"),
+      ).toBeTrue()
+      expect(yield* llm.hits).toHaveLength(3)
+      expect(
+        yield* db
+          .select()
+          .from(SessionActivityAdmissionTable)
+          .where(eq(SessionActivityAdmissionTable.session_id, chat.id))
+          .all()
+          .pipe(Effect.orDie),
+      ).toHaveLength(2)
+      expect(yield* db.select().from(SessionLegacyActivityTable).all().pipe(Effect.orDie)).toMatchObject([
+        { state: "settled", terminal_reason: "assistant_completed" },
+        { state: "settled", terminal_reason: "assistant_completed" },
+      ])
+    }),
+  15_000,
+)
+
+// ---------------------------------------------------------------------------
+// BUG-407-009 shape: abandoned resolution of an indeterminate receipt
+// ---------------------------------------------------------------------------
+
+const resolutionLayer = Layer.mergeAll(
+  Session.defaultLayer,
+  Database.defaultLayer,
+  EventV2Bridge.defaultLayer,
+  SessionProjector.defaultLayer,
+  SessionLegacyProviderResolution.defaultLayer,
+  SessionProviderOwner.layer.pipe(Layer.provide(Database.defaultLayer)),
+  LocationIdentity.defaultLayer,
+)
+const resolution = testEffect(resolutionLayer)
+const resolutionModel = { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("model") }
+let nextMessageTime = 1
+
+const addUser = Effect.fn("IncidentRegression.addUser")(function* (
+  sessionID: Parameters<Session.Interface["get"]>[0],
+  text: string,
+) {
+  const session = yield* Session.Service
+  const message = yield* session.updateMessage({
+    id: MessageID.ascending(`msg_${String(nextMessageTime++).padStart(26, "0")}`),
+    sessionID,
+    role: "user",
+    time: { created: Date.now() },
+    agent: "build",
+    model: resolutionModel,
+  })
+  yield* session.updatePart({
+    id: PartID.ascending(),
+    sessionID,
+    messageID: message.id,
+    type: "text",
+    text,
+  })
+  return message
+})
+
+const addAssistant = Effect.fn("IncidentRegression.addAssistant")(function* (
+  sessionID: Parameters<Session.Interface["get"]>[0],
+  parentID: MessageID,
+  completed = false,
+) {
+  const session = yield* Session.Service
+  return yield* session.updateMessage({
+    id: MessageID.ascending(`msg_${String(nextMessageTime++).padStart(26, "0")}`),
+    sessionID,
+    role: "assistant",
+    parentID,
+    time: { created: Date.now(), ...(completed ? { completed: Date.now() } : {}) },
+    mode: "build",
+    agent: "build",
+    cost: 0,
+    path: { cwd: "/tmp", root: "/tmp" },
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    modelID: resolutionModel.modelID,
+    providerID: resolutionModel.providerID,
+    ...(completed ? { finish: "stop" as const } : {}),
+  })
+})
+
+// Mirrors the legal-lifecycle crash fixture of legacy-provider-resolution.test.ts:
+// rows are seeded in non-terminal states and advanced through the provider
+// lifecycle updates before being left indeterminate by a simulated restart.
+const seedIndeterminateProviderTurn = Effect.fn("IncidentRegression.seedIndeterminateProviderTurn")(
+  function* (input: {
+    session: Session.Info
+    userMessageID: MessageID
+    assistantMessageID: MessageID
+    receiptID: string
+    providerAttemptID: string
+    activityID: string
+    selectionID: string
+    requestHash: string
+    prompt?: { epoch: number; windowID: string; historyHash: string }
+  }) {
+    const db = (yield* Database.Service).db
+    const owners = yield* SessionProviderOwner.Service
+    const identity = yield* LocationIdentity.Service.use((service) =>
+      service.resolve({
+        boundary: { kind: "implicit_local" },
+        directory: AbsolutePath.make(input.session.directory),
+        project: { kind: "git", observedProjectId: input.session.projectID },
+      }),
+    )
+    const binding = DeepAgentReleasedSnapshot.binding(undefined)
+    const staleOwnerToken = `stale:${input.receiptID}`
+    const recoveryOwnerToken = `recovery:${input.receiptID}`
+    const now = Date.now()
+    const preparedTurnHash = Hash.sha256(`prepared:${input.receiptID}`)
+    const contextEligibility = ContextFederationRollout.resolveProject(
+      ContextFederationRollout.resolve(
+        {
+          contextFederationShadow: true,
+          locationIndexesV2Shadow: true,
+          contextProjectionV2: true,
+          contextQueryToolsV2: true,
+          coreV2ExecutionOwner: false,
+        },
+        { coreV2ParityVerified: false },
+      ),
+      identity.projectScopeKey,
+      { stage: "all", percentage: 100, internalProjectScopeKeys: [], killSwitch: false },
+    )
+    const contextReadiness = {
+      ...ContextFederationRollout.READINESS_READY_STUB,
+      revision: `readiness:${input.receiptID}`,
+      observedAt: now,
+      expiresAt: now + 60_000,
+    }
+    const contextActivation = ContextActivationReceipt.make({
+      readiness: contextReadiness,
+      decision: ContextFederationRollout.activate(contextEligibility, contextReadiness),
+      recordedAt: now,
+      projectionEnabled: true,
+      toolsEnabled: true,
+      selection: { selectionId: input.selectionID, projectionHash: "projection" },
+    })
+
+    yield* owners.register({ ownerToken: staleOwnerToken, leaseMs: SessionProviderOwner.LeaseMs })
+    yield* Effect.addFinalizer(() => owners.release({ ownerToken: staleOwnerToken }).pipe(Effect.ignore))
+    yield* db
+      .insert(SessionInputTable)
+      .values({
+        id: SessionMessage.ID.make(input.userMessageID),
+        session_id: input.session.id,
+        prompt: new Prompt({ text: "dispatch then crash" }),
+        delivery: "steer",
+        admitted_seq: 0,
+        promoted_seq: 0,
+      })
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionActivityTable) // fixture-exempt: seeds active activity for BUG-407-009 abandoned-resolution fixture
+      .values({
+        activity_id: input.activityID,
+        session_id: input.session.id,
+        ordinal: 0,
+        trigger_input_id: input.userMessageID,
+        delivery: "steer",
+        state: "active",
+        created_at: now,
+      })
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionContextSelectionTable)
+      .values({
+        selection_id: input.selectionID,
+        session_id: input.session.id,
+        activity_id: input.activityID,
+        revision: 0,
+        trigger_input_id: input.userMessageID,
+        location_key: identity.locationKey,
+        security_namespace_id: identity.securityNamespaceId,
+        project_scope_key: identity.projectScopeKey,
+        query_fingerprint: "query",
+        authorization_fingerprint: "authorization",
+        authorization_epoch: 0,
+        execution_fingerprint: "execution",
+        selected_source_fingerprint: "sources",
+        observed_location_mutation_epoch: 0,
+        next_revalidation_at: now + 60_000,
+        released_knowledge_binding_state: binding.state,
+        released_knowledge_exact_refs: binding.exactRefs,
+        released_knowledge_exact_refs_fingerprint: binding.exactRefsFingerprint,
+        graph_revisions: "{}",
+        graph_statuses: "[]",
+        selected_refs: "[]",
+        projection: "",
+        projection_hash: "projection",
+        token_count: 0,
+        artifact_write_status: "degraded_unavailable",
+        inline_audit: "{}",
+        created_at: now,
+      })
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionProviderAttemptTable) // fixture-exempt: seeds prepared attempt with stale owner for BUG-407-009 crash fixture
+      .values({
+        attempt_id: input.providerAttemptID,
+        session_id: input.session.id,
+        activity_id: input.activityID,
+        provider_turn_seq: 0,
+        selection_id: input.selectionID,
+        projection_hash: "projection",
+        request_hash: input.requestHash,
+        provider_id: resolutionModel.providerID,
+        owner_token: staleOwnerToken,
+        state: "prepared",
+        created_at: now,
+      })
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds preparing receipt for BUG-407-009 crash fixture
+      .values({
+        receipt_id: input.receiptID,
+        request_ordinal: 1,
+        session_id: input.session.id,
+        user_message_id: input.userMessageID,
+        assistant_message_id: input.assistantMessageID,
+        provider_attempt_id: input.providerAttemptID,
+        context_selection_id: input.selectionID,
+        context_eligibility: contextEligibility,
+        context_readiness: contextReadiness,
+        context_activation: contextActivation,
+        context_activation_fingerprint: ContextActivationReceipt.fingerprint({
+          eligibility: contextEligibility,
+          readiness: contextReadiness,
+          activation: contextActivation,
+        }),
+        released_knowledge_security_namespace_id: identity.securityNamespaceId,
+        released_knowledge_project_scope_key: identity.projectScopeKey,
+        released_knowledge_binding_state: binding.state,
+        released_knowledge_exact_refs: binding.exactRefs,
+        released_knowledge_exact_refs_fingerprint: binding.exactRefsFingerprint,
+        provider_id: resolutionModel.providerID,
+        model_id: resolutionModel.modelID,
+        protocol: "chat",
+        registry_tool_ids: [],
+        permission_filtered_tool_ids: [],
+        final_offered_tool_ids: [],
+        call_ids: [],
+        ...(input.prompt
+          ? {
+              prompt_epoch: input.prompt.epoch,
+              prompt_window_id: input.prompt.windowID,
+              effective_history_hash: input.prompt.historyHash,
+            }
+          : {}),
+        request_input_hash: input.requestHash,
+        provider_state: "preparing",
+        owner_token: staleOwnerToken,
+        request_state: "prepared",
+        created_at: now,
+      })
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ prepared_turn_hash: preparedTurnHash, wire_request_hash: input.requestHash })
+      .where(eq(SessionProviderAttemptTable.attempt_id, input.providerAttemptID))
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        released_knowledge_selected_refs: [],
+        released_knowledge_selected_refs_fingerprint: binding.exactRefsFingerprint,
+      })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, input.receiptID))
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        provider_state: "prepared",
+        final_request_hash: input.requestHash,
+        provider_request_hash: input.requestHash,
+        adapter_prepared_at: now,
+        tool_definition_hash: Hash.sha256("[]"),
+        prepared_turn_hash: preparedTurnHash,
+        system_stable_hash: Hash.sha256(`stable:${input.receiptID}`),
+        system_volatile_hash: Hash.sha256(`volatile:${input.receiptID}`),
+        wire_request_hash: input.requestHash,
+        tool_result_reference_ids: [],
+        tool_result_reference_count: 0,
+      })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, input.receiptID))
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ state: "dispatching" })
+      .where(eq(SessionProviderAttemptTable.attempt_id, input.providerAttemptID))
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .update(SessionToolRequestReceiptTable)
+      .set({
+        provider_state: "indeterminate_after_crash",
+        request_state: "dispatched",
+        dispatching_at: now,
+        terminal_at: now,
+        request_error_code: "provider_started_outcome_unknown_after_process_restart",
+      })
+      .where(eq(SessionToolRequestReceiptTable.receipt_id, input.receiptID))
+      .run()
+      .pipe(Effect.orDie)
+    yield* owners.register({ ownerToken: recoveryOwnerToken, leaseMs: SessionProviderOwner.LeaseMs })
+    yield* Effect.addFinalizer(() => owners.release({ ownerToken: recoveryOwnerToken }).pipe(Effect.ignore))
+    yield* owners.release({ ownerToken: staleOwnerToken })
+    yield* db
+      .update(SessionProviderAttemptTable)
+      .set({ state: "indeterminate_after_crash", error_code: "process_recovery" })
+      .where(eq(SessionProviderAttemptTable.attempt_id, input.providerAttemptID))
+      .run()
+      .pipe(Effect.orDie)
+    return { recoveryOwnerToken }
+  },
+)
+
+resolution.instance(
+  "BUG-407-009: abandoned resolution unblocks the session, permits cutoff forks, and is idempotent",
+  () =>
+    Effect.gen(function* () {
+      const sessions = yield* Session.Service
+      const recovery = yield* SessionLegacyProviderResolution.Service
+      yield* TestInstance
+      const { db } = yield* Database.Service
+      const parent = yield* sessions.create({ title: "incident abandoned resolution parent" })
+      const source = yield* sessions.fork({ sessionID: parent.id, intentID: "incident-abandoned-source" })
+      const safeUser = yield* addUser(source.id, "completed before provider crash")
+      const safeAssistant = yield* addAssistant(source.id, safeUser.id, true)
+      const user = yield* addUser(source.id, "dispatch then crash")
+      const assistant = yield* addAssistant(source.id, user.id)
+      const authority = yield* MessageV2.promptHistoryProjectionEffect(source.id)
+      if (!authority.worldStateBaselineHash) return yield* Effect.die("expected frozen source World State baseline")
+      const receiptID = "receipt-incident-abandoned"
+      const providerAttemptID = "attempt-incident-abandoned"
+      const providerActivityID = "activity-incident-abandoned"
+      const providerSelectionID = "selection-incident-abandoned"
+      const seeded = yield* seedIndeterminateProviderTurn({
+        session: source,
+        userMessageID: user.id,
+        assistantMessageID: assistant.id,
+        receiptID,
+        providerAttemptID,
+        activityID: providerActivityID,
+        selectionID: providerSelectionID,
+        requestHash: Hash.sha256("incident-final-request-hash"),
+        prompt: {
+          epoch: authority.epoch,
+          windowID: authority.window.windowID,
+          historyHash: authority.effectiveHistoryHash,
+        },
+      })
+      const now = Date.now()
+      yield* db
+        .update(SessionPromptEpochTable)
+        .set({ authority_state: "recovery_required", recovery_reason: "provider outcome is unknown after restart" })
+        .where(
+          and(eq(SessionPromptEpochTable.session_id, source.id), eq(SessionPromptEpochTable.epoch, authority.epoch)),
+        )
+        .run()
+        .pipe(Effect.orDie)
+      yield* db
+        .update(SessionHistoryStateTable)
+        .set({
+          state: "recovery_required",
+          reason: "provider outcome is unknown after restart",
+          time_updated: now,
+        })
+        .where(eq(SessionHistoryStateTable.session_id, source.id))
+        .run()
+        .pipe(Effect.orDie)
+
+      const descriptors = yield* recovery.describe(source.id)
+      expect(descriptors).toHaveLength(1)
+      const [descriptor] = descriptors
+      expect(descriptor).toMatchObject({
+        receiptID,
+        sessionID: source.id,
+        providerState: "indeterminate_after_crash",
+        promptEpoch: authority.epoch,
+        continuationRecoverySupported: true,
+      })
+
+      // While the turn is indeterminate, forking before the crashed turn's
+      // cutoff stays possible and cutoffs at/after it stay blocked.
+      const prefixFork = yield* sessions.fork({
+        sessionID: source.id,
+        messageID: user.id,
+        intentID: "fork-before-incident-abandoned-turn",
+      })
+      expect(
+        (yield* sessions.messages({ sessionID: prefixFork.id })).map((message) => message.info.role),
+      ).toEqual(["user", "assistant"])
+      expect(
+        yield* sessions
+          .fork({
+            sessionID: source.id,
+            messageID: assistant.id,
+            intentID: "fork-at-incident-abandoned-turn",
+          })
+          .pipe(Effect.flip),
+      ).toMatchObject({
+        _tag: "Session.ForkConflict",
+        reason: expect.stringContaining("fork cutoff is outside the recoverable history prefix"),
+      })
+
+      if (!descriptor) return
+      if (!descriptor.resolutionSupported)
+        return yield* Effect.die(
+          `expected a resolvable provider recovery descriptor: ${descriptor.unsupportedReasons.join(",")}`,
+        )
+      const command = {
+        sessionID: source.id,
+        commandID: "resolve-incident-abandoned",
+        receiptID,
+        decision: "abandoned" as const,
+        expected: {
+          providerState: "indeterminate_after_crash" as const,
+          promptEpoch: descriptor.promptEpoch,
+          sessionMutationEpoch: descriptor.sessionMutationEpoch,
+          requestHash: descriptor.requestHash,
+          historyHash: descriptor.historyHash,
+          worldStateBaselineHash: descriptor.worldStateBaselineHash,
+        },
+        actorID: "test-user",
+      }
+
+      // Explicit abandoned resolution, then idempotent repeats.
+      const first = yield* recovery.resolve(command)
+      expect(first).toMatchObject({
+        decision: "abandoned",
+        sourcePromptEpoch: authority.epoch,
+        successorPromptEpoch: authority.epoch + 1,
+        sourceMutationEpoch: 0,
+        successorMutationEpoch: 1,
+      })
+      const retry = yield* recovery.resolve(command)
+      expect(retry).toEqual(first)
+      const repeat = yield* recovery.resolve(command)
+      expect(repeat).toEqual(first)
+      expect(yield* recovery.describe(source.id)).toEqual([])
+      expect(
+        yield* db
+          .select({ attemptID: SessionProviderAttemptResolutionTable.attempt_id, decision: SessionProviderAttemptResolutionTable.decision })
+          .from(SessionProviderAttemptResolutionTable)
+          .all()
+          .pipe(Effect.orDie),
+      ).toEqual([{ attemptID: providerAttemptID, decision: "abandoned" }])
+      expect(
+        yield* db
+          .select({ state: SessionProviderAttemptTable.state })
+          .from(SessionProviderAttemptTable)
+          .where(eq(SessionProviderAttemptTable.attempt_id, providerAttemptID))
+          .get()
+          .pipe(Effect.orDie),
+      ).toEqual({ state: "resolved_abandoned" })
+      expect(
+        yield* db
+          .select({ state: SessionActivityTable.state })
+          .from(SessionActivityTable)
+          .where(eq(SessionActivityTable.activity_id, providerActivityID))
+          .get()
+          .pipe(Effect.orDie),
+      ).toEqual({ state: "interrupted" })
+
+      // Startup recovery after resolution must clear the quarantine to ready.
+      yield* recoverProviderReceiptsOnStartup({ ownerToken: seeded.recoveryOwnerToken })
+      expect(
+        yield* db
+          .select({ state: SessionHistoryStateTable.state })
+          .from(SessionHistoryStateTable)
+          .where(eq(SessionHistoryStateTable.session_id, source.id))
+          .get()
+          .pipe(Effect.orDie),
+      ).toEqual({ state: "ready" })
+
+      // Forking stays possible after resolution: the safe prefix copies cleanly.
+      const fork = yield* sessions.fork({
+        sessionID: source.id,
+        intentID: "fork-after-incident-abandoned-resolution",
+      })
+      expect(
+        (yield* sessions.messages({ sessionID: fork.id })).map((message) => message.info.role),
+      ).toEqual(["user", "assistant"])
+
+      // The session keeps accepting newly admitted messages.
+      const continued = yield* addUser(source.id, "continue after explicit abandon")
+      const admittedAt = Date.now()
+      yield* db
+        .insert(SessionIntentTable)
+        .values({
+          intent_id: "incident-continue-after-explicit-abandon",
+          session_id: source.id,
+          source: "composer",
+          state: "admitted",
+          selected_variant: "original",
+          selected_payload_hash: "test",
+          delivery: "turn",
+          admitted_message_id: continued.id,
+          execution_mode: "legacy",
+          execution_state: "legacy",
+          mutation_epoch: first.successorMutationEpoch,
+          version: 1,
+          time_created: admittedAt,
+          time_selected: admittedAt,
+          time_admitted: admittedAt,
+          time_updated: admittedAt,
+        })
+        .run()
+        .pipe(Effect.orDie)
+      const continuedProjection = yield* MessageV2.promptHistoryProjectionEffect(source.id)
+      expect(continuedProjection.messages.map((message) => message.info.id)).toEqual([
+        safeUser.id,
+        safeAssistant.id,
+        continued.id,
+      ])
+      expect(continuedProjection.epoch).toBe(authority.epoch + 1)
+      expect(continuedProjection.recoveryResolutionID).toBe(first.resolutionID)
+    }),
+  { git: true },
+  30_000,
+)
diff --git a/packages/deepagent-code/test/session/legacy-provider-resolution.test.ts b/packages/deepagent-code/test/session/legacy-provider-resolution.test.ts
index ced0fa9e..074b7a50 100644
--- a/packages/deepagent-code/test/session/legacy-provider-resolution.test.ts
+++ b/packages/deepagent-code/test/session/legacy-provider-resolution.test.ts
@@ -174,7 +174,7 @@ const seedIndeterminateProviderTurn = Effect.fn("LegacyProviderResolutionTest.se
       .run()
       .pipe(Effect.orDie)
     yield* db
-      .insert(SessionActivityTable)
+      .insert(SessionActivityTable) // fixture-exempt: seeds active activity for legacy-resolution fixture
       .values({
         activity_id: input.activityID,
         session_id: input.session.id,
@@ -220,7 +220,7 @@ const seedIndeterminateProviderTurn = Effect.fn("LegacyProviderResolutionTest.se
       .run()
       .pipe(Effect.orDie)
     yield* db
-      .insert(SessionProviderAttemptTable)
+      .insert(SessionProviderAttemptTable) // fixture-exempt: seeds prepared attempt with stale owner for crash fixture
       .values({
         attempt_id: input.providerAttemptID,
         session_id: input.session.id,
@@ -237,7 +237,7 @@ const seedIndeterminateProviderTurn = Effect.fn("LegacyProviderResolutionTest.se
       .run()
       .pipe(Effect.orDie)
     yield* db
-      .insert(SessionToolRequestReceiptTable)
+      .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds receipt mid-state for legacy-resolution fixture
       .values({
         receipt_id: input.receiptID,
         request_ordinal: 1,
diff --git a/packages/deepagent-code/test/session/llm-native.test.ts b/packages/deepagent-code/test/session/llm-native.test.ts
index 2310323a..4a8b7474 100644
--- a/packages/deepagent-code/test/session/llm-native.test.ts
+++ b/packages/deepagent-code/test/session/llm-native.test.ts
@@ -6,6 +6,9 @@ import { Effect, Fiber, Layer, Stream } from "effect"
 import { LLMNative } from "@/session/llm/native-request"
 import { LLMNativeRuntime } from "@/session/llm/native-runtime"
 import { FreeformTools } from "@/session/llm/freeform-tools"
+import { LLMRequestPrep } from "@/session/llm/request"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import type { SessionV1 } from "@deepagent-code/core/v1/session"
 import type { Provider } from "@/provider/provider"
 
 import { OAUTH_DUMMY_KEY } from "@/auth"
@@ -73,10 +76,58 @@ const providerInfo: Provider.Info = {
   models: {},
 }
 
+const deepseekModel: Provider.Model = {
+  ...baseModel,
+  id: ModelV2.ID.make("deepseek-reasoner"),
+  providerID: ProviderV2.ID.make("deepseek"),
+  api: {
+    id: "deepseek-reasoner",
+    url: "https://api.deepseek.com/v1",
+    npm: "@ai-sdk/openai-compatible",
+  },
+  name: "DeepSeek Reasoner",
+}
+
 const it = testEffect(
   LLMClient.layer.pipe(Layer.provide(Layer.mergeAll(RequestExecutor.defaultLayer, WebSocketExecutor.layer))),
 )
 
+// UPD-002 residual: the wire-structured-output capability is a CANONICAL declaration, never assumed
+// from Responses support. Locks the two independent facts: the reference OpenAI package is
+// format-capable, while a Responses-capable compatible family (deepseek) is NOT wire-format-capable
+// unless its profile opts in (none do today).
+describe("UPD-002 wire structured-output capability (canonical declaration)", () => {
+  const wireInput = (model: Provider.Model) => ({
+    user: { format: { type: "json_schema" }, metadata: {} } as unknown as SessionV1.User,
+    model,
+    flags: { experimentalNativeLlm: true } as RuntimeFlags.Info,
+  })
+
+  test("reference OpenAI package delivers json_schema over the wire", () => {
+    expect(LLMRequestPrep.shouldUseWireStructuredOutput(wireInput(baseModel))).toBe(true)
+  })
+
+  test("deepseek is Responses-family but NOT wire-format-capable (Responses ≠ format)", () => {
+    expect(LLMRequestPrep.shouldUseWireStructuredOutput(wireInput(deepseekModel))).toBe(false)
+  })
+
+  test("non-Responses providers never take the wire path", () => {
+    const anthropic = {
+      ...baseModel,
+      providerID: ProviderV2.ID.make("anthropic"),
+      api: { ...baseModel.api, npm: "@ai-sdk/anthropic" },
+    }
+    expect(LLMRequestPrep.shouldUseWireStructuredOutput(wireInput(anthropic))).toBe(false)
+  })
+
+  test("without the native runtime flag the wire path is off even for a capable model", () => {
+    const input = wireInput(baseModel)
+    expect(
+      LLMRequestPrep.shouldUseWireStructuredOutput({ ...input, flags: { experimentalNativeLlm: false } as RuntimeFlags.Info }),
+    ).toBe(false)
+  })
+})
+
 function responsesStream(chunks: unknown[]) {
   return new Response(chunks.map((chunk) => `data: ${JSON.stringify(chunk)}`).join("\n\n") + "\n\n", {
     status: 200,
@@ -366,6 +417,31 @@ describe("session.llm-native.request", () => {
     expect(compatible.route.id).toBe("openai-compatible-chat")
     expect(compatible.route.endpoint.baseURL).toBe("https://ai.example.test/v1")
 
+    // Capability-based fork: deepseek profiles declare `supportsResponses`,
+    // so they land on the Responses route with deepseek provider ownership —
+    // never the hardcoded openai route/provider.
+    const deepseek = LLMNative.model({
+      model: deepseekModel,
+      apiKey: "test-key",
+      messages: [],
+    })
+    expect(deepseek.route.id).toBe("openai-compatible-responses")
+    expect(String(deepseek.provider)).toBe("deepseek")
+    expect(String(deepseek.provider)).not.toBe("openai")
+    expect(deepseek.route.endpoint.baseURL).toBe("https://api.deepseek.com/v1")
+
+    const groq = LLMNative.model({
+      model: {
+        ...baseModel,
+        providerID: ProviderV2.ID.make("groq"),
+        api: { ...baseModel.api, url: "https://api.groq.com/openai/v1", npm: "@ai-sdk/openai-compatible" },
+      },
+      apiKey: "test-key",
+      messages: [],
+    })
+    expect(groq.route.id).toBe("openai-compatible-chat")
+    expect(String(groq.provider)).toBe("groq")
+
     const openrouter = LLMNative.model({
       model: { ...baseModel, api: { ...baseModel.api, url: "", npm: "@openrouter/ai-sdk-provider" } },
       apiKey: "test-key",
@@ -419,7 +495,7 @@ describe("session.llm-native.request", () => {
         provider: { ...providerInfo, id: ProviderV2.ID.make("google") },
         auth: undefined,
       }),
-    ).toEqual({ type: "unsupported", reason: "provider is not openai, deepagent-code, anthropic, or deepagent" })
+    ).toEqual({ type: "unsupported", reason: "provider is not openai, deepagent-code, anthropic, deepagent, or deepseek" })
     expect(
       LLMNativeRuntime.status({
         model: baseModel,
@@ -452,6 +528,22 @@ describe("session.llm-native.request", () => {
     ).toEqual({ type: "unsupported", reason: "API key is not configured" })
   })
 
+  test("enables native runtime for deepseek API-key models", () => {
+    expect(
+      LLMNativeRuntime.status({
+        model: deepseekModel,
+        provider: {
+          ...providerInfo,
+          id: ProviderV2.ID.make("deepseek"),
+          name: "DeepSeek",
+          env: ["DEEPSEEK_API_KEY"],
+          options: { apiKey: "test-deepseek-key" },
+        },
+        auth: undefined,
+      }),
+    ).toMatchObject({ type: "supported", apiKey: "test-deepseek-key" })
+  })
+
   test("enables native runtime for Anthropic API-key models", () => {
     expect(
       LLMNativeRuntime.status({
@@ -785,6 +877,33 @@ describe("session.llm-native.request", () => {
     }),
   )
 
+  it.effect("compiles deepseek through the compatible Responses route without include/store", () =>
+    Effect.gen(function* () {
+      const prepared = yield* prepareNativeRequest({
+        model: deepseekModel,
+        apiKey: "test-deepseek-key",
+        messages: [{ role: "user", content: "hello" }],
+        // DeepSeek's Responses compatibility set has not been proven to
+        // support encrypted reasoning; family options keyed under `deepseek`
+        // must never surface OpenAI-only wire fields (include/store).
+        providerOptions: { deepseek: { store: false, include: ["reasoning.encrypted_content"] } },
+      })
+      expect(prepared).toMatchObject({
+        route: "openai-compatible-responses",
+        protocol: "openai-responses",
+        model: { id: "deepseek-reasoner", provider: "deepseek" },
+      })
+      expect(prepared.model.provider).not.toBe("openai")
+      expect(prepared.body).not.toHaveProperty("include")
+      expect(prepared.body).not.toHaveProperty("store")
+      expect(prepared.body).toMatchObject({
+        model: "deepseek-reasoner",
+        input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }],
+        stream: true,
+      })
+    }),
+  )
+
   it.effect("uses provider fetch override for native OpenAI OAuth requests", () =>
     Effect.gen(function* () {
       const captures: Array<{ url: string; body: unknown }> = []
diff --git a/packages/deepagent-code/test/session/llm/tool-pairing.test.ts b/packages/deepagent-code/test/session/llm/tool-pairing.test.ts
new file mode 100644
index 00000000..ff8a346b
--- /dev/null
+++ b/packages/deepagent-code/test/session/llm/tool-pairing.test.ts
@@ -0,0 +1,322 @@
+import { describe, expect, test } from "bun:test"
+import type { ModelMessage } from "ai"
+import { ProviderTransform } from "@/provider/transform"
+import { ToolPairing } from "@/session/llm/tool-pairing"
+
+const INTERRUPTED = "[Tool execution was interrupted]"
+
+function call(toolCallId: string, toolName = "bash") {
+  return { type: "tool-call" as const, toolCallId, toolName, input: { cmd: "ls" } }
+}
+
+function result(toolCallId: string, toolName = "bash", value = "ok") {
+  return { type: "tool-result" as const, toolCallId, toolName, output: { type: "text" as const, value } }
+}
+
+function toolMsg(...parts: ReturnType<typeof result>[]): ModelMessage {
+  return { role: "tool", content: parts }
+}
+
+describe("ToolPairing.repairToolPairing - missing result synthesis", () => {
+  test("synthesizes an error result right after the assistant message carrying the call", () => {
+    const input: ModelMessage[] = [
+      { role: "user", content: "hi" },
+      { role: "assistant", content: [call("call_1")] },
+      { role: "assistant", content: [{ type: "text", text: "continuing" }] },
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(4)
+    expect(out[0]).toBe(input[0])
+    expect(out[1]).toBe(input[1])
+    expect(out[2]).toEqual({
+      role: "tool",
+      content: [
+        {
+          type: "tool-result",
+          toolCallId: "call_1",
+          toolName: "bash",
+          output: { type: "error-text", value: INTERRUPTED },
+        },
+      ],
+    })
+    expect(out[3]).toBe(input[2])
+  })
+
+  test("synthesizes at the end when the dangling call is in the last message", () => {
+    const input: ModelMessage[] = [{ role: "assistant", content: [call("call_last", "read")] }]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(2)
+    expect(out[1]).toEqual({
+      role: "tool",
+      content: [
+        {
+          type: "tool-result",
+          toolCallId: "call_last",
+          toolName: "read",
+          output: { type: "error-text", value: INTERRUPTED },
+        },
+      ],
+    })
+  })
+
+  test("synthesizes only the unmatched call when siblings are paired", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_a"), call("call_b", "read")] },
+      toolMsg(result("call_a")),
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(3)
+    // synthetic for call_b sits between the call message and the result message
+    expect((out[1] as any).content[0].toolCallId).toBe("call_b")
+    expect((out[1] as any).content[0].output).toEqual({ type: "error-text", value: INTERRUPTED })
+    expect(out[2]).toEqual(input[1])
+  })
+
+  test("does not mutate its input", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_1")] },
+      { role: "tool", content: [{ ...result("ghost") }] },
+    ]
+    const snapshot = JSON.parse(JSON.stringify(input))
+    ToolPairing.repairToolPairing(input)
+    expect(input).toEqual(snapshot)
+  })
+})
+
+describe("ToolPairing.repairToolPairing - orphan result stripping", () => {
+  test("strips tool results whose callID never appeared as a call", () => {
+    const input: ModelMessage[] = [
+      toolMsg(result("ghost_1"), result("ghost_2", "read")),
+      { role: "assistant", content: [call("call_1")] },
+      toolMsg(result("call_1")),
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(2)
+    expect(out[0]).toBe(input[1])
+    expect(out[1]).toBe(input[2])
+  })
+
+  test("drops a message entirely when all of its parts are stripped", () => {
+    const input: ModelMessage[] = [
+      { role: "user", content: "hi" },
+      toolMsg(result("ghost")),
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(2)
+    expect(out[0]).toBe(input[0])
+    expect(out[1]).toBe(input[2])
+  })
+
+  test("strips a result that appears before its call (no preceding call)", () => {
+    const input: ModelMessage[] = [
+      toolMsg(result("call_1")),
+      { role: "assistant", content: [call("call_1")] },
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    // orphan result message dropped; dangling call gets a synthetic result
+    expect(out).toHaveLength(2)
+    expect(out[0]).toBe(input[1])
+    expect((out[1] as any).content[0].output).toEqual({ type: "error-text", value: INTERRUPTED })
+  })
+
+  test("keeps non-result parts inside tool messages", () => {
+    const approvalResponse = { type: "tool-approval-response" as const, approvalId: "appr_1", approved: true }
+    const input: ModelMessage[] = [{ role: "tool", content: [result("ghost"), approvalResponse] as any }]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(1)
+    expect((out[0] as any).content).toEqual([approvalResponse])
+  })
+})
+
+describe("ToolPairing.repairToolPairing - duplicate callID dedup", () => {
+  test("keeps the first call and first result for a duplicated callID", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_dup"), call("call_dup")] },
+      toolMsg(result("call_dup", "bash", "first"), result("call_dup", "bash", "second")),
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(2)
+    expect((out[0] as any).content).toEqual([call("call_dup")])
+    expect((out[1] as any).content).toEqual([result("call_dup", "bash", "first")])
+  })
+
+  test("keeps the first result when the duplicate call was dropped", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_x")] },
+      { role: "assistant", content: [call("call_x")] },
+      toolMsg(result("call_x", "bash", "keep")),
+      toolMsg(result("call_x", "bash", "drop")),
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    // duplicate call message is dropped entirely; duplicate result stripped
+    expect(out).toHaveLength(2)
+    expect(out[0]).toBe(input[0])
+    expect(out[1]).toBe(input[2])
+  })
+})
+
+describe("ToolPairing.repairToolPairing - invariants", () => {
+  test("well-formed history passes through with identical references", () => {
+    const input: ModelMessage[] = [
+      { role: "system", content: "be nice" },
+      { role: "user", content: "hi" },
+      { role: "assistant", content: [{ type: "text", text: "thinking" }, call("call_1")] },
+      toolMsg(result("call_1")),
+      { role: "assistant", content: [call("call_2", "read")] },
+      toolMsg(result("call_2", "read", "file content")),
+      { role: "assistant", content: [{ type: "text", text: "done" }] },
+    ]
+    const out = ToolPairing.repairToolPairing(input)
+    expect(out).toHaveLength(input.length)
+    input.forEach((msg, i) => expect(out[i]).toBe(msg))
+  })
+})
+
+describe("ProviderTransform.message - UPD-001 integration", () => {
+  const mistralModel = {
+    id: "mistral/mistral-medium-latest",
+    providerID: "mistral",
+    api: { id: "mistral-medium-latest", url: "https://api.mistral.ai", npm: "@ai-sdk/mistral" },
+    capabilities: {
+      temperature: true,
+      reasoning: false,
+      attachment: false,
+      toolcall: true,
+      input: { text: true, audio: false, image: false, video: false, pdf: false },
+      output: { text: true, audio: false, image: false, video: false, pdf: false },
+      interleaved: false,
+    },
+  } as any
+
+  const plainModel = {
+    id: "openai/gpt-4o",
+    providerID: "openai",
+    api: { id: "gpt-4o", url: "https://api.openai.com", npm: "@ai-sdk/openai" },
+    capabilities: {
+      temperature: true,
+      reasoning: false,
+      attachment: false,
+      toolcall: true,
+      input: { text: true, audio: false, image: false, video: false, pdf: false },
+      output: { text: true, audio: false, image: false, video: false, pdf: false },
+      interleaved: false,
+    },
+  } as any
+
+  test("dedups callIDs that only collide after the mistral scrub", () => {
+    // Both IDs scrub to "callabc12" (non-alphanumerics removed, truncated to 9)
+    const id1 = "call_abc123XYZ"
+    const id2 = "call_abc123!UV"
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call(id1, "bash"), call(id2, "read")] },
+      toolMsg(result(id1, "bash", "first"), result(id2, "read", "second")),
+    ]
+    const out = ProviderTransform.message(input, mistralModel, {})
+    const assistant = out.find((m) => m.role === "assistant")!
+    const toolMsgs = out.filter((m) => m.role === "tool")
+    const callIds = (assistant.content as any[]).filter((p) => p.type === "tool-call").map((p) => p.toolCallId)
+    const resultIds = toolMsgs.flatMap((m) => (m.content as any[]).map((p) => p.toolCallId))
+    expect(callIds).toEqual(["callabc12"])
+    expect(resultIds).toEqual(["callabc12"])
+    // kept result is the first one
+    expect((toolMsgs[0].content as any[])[0].output).toEqual({ type: "text", value: "first" })
+  })
+
+  test("synthetic result before a user message gets the mistral assistant bridge", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_missing")] },
+      { role: "user", content: "keep going" },
+    ]
+    const out = ProviderTransform.message(input, mistralModel, {})
+    expect(out.map((m) => m.role)).toEqual(["assistant", "tool", "assistant", "user"])
+    expect((out[1].content as any[])[0].output).toEqual({ type: "error-text", value: INTERRUPTED })
+    expect(out[2]).toEqual({ role: "assistant", content: [{ type: "text", text: "Done." }] })
+  })
+
+  test("well-formed message() output is structurally unchanged", () => {
+    const input: ModelMessage[] = [
+      { role: "user", content: "hi" },
+      { role: "assistant", content: [call("call_1")] },
+      toolMsg(result("call_1")),
+      { role: "assistant", content: [{ type: "text", text: "all done" }] },
+    ]
+    const out = ProviderTransform.message(JSON.parse(JSON.stringify(input)), plainModel, {})
+    expect(out).toEqual(input)
+  })
+
+  test("repairs dangling call on the plain (non-scrubbing) path too", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_1")] },
+      { role: "assistant", content: [{ type: "text", text: "next" }] },
+    ]
+    const out = ProviderTransform.message(input, plainModel, {})
+    expect(out.map((m) => m.role)).toEqual(["assistant", "tool", "assistant"])
+    expect((out[1].content as any[])[0]).toEqual({
+      type: "tool-result",
+      toolCallId: "call_1",
+      toolName: "bash",
+      output: { type: "error-text", value: INTERRUPTED },
+    })
+  })
+})
+
+// UPD-001 telemetry: the RepairReport records exactly what the repairer changed so the receipt's
+// pre-repair call_ids ↔ repaired wire body divergence is explainable.
+describe("ToolPairing.repairToolPairing - RepairReport telemetry", () => {
+  test("reports synthesized results for dangling calls", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_1")] },
+      { role: "assistant", content: [call("call_2")] },
+    ]
+    const report = ToolPairing.emptyRepairReport()
+    ToolPairing.repairToolPairing(input, { report })
+    expect(report.synthesizedResults.sort()).toEqual(["call_1", "call_2"])
+    expect(report.strippedOrphanResults).toEqual([])
+    expect(report.droppedDuplicates).toEqual([])
+    expect(ToolPairing.repairReportIsEmpty(report)).toBe(false)
+  })
+
+  test("reports stripped orphan results and dropped duplicates", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_1"), call("call_1")] },
+      toolMsg(result("call_1"), result("call_1"), result("orphan_x")),
+    ]
+    const report = ToolPairing.emptyRepairReport()
+    ToolPairing.repairToolPairing(input, { report })
+    expect(report.droppedDuplicates).toEqual(["call_1", "call_1"])
+    expect(report.strippedOrphanResults).toEqual(["orphan_x"])
+    expect(report.synthesizedResults).toEqual([])
+  })
+
+  test("a clean history yields an empty report", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_1")] },
+      toolMsg(result("call_1")),
+    ]
+    const report = ToolPairing.emptyRepairReport()
+    ToolPairing.repairToolPairing(input, { report })
+    expect(ToolPairing.repairReportIsEmpty(report)).toBe(true)
+  })
+
+  test("counts bridged tool→user gaps when bridging is enabled", () => {
+    const input: ModelMessage[] = [
+      { role: "assistant", content: [call("call_1")] },
+      toolMsg(result("call_1")),
+      { role: "user", content: "follow-up" },
+    ]
+    const report = ToolPairing.emptyRepairReport()
+    ToolPairing.repairToolPairing(input, { bridgeToolUserGap: false, report })
+    expect(report.bridgedToolUserGaps).toBe(0)
+    const reportBridged = ToolPairing.emptyRepairReport()
+    ToolPairing.repairToolPairing(
+      [
+        { role: "assistant", content: [call("call_1")] },
+        { role: "user", content: "follow-up" },
+      ],
+      { bridgeToolUserGap: true, report: reportBridged },
+    )
+    expect(reportBridged.bridgedToolUserGaps).toBe(1)
+    expect(reportBridged.synthesizedResults).toEqual(["call_1"])
+  })
+})
diff --git a/packages/deepagent-code/test/session/message-update-event-bytes.test.ts b/packages/deepagent-code/test/session/message-update-event-bytes.test.ts
new file mode 100644
index 00000000..3eb12cac
--- /dev/null
+++ b/packages/deepagent-code/test/session/message-update-event-bytes.test.ts
@@ -0,0 +1,126 @@
+/**
+ * BUG-407-010 §13.3 / REL-002 — a giant user-message summary must not multiply through the
+ * `message.updated` sync stream. The durable message authority keeps the full summary (inline
+ * patch bodies included), but every published/replayed event carries only the bounded client
+ * projection (patch bodies stripped, diff descriptors capped), so updating the same message 20
+ * times yields 20 bounded events whose cumulative bytes never scale with the patch body.
+ *
+ * Everything is driven through the real `Session.updateMessage` state machine and the real
+ * EventV2 sync persistence; no authority rows are inserted directly.
+ */
+import { expect } from "bun:test"
+import { Database } from "@deepagent-code/core/database/database"
+import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
+import { EventTable } from "@deepagent-code/core/event/sql"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
+import { MessageTable } from "@deepagent-code/core/session/sql"
+import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
+import { asc, eq } from "drizzle-orm"
+import { Effect, Layer } from "effect"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { MessageV2 } from "@/session/message-v2"
+import { Session } from "@/session/session"
+import { MessageID } from "@/session/schema"
+import { testEffect } from "../lib/effect"
+import { TestInstance } from "../fixture/fixture"
+
+const layer = Layer.mergeAll(
+  Session.defaultLayer,
+  Database.defaultLayer,
+  EventV2Bridge.defaultLayer,
+  SessionProjector.defaultLayer,
+  SessionProviderOwner.layer.pipe(Layer.provide(Database.defaultLayer)),
+  LocationIdentity.defaultLayer,
+)
+const it = testEffect(layer)
+const model = { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("model") }
+
+const PATCH_MARKER = "GIANT_PATCH_MARKER"
+const PATCH_LINES = 64
+const DIFF_COUNT = MessageV2.ClientDiffLimits.files + 300
+const UPDATES = 20
+
+it.instance(
+  "20 updates of a giant message keep every message.updated event bounded (no patch multiplication)",
+  () =>
+    Effect.gen(function* () {
+      const sessions = yield* Session.Service
+      const { db } = yield* Database.Service
+      yield* TestInstance
+      const session = yield* sessions.create({ title: "giant message event budget" })
+      const messageID = MessageID.ascending()
+
+      const patchBody = Array.from({ length: PATCH_LINES }, (_, line) => `${PATCH_MARKER}:${line}`).join("\n")
+      const diffs = Array.from({ length: DIFF_COUNT }, (_, index) => ({
+        file: `generated/file-${String(index).padStart(4, "0")}.txt`,
+        additions: PATCH_LINES,
+        deletions: 0,
+        patch: patchBody,
+      }))
+      const patchBytesPerUpdate = Buffer.byteLength(patchBody) * DIFF_COUNT
+
+      const eventsBefore = yield* db
+        .select({ count: EventTable.seq })
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, session.id))
+        .all()
+        .pipe(Effect.orDie)
+
+      for (let update = 0; update < UPDATES; update += 1) {
+        yield* sessions.updateMessage({
+          id: messageID,
+          sessionID: session.id,
+          role: "user",
+          time: { created: 1 },
+          agent: "build",
+          model,
+          summary: { additions: PATCH_LINES * DIFF_COUNT, deletions: 0, files: DIFF_COUNT, diffs },
+        } as never)
+      }
+
+      const rows = yield* db
+        .select({ seq: EventTable.seq, type: EventTable.type, data: EventTable.data })
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, session.id))
+        .orderBy(asc(EventTable.seq))
+        .all()
+        .pipe(Effect.orDie)
+      const updated = rows.filter((row) => row.type === "message.updated.1")
+      expect(updated.length).toBe(UPDATES)
+      expect(rows.length).toBe(eventsBefore.length + UPDATES)
+
+      const encoded = updated.map((row) => JSON.stringify(row.data))
+      for (const json of encoded) expect(json).not.toContain(PATCH_MARKER)
+
+      const projectionBytes = encoded.map((json) => Buffer.byteLength(json))
+      const maxBytes = Math.max(...projectionBytes)
+      // Each event must stay far below both one update's patch body and the 4 MiB encoded
+      // payload gate, independent of how large the patch is.
+      expect(maxBytes).toBeLessThan(patchBytesPerUpdate / 4)
+      expect(maxBytes).toBeLessThan(1024 * 1024)
+
+      // BUG-407-010 §13.3: cumulative event bytes must not multiply with the patch body —
+      // 20 bounded projections stay under a single update's patch total.
+      const cumulativeBytes = projectionBytes.reduce((total, bytes) => total + bytes, 0)
+      expect(cumulativeBytes).toBeLessThan(patchBytesPerUpdate)
+
+      for (const row of updated) {
+        const info = row.data["info"] as { summary?: { diffs?: Array<Record<string, unknown>> } }
+        const projected = info.summary?.diffs ?? []
+        expect(projected.length).toBe(MessageV2.ClientDiffLimits.files)
+        for (const item of projected) expect(Object.keys(item)).not.toContain("patch")
+      }
+
+      // The durable authority still owns the full summary; only the wire projection is bounded.
+      const stored = yield* db
+        .select({ data: MessageTable.data })
+        .from(MessageTable)
+        .where(eq(MessageTable.id, messageID))
+        .get()
+        .pipe(Effect.orDie)
+      expect(JSON.stringify(stored?.data)).toContain(PATCH_MARKER)
+    }),
+  { timeout: 30_000 },
+)
diff --git a/packages/deepagent-code/test/session/messages-pagination.test.ts b/packages/deepagent-code/test/session/messages-pagination.test.ts
index aec4eb69..ce49351f 100644
--- a/packages/deepagent-code/test/session/messages-pagination.test.ts
+++ b/packages/deepagent-code/test/session/messages-pagination.test.ts
@@ -3,6 +3,7 @@ import { SessionV1 } from "@deepagent-code/core/v1/session"
 import { Database } from "@deepagent-code/core/database/database"
 import { Effect, Layer, Option } from "effect"
 import { Session as SessionNs } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { MessageV2 } from "../../src/session/message-v2"
 import { MessageID, PartID, type SessionID } from "../../src/session/schema"
 
@@ -14,7 +15,9 @@ import { ModelV2 } from "@deepagent-code/core/model"
 
 void Log.init({ print: false })
 
-const it = testEffect(Layer.mergeAll(SessionNs.defaultLayer, Database.defaultLayer))
+// QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+// writes hit the session FK.
+const it = testEffect(Layer.mergeAll(SessionNs.defaultLayer, SessionProjector.defaultLayer, Database.defaultLayer))
 
 const withSession = <A, E, R>(
   fn: (input: { session: SessionNs.Interface; sessionID: SessionID }) => Effect.Effect<A, E, R>,
diff --git a/packages/deepagent-code/test/session/multi-process-takeover.test.ts b/packages/deepagent-code/test/session/multi-process-takeover.test.ts
new file mode 100644
index 00000000..fd39c76f
--- /dev/null
+++ b/packages/deepagent-code/test/session/multi-process-takeover.test.ts
@@ -0,0 +1,359 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { Database } from "@deepagent-code/core/database/database"
+import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
+import { SessionForkIntentTable } from "@deepagent-code/core/session/sql"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { Effect, Layer } from "effect"
+import { and, eq, sql } from "drizzle-orm"
+import {
+  acquireDurableExecutorLease,
+  releaseDurableExecutorLease,
+  releaseDurableExecutorReservation,
+  reserveDurableExecutor,
+} from "@/session/durable-executor-lock"
+import { Session } from "@/session/session"
+import { MessageID, PartID, type SessionID } from "@/session/schema"
+import { Storage } from "@/storage/storage"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { BackgroundJob } from "@/background/job"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { testInstanceStoreLayer } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const roots: string[] = []
+
+function temporaryRoot() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "deepagent-takeover-drill-"))
+  roots.push(root)
+  return root
+}
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true })
+})
+
+/** A pid that cannot exist on the host, simulating a holder that died via kill -9. */
+const deadPid = 999_999_999
+
+function killHolder(lease: NonNullable<ReturnType<typeof acquireDurableExecutorLease>>, staleMs: number) {
+  clearInterval(lease.heartbeat)
+  const expired = new Date(Date.now() - (staleMs + 1_000))
+  fs.utimesSync(lease.heartbeatPath, expired, expired)
+  const metadata = JSON.parse(fs.readFileSync(lease.metadataPath, "utf-8"))
+  fs.writeFileSync(lease.metadataPath, JSON.stringify({ ...metadata, pid: deadPid }))
+}
+
+describe("RISK-004 drill: durable executor lease takeover", () => {
+  test("a: kill -9 holder (dead pid + missed heartbeats) is quarantined and a successor acquires", () => {
+    const root = temporaryRoot()
+    const workspace = path.join(root, "workspace")
+    fs.mkdirSync(workspace)
+    expect(reserveDurableExecutor(workspace)).toBe(true)
+
+    const first = acquireDurableExecutorLease({
+      directory: workspace,
+      mode: "durable",
+      stateRoot: root,
+      staleMs: 20,
+      heartbeatMs: 60_000,
+    })
+    expect(first).toBeDefined()
+    killHolder(first!, 20)
+    releaseDurableExecutorReservation(workspace)
+
+    expect(reserveDurableExecutor(workspace)).toBe(true)
+    const successor = acquireDurableExecutorLease({
+      directory: workspace,
+      mode: "durable",
+      stateRoot: root,
+      staleMs: 20,
+      heartbeatMs: 60_000,
+    })
+    expect(successor).toBeDefined()
+    expect(successor!.token).not.toBe(first!.token)
+    expect(JSON.parse(fs.readFileSync(successor!.metadataPath, "utf-8")).token).toBe(successor!.token)
+    // Quarantine removes the dead holder's directory; only the successor's lock remains.
+    expect(fs.existsSync(successor!.lockPath)).toBe(true)
+    expect(fs.readdirSync(path.dirname(successor!.lockPath)).filter((name) => name.includes(".stale-"))).toEqual([])
+
+    releaseDurableExecutorLease(successor!)
+  })
+
+  test("b: expired lease held by a live pid is refused (fail-closed) and raises a structured warning", () => {
+    const root = temporaryRoot()
+    const workspace = path.join(root, "workspace")
+    fs.mkdirSync(workspace)
+    expect(reserveDurableExecutor(workspace)).toBe(true)
+
+    const first = acquireDurableExecutorLease({
+      directory: workspace,
+      mode: "durable",
+      stateRoot: root,
+      staleMs: 20,
+      heartbeatMs: 60_000,
+    })
+    expect(first).toBeDefined()
+    // Simulate a wedged holder: heartbeats stopped but the owner process (this one) is alive.
+    clearInterval(first!.heartbeat)
+    const expired = new Date(Date.now() - 1_000)
+    fs.utimesSync(first!.heartbeatPath, expired, expired)
+    releaseDurableExecutorReservation(workspace)
+
+    const warn = spyOn(console, "warn")
+    try {
+      expect(reserveDurableExecutor(workspace)).toBe(true)
+      const successor = acquireDurableExecutorLease({
+        directory: workspace,
+        mode: "durable",
+        stateRoot: root,
+        staleMs: 20,
+        heartbeatMs: 60_000,
+      })
+      // Fail-closed: a live holder is never replaced, even with an expired heartbeat.
+      expect(successor).toBeUndefined()
+      expect(fs.existsSync(first!.lockPath)).toBe(true)
+      expect(JSON.parse(fs.readFileSync(first!.metadataPath, "utf-8")).token).toBe(first!.token)
+      releaseDurableExecutorReservation(workspace)
+
+      expect(warn).toHaveBeenCalled()
+      const call = warn.mock.calls.find(([message]) => String(message).includes("fail-closed"))
+      expect(call).toBeDefined()
+      const detail = call![1] as Record<string, unknown>
+      expect(detail.workspace).toBe(workspace)
+      expect(detail.pid).toBe(process.pid)
+      expect(typeof detail.leaseAgeMs).toBe("number")
+      expect(detail.leaseAgeMs).toBeGreaterThanOrEqual(20)
+    } finally {
+      warn.mockRestore()
+    }
+
+    releaseDurableExecutorLease(first!)
+  })
+
+  test("c1: a displaced holder's heartbeat stops on token mismatch without touching the successor's files", async () => {
+    const root = temporaryRoot()
+    const workspace = path.join(root, "workspace")
+    fs.mkdirSync(workspace)
+    expect(reserveDurableExecutor(workspace)).toBe(true)
+
+    const lease = acquireDurableExecutorLease({
+      directory: workspace,
+      mode: "durable",
+      stateRoot: root,
+      staleMs: 60_000,
+      heartbeatMs: 25,
+    })
+    expect(lease).toBeDefined()
+    await Bun.sleep(60)
+    // A takeover replaces meta.json's token; the old holder's heartbeat must self-terminate.
+    const metadata = JSON.parse(fs.readFileSync(lease!.metadataPath, "utf-8"))
+    fs.writeFileSync(lease!.metadataPath, JSON.stringify({ ...metadata, token: "successor-token" }))
+    const before = fs.statSync(lease!.heartbeatPath).mtimeMs
+    await Bun.sleep(120)
+    const after = fs.statSync(lease!.heartbeatPath).mtimeMs
+    expect(after).toBe(before)
+
+    clearInterval(lease!.heartbeat)
+    releaseDurableExecutorLease(lease!)
+  })
+
+  test("c2: a displaced holder's release with a stale token never removes the successor's lock", () => {
+    const root = temporaryRoot()
+    const workspace = path.join(root, "workspace")
+    fs.mkdirSync(workspace)
+    expect(reserveDurableExecutor(workspace)).toBe(true)
+
+    const first = acquireDurableExecutorLease({
+      directory: workspace,
+      mode: "durable",
+      stateRoot: root,
+      staleMs: 20,
+      heartbeatMs: 60_000,
+    })!
+    killHolder(first, 20)
+    releaseDurableExecutorReservation(workspace)
+
+    expect(reserveDurableExecutor(workspace)).toBe(true)
+    const successor = acquireDurableExecutorLease({
+      directory: workspace,
+      mode: "durable",
+      stateRoot: root,
+      staleMs: 20,
+      heartbeatMs: 60_000,
+    })!
+    expect(successor.token).not.toBe(first.token)
+
+    // The killed holder wakes up and tries to release with its old token: rejected by token check.
+    releaseDurableExecutorLease(first)
+    expect(fs.existsSync(successor.lockPath)).toBe(true)
+    expect(JSON.parse(fs.readFileSync(successor.metadataPath, "utf-8")).token).toBe(successor.token)
+
+    releaseDurableExecutorLease(successor)
+    expect(fs.existsSync(successor.lockPath)).toBe(false)
+  })
+})
+
+const it = testEffect(
+  Layer.mergeAll(
+    Session.layer.pipe(
+      Layer.provide(Storage.defaultLayer),
+      Layer.provide(Database.defaultLayer),
+      Layer.provideMerge(EventV2Bridge.defaultLayer),
+      Layer.provide(SessionProjector.defaultLayer),
+      Layer.provide(RuntimeFlags.layer({ experimentalWorkspaces: false })),
+      Layer.provide(BackgroundJob.defaultLayer),
+    ),
+    Database.defaultLayer,
+    CrossSpawnSpawner.defaultLayer,
+    testInstanceStoreLayer,
+  ),
+)
+
+const addUser = Effect.fn("MultiProcessTakeover.addUser")(function* (sessionID: SessionID, text: string) {
+  const sessions = yield* Session.Service
+  const message = yield* sessions.updateMessage({
+    id: MessageID.ascending(),
+    sessionID,
+    role: "user",
+    time: { created: Date.now() },
+    agent: "test",
+    model: { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("test") },
+  })
+  yield* sessions.updatePart({
+    id: PartID.ascending(),
+    sessionID,
+    messageID: message.id,
+    type: "text",
+    text,
+  })
+  return message.id
+})
+
+const addAssistant = Effect.fn("MultiProcessTakeover.addAssistant")(function* (
+  sessionID: SessionID,
+  parentID: MessageID,
+  text: string,
+) {
+  const sessions = yield* Session.Service
+  const message = yield* sessions.updateMessage({
+    id: MessageID.ascending(),
+    sessionID,
+    role: "assistant",
+    time: { created: Date.now(), completed: Date.now() },
+    parentID,
+    modelID: ModelV2.ID.make("test"),
+    providerID: ProviderV2.ID.make("test"),
+    mode: "test",
+    agent: "test",
+    path: { cwd: "/", root: "/" },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    finish: "stop",
+  })
+  yield* sessions.updatePart({
+    id: PartID.ascending(),
+    sessionID,
+    messageID: message.id,
+    type: "text",
+    text,
+  })
+  return message.id
+})
+
+describe("RISK-004 drill: fork delivery claim lease", () => {
+  it.instance("reclaims an expired fork delivery claim and fences the stale owner's writes", () =>
+    Effect.gen(function* () {
+      const sessions = yield* Session.Service
+      const { db } = yield* Database.Service
+      const parent = yield* sessions.create({})
+      const user = yield* addUser(parent.id, "takeover drill user")
+      yield* addAssistant(parent.id, user, "takeover drill assistant")
+      const intentID = "fork-takeover-lease-reclaim"
+      const staleOwner = "fork-delivery:stale-owner"
+      const triggerName = "test_fork_claim_lease_expiry"
+
+      // Crash the first claimant mid-delivery: every cursor commit aborts.
+      yield* db.run(sql`
+        CREATE TRIGGER ${sql.raw(triggerName)}
+        BEFORE UPDATE OF event_cursor ON session_fork_intent
+        WHEN NEW.intent_id = '${sql.raw(intentID)}'
+        BEGIN
+          SELECT RAISE(ABORT, 'test_fork_delivery_crash');
+        END
+      `)
+      const crashed = yield* sessions.fork({ sessionID: parent.id, intentID }).pipe(Effect.exit)
+      expect(crashed._tag).toBe("Failure")
+      yield* db.run(sql`DROP TRIGGER ${sql.raw(triggerName)}`)
+
+      const crashedIntent = yield* db
+        .select()
+        .from(SessionForkIntentTable)
+        .where(eq(SessionForkIntentTable.intent_id, intentID))
+        .get()
+        .pipe(Effect.orDie)
+      expect(crashedIntent?.state).toBe("committed")
+      expect(crashedIntent?.delivery_owner).toBeNull()
+
+      // Reconstruct the moment a claimant holds the claim but dies: publishing with a lease.
+      const setPublishing = (leaseExpiresAt: number) =>
+        db
+          .update(SessionForkIntentTable)
+          .set({ state: "publishing", delivery_owner: staleOwner, lease_expires_at: leaseExpiresAt, time_updated: Date.now() })
+          .where(eq(SessionForkIntentTable.intent_id, intentID))
+          .run()
+          .pipe(Effect.orDie)
+
+      // A live lease is never stolen: recoverForks leaves the claim untouched.
+      yield* setPublishing(Date.now() + 60_000)
+      yield* sessions.recoverForks()
+      const live = yield* db
+        .select()
+        .from(SessionForkIntentTable)
+        .where(eq(SessionForkIntentTable.intent_id, intentID))
+        .get()
+        .pipe(Effect.orDie)
+      expect(live?.state).toBe("publishing")
+      expect(live?.delivery_owner).toBe(staleOwner)
+
+      // Once the lease expires, a new claimant reclaims and completes delivery.
+      yield* setPublishing(Date.now() - 1_000)
+      yield* sessions.recoverForks()
+      const reclaimed = yield* db
+        .select()
+        .from(SessionForkIntentTable)
+        .where(eq(SessionForkIntentTable.intent_id, intentID))
+        .get()
+        .pipe(Effect.orDie)
+      expect(reclaimed?.state).toBe("complete")
+      expect(reclaimed?.delivery_owner).toBeNull()
+      expect(reclaimed?.lease_expires_at).toBeNull()
+      expect(reclaimed?.event_cursor).toBe(reclaimed?.event_count)
+      expect(reclaimed?.delivery_attempts).toBeGreaterThanOrEqual(2)
+
+      // The stale owner's cursor-advance predicate (intent + owner + state + cursor) matches nothing.
+      const staleWrite = yield* db
+        .update(SessionForkIntentTable)
+        .set({ time_updated: Date.now() })
+        .where(
+          and(
+            eq(SessionForkIntentTable.intent_id, intentID),
+            eq(SessionForkIntentTable.delivery_owner, staleOwner),
+            eq(SessionForkIntentTable.state, "publishing"),
+          ),
+        )
+        .returning({ intent_id: SessionForkIntentTable.intent_id })
+        .get()
+        .pipe(Effect.orDie)
+      expect(staleWrite).toBeUndefined()
+
+      const child = yield* sessions.get(reclaimed!.target_session_id)
+      yield* sessions.remove(child.id)
+      yield* sessions.remove(parent.id)
+    }),
+  )
+})
diff --git a/packages/deepagent-code/test/session/processor-effect.test.ts b/packages/deepagent-code/test/session/processor-effect.test.ts
index 28774f13..b191abd7 100644
--- a/packages/deepagent-code/test/session/processor-effect.test.ts
+++ b/packages/deepagent-code/test/session/processor-effect.test.ts
@@ -3,7 +3,7 @@ import { SessionV1 } from "@deepagent-code/core/v1/session"
 import { PermissionV1 } from "@deepagent-code/core/v1/permission"
 import { Database } from "@deepagent-code/core/database/database"
 import { EventV2Bridge } from "@/event-v2-bridge"
-import { expect } from "bun:test"
+import { afterEach, expect } from "bun:test"
 import { tool } from "ai"
 import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
 import path from "path"
@@ -35,7 +35,7 @@ import { Snapshot } from "../../src/snapshot"
 import * as Log from "@deepagent-code/core/util/log"
 import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
 import { WorkspaceRef } from "../../src/effect/instance-ref"
-import { provideTmpdirInstance, provideTmpdirServer } from "../fixture/fixture"
+import { disposeAllInstances, provideTmpdirInstance, provideTmpdirServer } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 import { raw, reply, TestLLMServer } from "../lib/llm-server"
 import { RuntimeFlags } from "@/effect/runtime-flags"
@@ -67,6 +67,12 @@ import { Tool } from "../../src/tool/tool"
 
 void Log.init({ print: false })
 
+// Dispose any instances loaded into the process-wide AppRuntime instance
+// store so this file leaves no shared state for files that run after it.
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
 const summary = Layer.succeed(
   SessionSummary.Service,
   SessionSummary.Service.of({
@@ -330,7 +336,7 @@ const noProgressLLM = Layer.sync(LLM.Service, () => {
     },
   })
 })
-const durableFlags = RuntimeFlags.layer({ experimentalEventSystem: true, activityAuthority: "durable" })
+const durableFlags = RuntimeFlags.layer({ experimentalEventSystem: true })
 const durablePermission = Permission.layer.pipe(
   Layer.provide(EventV2Bridge.defaultLayer),
   Layer.provide(Database.defaultLayer),
@@ -687,7 +693,7 @@ const admitActivity = Effect.fn("test.admitActivity")(function* (sessionID: Sess
     .run()
     .pipe(Effect.orDie)
   yield* db
-    .insert(SessionActivityAdmissionTable)
+    .insert(SessionActivityAdmissionTable) // fixture-exempt: seeds legacy-intent admission row for processor fixture
     .values({
       admission_id: admissionID,
       session_id: sessionID,
@@ -2123,7 +2129,6 @@ itNoProgress.live(
           const { processors, session, provider } = yield* boot()
           const database = yield* Database.Service
           const permission = yield* Permission.Service
-          expect((yield* RuntimeFlags.Service).activityAuthority).toBe("durable")
           const chat = yield* session.create({})
           const parent = yield* user(chat.id, "read stable.ts until it changes")
           const activityID = yield* admitActivity(chat.id, parent.id)
diff --git a/packages/deepagent-code/test/session/prompt-intent.test.ts b/packages/deepagent-code/test/session/prompt-intent.test.ts
index d1417a94..bb1686f7 100644
--- a/packages/deepagent-code/test/session/prompt-intent.test.ts
+++ b/packages/deepagent-code/test/session/prompt-intent.test.ts
@@ -704,7 +704,7 @@ describe("SessionPromptIntent", () => {
         delivery: "steer",
       })
       yield* db
-        .insert(SessionActivityAdmissionTable)
+        .insert(SessionActivityAdmissionTable) // fixture-exempt: seeds legacy-intent admission row for steer fixture
         .values({
           admission_id: admissionID,
           session_id: sessionID,
@@ -1520,7 +1520,7 @@ function preparingProviderReceipt(input: {
   readonly registryToolIDs: readonly string[]
 }) {
   return input.db
-    .insert(SessionToolRequestReceiptTable)
+    .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds preparing receipt for prompt-intent fixture
     .values({
       receipt_id: input.receiptID,
       request_ordinal: 1,
diff --git a/packages/deepagent-code/test/session/prompt.test.ts b/packages/deepagent-code/test/session/prompt.test.ts
index ae7704f3..c9f6740d 100644
--- a/packages/deepagent-code/test/session/prompt.test.ts
+++ b/packages/deepagent-code/test/session/prompt.test.ts
@@ -2,6 +2,8 @@ import { NodeFileSystem } from "@effect/platform-node"
 import { ConfigV1 } from "@deepagent-code/core/v1/config/config"
 import { SessionV1 } from "@deepagent-code/core/v1/session"
 import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
 import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
 import { LocationIdentityTable } from "@deepagent-code/core/context-federation/sql"
 import {
@@ -20,7 +22,7 @@ import { EventV2Bridge } from "@/event-v2-bridge"
 import { WorkspaceV2 } from "@deepagent-code/core/workspace"
 import { FetchHttpClient } from "effect/unstable/http"
 import { expect } from "bun:test"
-import { Cause, Deferred, Duration, Effect, Exit, Fiber, Layer } from "effect"
+import { Cause, DateTime, Deferred, Duration, Effect, Exit, Fiber, Layer, Logger, References, Stream } from "effect"
 import path from "path"
 import { fileURLToPath, pathToFileURL } from "url"
 import { NamedError } from "@deepagent-code/core/util/error"
@@ -68,6 +70,7 @@ import { SessionPromptIntent } from "../../src/session/prompt-intent"
 import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { SessionStatus } from "../../src/session/status"
 import { SessionV2 } from "@deepagent-code/core/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { SessionExecution } from "@deepagent-code/core/session/execution"
 import { SessionMessage } from "@deepagent-code/core/session/message"
 import { Prompt } from "@deepagent-code/core/session/prompt"
@@ -89,6 +92,8 @@ import { RepositoryCache } from "../../src/reference/repository-cache"
 import { TestInstance, testInstanceStoreLayer, tmpdirScoped } from "../fixture/fixture"
 import { InstanceStore } from "@/project/instance-store"
 import { AgentGateway } from "@deepagent-code/core/agent-gateway"
+import { Global } from "@deepagent-code/core/global"
+import { LLMClient, RequestExecutor, WebSocketExecutor } from "@deepagent-code/llm/route"
 import { createHash } from "node:crypto"
 import { symlink } from "node:fs/promises"
 import { awaitWithTimeout, pollWithTimeout, testEffect } from "../lib/effect"
@@ -283,8 +288,41 @@ type PromptLayerOptions = {
   flags?: Partial<RuntimeFlags.Info>
   federation?: SessionFederatedContext.Interface
   plugin?: Plugin.Interface
+  // FEAT-010: lets a test swap the V2 session layer (default: SessionV2.defaultLayer with noop
+  // execution) so the V2 owner branch of loop() can be observed without a live V2 runner.
+  sessionV2?: Layer.Layer<SessionV2.Service, never, never>
 }
 
+// UPD-002: LLM.defaultLayer hardwires RuntimeFlags.defaultLayer, which would
+// freeze default flags (e.g. experimentalNativeLlm) for every instance. Mirror
+// the default wiring over `LLM.layer` so each harness's runtimeFlags wins.
+const testLLMLayer = (runtimeFlags: Layer.Layer<RuntimeFlags.Service>) =>
+  LLM.layer.pipe(
+    Layer.provide(Auth.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(ProviderSvc.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(
+      Layer.mergeAll(
+        AgentGateway.layer({ enabled: true, runsDir: Global.Path.agent.runs }),
+        LLMClient.layer.pipe(Layer.provide(Layer.mergeAll(RequestExecutor.defaultLayer, WebSocketExecutor.layer))),
+      ),
+    ),
+    Layer.provide(runtimeFlags),
+  )
+
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Apply it over the tracked history
+// so compaction_run carries the mode columns the drizzle schema already declares.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
 function makePrompt(input?: PromptLayerOptions) {
   const runtimeFlags = RuntimeFlags.layer({
     experimentalEventSystem: true,
@@ -295,7 +333,7 @@ function makePrompt(input?: PromptLayerOptions) {
   const deps = Layer.mergeAll(
     Session.defaultLayer,
     Snapshot.defaultLayer,
-    LLM.defaultLayer,
+    testLLMLayer(runtimeFlags),
     Env.defaultLayer,
     AgentSvc.defaultLayer,
     Command.defaultLayer,
@@ -309,7 +347,7 @@ function makePrompt(input?: PromptLayerOptions) {
     FSUtil.defaultLayer,
     BackgroundJob.defaultLayer,
     status,
-    Database.defaultLayer,
+    database,
     EventV2Bridge.defaultLayer,
     PromptEpoch.defaultLayer,
   ).pipe(Layer.provideMerge(infra))
@@ -350,6 +388,7 @@ function makePrompt(input?: PromptLayerOptions) {
         )
   const compact = SessionCompaction.layer.pipe(
     Layer.provide(runtimeFlags),
+    Layer.provide(RequestExecutor.defaultLayer),
     Layer.provideMerge(proc),
     Layer.provideMerge(deps),
   )
@@ -357,7 +396,7 @@ function makePrompt(input?: PromptLayerOptions) {
   // `deps`) so drained steers are visible to the loop's history reads.
   const steer = SessionSteer.layer.pipe(Layer.provideMerge(deps))
   const promptLayer = SessionPrompt.layer.pipe(
-    Layer.provide(SessionV2.defaultLayer),
+    Layer.provide(input?.sessionV2 ?? SessionV2.defaultLayer),
     Layer.provide(SessionProviderOwner.layer.pipe(Layer.provide(deps))),
     Layer.provide(testInstanceStoreLayer),
     Layer.provide(SessionRevert.defaultLayer),
@@ -427,6 +466,12 @@ const worldStateCompactionDisabled = testEffect(
   makeHttp({ flags: { softLandingCompaction: false, worldStateReinjection: false } }),
 )
 const noLLMServer = testEffect(makeHttpNoLLMServer())
+// UPD-002: native runtime ON so a Responses+format-capable family can take the
+// wire structured-output path end to end.
+const wireStructuredOutput = testEffect(makeHttp({ flags: { experimentalNativeLlm: true } }))
+// UPD-002: same provider family but default (AI SDK) runtime — asserts the
+// synthetic StructuredOutput path is retained when the wire path is unavailable.
+const wireCapableAiSdk = testEffect(makeHttp())
 const raceNoLLMServer = testEffect(makeHttpNoLLMServer({ processor: "blocking" }))
 const mutatingProviderHistoryTrigger: Plugin.Interface["trigger"] = (name, _input, output) =>
   Effect.sync(() => {
@@ -462,7 +507,7 @@ const federationAdapter = {
       if (!identity) return yield* Effect.die("prompt federation identity unavailable")
       const releasedKnowledgeBinding = DeepAgentReleasedSnapshot.binding(input.releasedKnowledgeSelection)
       yield* db
-        .insert(SessionActivityTable)
+        .insert(SessionActivityTable) // fixture-exempt: seeds active activity inside federation adapter stub
         .values({
           activity_id: "activity_prompt_adapter",
           session_id: input.session.id,
@@ -607,6 +652,7 @@ const federationAdapter = {
     Effect.sync(() => {
       federationTrace.push(`activity:${state}`)
     }),
+  settleOrphanedActivities: () => Effect.succeed(0),
   replayIndeterminate: () => Effect.die("not used"),
   releasedKnowledgeForActiveSession: () => Effect.succeed(undefined),
 } as unknown as SessionFederatedContext.Interface
@@ -627,6 +673,9 @@ const prepareFailureFederated = testEffect(
       contextFederationShadow: true,
       locationIndexesV2Shadow: true,
       contextProjectionV2: true,
+      // QUAL-006: pin tools OFF — this instance verifies the projection-prepare degradation path in
+      // isolation; the shipped default (tools ON) is covered by runtime-flags and the federated suite.
+      contextQueryToolsV2: false,
     },
     federation: {
       ...federationAdapter,
@@ -639,6 +688,10 @@ const shadowFederated = testEffect(
     flags: {
       contextFederationShadow: true,
       locationIndexesV2Shadow: true,
+      // QUAL-006: pin model-facing owners OFF — this instance verifies shadow-only behavior; the
+      // shipped defaults (both ON) are covered by runtime-flags and the federated suite.
+      contextProjectionV2: false,
+      contextQueryToolsV2: false,
     },
     federation: federationAdapter,
   }),
@@ -716,6 +769,50 @@ function providerCfgWithContext(url: string, context: number) {
   }
 }
 
+// UPD-002: a Responses-family, wire-format-capable provider (@ai-sdk/openai).
+// Official provider IDs ignore config.provider overrides, so this uses a
+// custom id; the `deepagent-code*` prefix keeps the native runtime status gate
+// happy while the npm package drives Responses wire lowering.
+// The baseline `test` provider stays registered (title/small-model paths), and
+// the build agent is pinned to the wire-capable model.
+function wireProviderCfg(url: string) {
+  const base = providerCfg(url)
+  return {
+    ...base,
+    agent: {
+      build: { model: "deepagent-code-wire/test-model" },
+    },
+    provider: {
+      ...base.provider,
+      "deepagent-code-wire": {
+        name: "Wire Test",
+        id: "deepagent-code-wire",
+        env: [],
+        npm: "@ai-sdk/openai",
+        models: {
+          "test-model": {
+            id: "test-model",
+            name: "Test Model",
+            attachment: false,
+            reasoning: false,
+            temperature: false,
+            tool_call: true,
+            release_date: "2025-01-01",
+            limit: { context: 100000, output: 10000 },
+            cost: { input: 0, output: 0 },
+            options: {},
+          },
+        },
+        options: {
+          apiKey: "test-key",
+          baseURL: url,
+          maxRetries: 0,
+        },
+      },
+    },
+  }
+}
+
 const writeText = Effect.fn("test.writeText")(function* (file: string, text: string) {
   const fs = yield* FSUtil.Service
   yield* fs.writeWithDirs(file, text)
@@ -1383,6 +1480,103 @@ it.instance("fingerprints the final persisted structured assistant", () =>
   }),
 )
 
+// UPD-002: wire-level structured output on a Responses + format-capable family.
+wireStructuredOutput.instance("delivers json_schema output through wire text.format", () =>
+  Effect.gen(function* () {
+    const { llm } = yield* useServerConfig(wireProviderCfg)
+    const prompt = yield* SessionPrompt.Service
+    const sessions = yield* Session.Service
+    const chat = yield* sessions.create({
+      title: "Wire structured output",
+      permission: [{ permission: "*", pattern: "*", action: "allow" }],
+    })
+    yield* llm.text('{"answer": 4}')
+    yield* prompt.prompt({
+      sessionID: chat.id,
+      agent: "build",
+      noReply: true,
+      format: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: { answer: { type: "number" } },
+          required: ["answer"],
+        },
+        retryCount: 1,
+      },
+      parts: [{ type: "text", text: "Return the answer." }],
+    })
+
+    const result = yield* prompt.loop({ sessionID: chat.id })
+
+    const wireRequest = (yield* llm.hits).find((item) => JSON.stringify(item.body).includes("Return the answer"))
+    expect(wireRequest).toBeDefined()
+    const body = wireRequest!.body
+    // Wire assertions: Responses endpoint, text.format lowered, NO synthesized
+    // StructuredOutput tool, and tool_choice is not forced to "required".
+    expect(wireRequest!.url.pathname).toBe("/v1/responses")
+    const text = body.text as Record<string, unknown> | undefined
+    expect(text?.format).toMatchObject({ type: "json_schema", name: "structured_output" })
+    expect((text?.format as Record<string, unknown> | undefined)?.schema).toMatchObject({
+      properties: { answer: { type: "number" } },
+    })
+    const tools = Array.isArray(body.tools) ? (body.tools as Array<Record<string, unknown>>) : []
+    expect(tools.some((tool) => tool.name === "StructuredOutput")).toBe(false)
+    expect(body.tool_choice).not.toBe("required")
+
+    expect(result.info.role).toBe("assistant")
+    if (result.info.role === "assistant") {
+      expect(result.info.structured).toEqual({ answer: 4 })
+      expect(result.info.finish).toBe("stop")
+    }
+  }),
+)
+
+// UPD-002: same wire-capable family but native runtime OFF ⇒ the AI SDK path
+// cannot carry the wire format, so the synthetic StructuredOutput tool stays.
+wireCapableAiSdk.instance("keeps the synthetic StructuredOutput path when the runtime is AI SDK", () =>
+  Effect.gen(function* () {
+    const { llm } = yield* useServerConfig(wireProviderCfg)
+    const prompt = yield* SessionPrompt.Service
+    const sessions = yield* Session.Service
+    const chat = yield* sessions.create({
+      title: "Synthetic structured output",
+      permission: [{ permission: "*", pattern: "*", action: "allow" }],
+    })
+    yield* prompt.prompt({
+      sessionID: chat.id,
+      agent: "build",
+      noReply: true,
+      format: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: { answer: { type: "number" } },
+          required: ["answer"],
+        },
+        retryCount: 1,
+      },
+      parts: [{ type: "text", text: "Return the answer." }],
+    })
+    yield* llm.tool("StructuredOutput", { answer: 4 })
+
+    const result = yield* prompt.loop({ sessionID: chat.id })
+
+    const syntheticRequest = (yield* llm.hits).find((item) => JSON.stringify(item.body).includes("Return the answer"))
+    expect(syntheticRequest).toBeDefined()
+    const body = syntheticRequest!.body
+    const tools = Array.isArray(body.tools) ? (body.tools as Array<Record<string, unknown>>) : []
+    expect(tools.some((tool) => tool.name === "StructuredOutput")).toBe(true)
+    expect(body.tool_choice).toBe("required")
+
+    expect(result.info.role).toBe("assistant")
+    if (result.info.role === "assistant") {
+      expect(result.info.structured).toEqual({ answer: 4 })
+      expect(result.info.finish).toBe("tool-calls")
+    }
+  }),
+)
+
 providerHistoryTransform.instance("isolates provider message transforms from durable history authority", () =>
   Effect.gen(function* () {
     const { llm } = yield* useServerConfig(providerCfg)
@@ -1712,7 +1906,7 @@ it.instance("recovers only compaction continuations that were durably not dispat
           .run()
           .pipe(Effect.orDie)
         yield* db
-          .insert(SessionToolRequestReceiptTable)
+          .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds preparing receipt with stale owner for recovery fixture
           .values({
             receipt_id: receiptID,
             request_ordinal: 1,
@@ -4336,6 +4530,47 @@ unix(
   30_000,
 )
 
+// BUG-407-008 §7.1 deterministic regressions: the computed activity-progress projection must be
+// derived from the durable progress authority on read, independent of whether the owning assistant
+// message carries a text part (reasoning-only / tool-only turns still project progress).
+unix(
+  "BUG-407-008 #5: a tool-only assistant turn still yields a computed activityProgress projection",
+  () =>
+    Effect.gen(function* () {
+      const { dir, llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const chat = yield* sessions.create({
+        title: "tool-only computed projection",
+        permission: [{ permission: "*", pattern: "*", action: "allow" }],
+      })
+      yield* prompt.prompt({
+        sessionID: chat.id,
+        agent: "build",
+        noReply: true,
+        parts: [{ type: "text", text: "run the tool" }],
+      })
+      yield* llm.tool("bash", { command: "echo progress-marker", description: "emit", workdir: path.resolve(dir) })
+      yield* llm.text("done")
+      yield* prompt.loop({ sessionID: chat.id })
+
+      const msgs = yield* MessageV2.filterCompactedEffect(chat.id)
+      const withTool = msgs.filter(
+        (item) => item.info.role === "assistant" && item.parts.some((p) => p.type === "tool"),
+      )
+      expect(withTool.length).toBeGreaterThan(0)
+      // The assistant message that owns the tool call carries a computed activityProgress derived
+      // from the durable progress authority — even though it may have no text part of its own.
+      const projected = withTool.find((item) => (item.info as SessionV1.Assistant).activityProgress)
+      expect(projected).toBeDefined()
+      const progress = projected ? (projected.info as SessionV1.Assistant).activityProgress : undefined
+      expect(progress?.revision).toBeGreaterThanOrEqual(0)
+      expect(progress?.activityID).toBeTruthy()
+    }),
+  { git: true },
+  30_000,
+)
+
 unixNoLLMServer(
   "cancel interrupts loop queued behind shell",
   () =>
@@ -5520,3 +5755,178 @@ noLLMServer.instance(
     }),
   30_000,
 )
+
+// FEAT-010: V2 owner fork observability lock-in. The fork logic itself is unchanged — these tests
+// pin the observation seams: (1) when the V2 owner branch is selected, the selection/receipt
+// correlation logs appear and the V2 runner is invoked; (2) the legacy path is unaffected and logs
+// owner=legacy; (3) the fork slog always carries the decision-factor snapshot.
+type CapturedLog = { message: string; level: string; annotations: Record<string, unknown> }
+const captureLogs = <A, E, R>(sink: CapturedLog[], fx: Effect.Effect<A, E, R>) =>
+  fx.pipe(
+    Effect.provide(
+      Logger.layer(
+        [
+          Logger.make(({ message, logLevel, fiber }) => {
+            sink.push({
+              message: String(message),
+              level: logLevel,
+              annotations: { ...fiber.getRef(References.CurrentLogAnnotations) },
+            })
+          }),
+        ],
+        { mergeWithExisting: false },
+      ),
+    ),
+  )
+
+const v2OwnerResumeCalls: string[] = []
+// FEAT-010: the stub replaces SessionV2.Service only; SessionProjector.defaultLayer is merged back
+// in because the default SessionV2 layer stack carries it, and it is the subscriber that persists
+// session/message rows from events (without it, Session.get fails with "Session not found").
+const v2OwnerStubLayer = Layer.merge(
+  Layer.succeed(
+    SessionV2.Service,
+    SessionV2.Service.of({
+      list: () => Effect.succeed([]),
+      create: () => Effect.die("v2 owner stub: create unused"),
+      get: () => Effect.die("v2 owner stub: get unused"),
+      messages: () => Effect.succeed([]),
+      message: () => Effect.succeed(undefined),
+      context: () =>
+        Effect.succeed([
+          new SessionMessage.Assistant({
+            id: SessionMessage.ID.create(),
+            type: "assistant",
+            agent: "build",
+            model: { id: ModelV2.ID.make("test-model"), providerID: ProviderV2.ID.make("test") },
+            content: [
+              new SessionMessage.AssistantText({ type: "text", id: "text-v2-owner-stub", text: "v2 owner reply" }),
+            ],
+            finish: "stop",
+            cost: 0,
+            time: { created: DateTime.makeUnsafe(Date.now()), completed: DateTime.makeUnsafe(Date.now()) },
+          }),
+        ]),
+      events: () => Stream.empty,
+      switchAgent: () => Effect.die("v2 owner stub: switchAgent unused"),
+      switchModel: () => Effect.die("v2 owner stub: switchModel unused"),
+      prompt: () => Effect.die("v2 owner stub: prompt unused"),
+      shell: () => Effect.die("v2 owner stub: shell unused"),
+      skill: () => Effect.die("v2 owner stub: skill unused"),
+      compact: () => Effect.die("v2 owner stub: compact unused"),
+      wait: () => Effect.die("v2 owner stub: wait unused"),
+      resume: (sessionID) =>
+        Effect.sync(() => {
+          v2OwnerResumeCalls.push(sessionID)
+        }),
+      interrupt: () => Effect.void,
+    }),
+  ),
+  SessionProjector.defaultLayer,
+)
+const v2Owner = testEffect(makeHttp({ flags: { coreV2ExecutionOwner: true }, sessionV2: v2OwnerStubLayer }))
+
+v2Owner.instance(
+  "V2 owner branch selected executes the V2 runner and emits selection + receipt-correlation logs",
+  () =>
+    Effect.gen(function* () {
+      const { llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const chat = yield* sessions.create({
+        title: "V2 owner fork",
+        permission: [{ permission: "*", pattern: "*", action: "allow" }],
+      })
+      yield* prompt.prompt({
+        sessionID: chat.id,
+        agent: "build",
+        noReply: true,
+        parts: [{ type: "text", text: "hello" }],
+      })
+      v2OwnerResumeCalls.length = 0
+      const logs: CapturedLog[] = []
+
+      const result = yield* captureLogs(logs, prompt.loop({ sessionID: chat.id }))
+
+      // The V2 owner branch was selected AND executed: the V2 runner resume fired once, the
+      // legacy LLM path was never touched, and the projected assistant came from the V2 context.
+      expect(v2OwnerResumeCalls).toEqual([chat.id])
+      expect(yield* llm.hits).toHaveLength(0)
+      expect(result.info.role).toBe("assistant")
+      expect(result.parts.some((part) => part.type === "text" && part.text === "v2 owner reply")).toBe(true)
+
+      // Fork slog: info level, owner selection + decision-factor snapshot.
+      const forks = logs.filter((entry) => entry.message === "v2 owner fork")
+      expect(forks.length).toBeGreaterThan(0)
+      for (const fork of forks) {
+        expect(fork.level).toBe("Info")
+        expect(fork.annotations).toMatchObject({
+          "session.id": chat.id,
+          owner: "v2",
+          releaseQualified: true,
+          coreV2ExecutionOwnerFlag: true,
+          coreV2ExecutionOwnerEnabled: true,
+          parityCampaign: "none",
+          ownerCampaign: "release",
+        })
+      }
+      // Selection log with the owner=selection reason + durable receipt correlation log.
+      expect(
+        logs.some(
+          (entry) =>
+            entry.message === "v2 owner branch selected" &&
+            entry.annotations.owner === "v2" &&
+            entry.annotations.reason === "rollout_gate_open",
+        ),
+      ).toBe(true)
+      expect(logs.some((entry) => entry.message === "v2 owner turn receipt")).toBe(true)
+    }),
+  30_000,
+)
+
+it.instance(
+  "legacy loop is unaffected by the fork observation and logs owner=legacy with decision factors",
+  () =>
+    Effect.gen(function* () {
+      const { llm } = yield* useServerConfig(providerCfg)
+      const prompt = yield* SessionPrompt.Service
+      const sessions = yield* Session.Service
+      const chat = yield* sessions.create({
+        title: "Legacy fork",
+        permission: [{ permission: "*", pattern: "*", action: "allow" }],
+      })
+      yield* prompt.prompt({
+        sessionID: chat.id,
+        agent: "build",
+        noReply: true,
+        parts: [{ type: "text", text: "hello" }],
+      })
+      yield* llm.text("world")
+      v2OwnerResumeCalls.length = 0
+      const logs: CapturedLog[] = []
+
+      const result = yield* captureLogs(logs, prompt.loop({ sessionID: chat.id }))
+
+      // Legacy behavior intact: the turn ran through the legacy provider and returned the reply.
+      expect(result.info.role).toBe("assistant")
+      expect(result.parts.some((part) => part.type === "text" && part.text === "world")).toBe(true)
+      expect(yield* llm.hits).toHaveLength(1)
+      expect(v2OwnerResumeCalls).toHaveLength(0)
+
+      // Fork slog still fires with the decision-factor snapshot, selecting legacy.
+      const forks = logs.filter((entry) => entry.message === "v2 owner fork")
+      expect(forks.length).toBeGreaterThan(0)
+      for (const fork of forks) {
+        expect(fork.level).toBe("Info")
+        expect(fork.annotations).toMatchObject({
+          "session.id": chat.id,
+          owner: "legacy",
+          releaseQualified: true,
+          coreV2ExecutionOwnerFlag: false,
+          coreV2ExecutionOwnerEnabled: false,
+        })
+      }
+      expect(logs.some((entry) => entry.message === "v2 owner branch selected")).toBe(false)
+    }),
+  30_000,
+)
diff --git a/packages/deepagent-code/test/session/provider-receipt-recovery.test.ts b/packages/deepagent-code/test/session/provider-receipt-recovery.test.ts
index 1d490bb6..e20e3076 100644
--- a/packages/deepagent-code/test/session/provider-receipt-recovery.test.ts
+++ b/packages/deepagent-code/test/session/provider-receipt-recovery.test.ts
@@ -636,7 +636,7 @@ function seed(db: Database.Interface["db"], options: { readonly releaseStaleOwne
       })
       .run()
     yield* db
-      .insert(SessionActivityTable)
+      .insert(SessionActivityTable) // fixture-exempt: seeds active activity for receipt-recovery fixture
       .values({
         activity_id: activityId,
         session_id: sessionId,
@@ -680,7 +680,7 @@ function seed(db: Database.Interface["db"], options: { readonly releaseStaleOwne
       })
       .run()
     yield* db
-      .insert(SessionProviderAttemptTable)
+      .insert(SessionProviderAttemptTable) // fixture-exempt: seeds attempt batch for receipt-recovery fixture
       .values([attempt(0), attempt(1), attempt(2), attempt(3), attempt(4)])
       .run()
     yield* Effect.forEach([0, 1, 2, 3], (providerTurnSeq) =>
@@ -694,7 +694,7 @@ function seed(db: Database.Interface["db"], options: { readonly releaseStaleOwne
         .run(),
     )
     yield* db
-      .insert(SessionToolRequestReceiptTable)
+      .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds receipt batch for receipt-recovery fixture
       .values([receipt(0), receipt(1), receipt(2), receipt(3)])
       .run()
     yield* db
diff --git a/packages/deepagent-code/test/session/remote-compact.test.ts b/packages/deepagent-code/test/session/remote-compact.test.ts
new file mode 100644
index 00000000..3c4da1f5
--- /dev/null
+++ b/packages/deepagent-code/test/session/remote-compact.test.ts
@@ -0,0 +1,374 @@
+import { describe, expect } from "bun:test"
+import { RequestExecutor } from "@deepagent-code/llm/route"
+import { Effect, Layer, Ref } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import type { ModelMessage } from "ai"
+import { join } from "path"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
+import type { Provider } from "@/provider/provider"
+import { RemoteCompact } from "@/session/remote-compact"
+import { testEffect } from "../lib/effect"
+import { TestInstance } from "../fixture/fixture"
+
+const JSON_HEADERS = { "content-type": "application/json" } as const
+
+const openaiModel: Provider.Model = {
+  id: ModelV2.ID.make("gpt-5-mini"),
+  providerID: ProviderV2.ID.make("openai"),
+  api: {
+    id: "gpt-5-mini",
+    url: "https://api.openai.test/v1",
+    npm: "@ai-sdk/openai",
+  },
+  name: "GPT-5 Mini",
+  capabilities: {
+    temperature: true,
+    reasoning: true,
+    attachment: true,
+    toolcall: true,
+    input: { text: true, audio: false, image: true, video: false, pdf: false },
+    output: { text: true, audio: false, image: false, video: false, pdf: false },
+    interleaved: false,
+  },
+  cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+  limit: { context: 128_000, input: 128_000, output: 32_000 },
+  status: "active",
+  options: {},
+  headers: {},
+  release_date: "2026-01-01",
+}
+
+const deepseekModel: Provider.Model = {
+  ...openaiModel,
+  id: ModelV2.ID.make("deepseek-chat"),
+  providerID: ProviderV2.ID.make("deepseek"),
+  api: { id: "deepseek-chat", url: "https://api.deepseek.com/v1", npm: "@ai-sdk/openai-compatible" },
+  name: "DeepSeek Chat",
+}
+
+const anthropicModel: Provider.Model = {
+  ...openaiModel,
+  id: ModelV2.ID.make("claude-sonnet-4"),
+  providerID: ProviderV2.ID.make("anthropic"),
+  api: { id: "claude-sonnet-4", url: "https://api.anthropic.com", npm: "@ai-sdk/anthropic" },
+  name: "Claude Sonnet 4",
+}
+
+const providerInfo: Provider.Info = {
+  id: ProviderV2.ID.make("openai"),
+  name: "OpenAI",
+  source: "config",
+  env: ["OPENAI_API_KEY"],
+  options: { apiKey: "test-openai-key" },
+  models: {},
+}
+
+const history: ModelMessage[] = [
+  { role: "user", content: [{ type: "text", text: "Fix the failing test." }] },
+  { role: "assistant", content: [{ type: "text", text: "Looking into it." }] },
+]
+
+const input = (model: Provider.Model, sessionID = "ses_remote_compact"): RemoteCompact.RemoteCompactionInput => ({
+  sessionID,
+  model,
+  provider: providerInfo,
+  auth: undefined,
+  messages: history,
+})
+
+type Handler = (handlerInput: {
+  readonly request: HttpClientRequest.HttpClientRequest
+  readonly text: string
+  readonly respond: (body: ConstructorParameters<typeof Response>[0], init?: ResponseInit) => HttpClientResponse.HttpClientResponse
+}) => Effect.Effect<HttpClientResponse.HttpClientResponse>
+
+const handlerLayer = (handler: Handler): Layer.Layer<HttpClient.HttpClient> =>
+  Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) =>
+      Effect.gen(function* () {
+        const web = yield* HttpClientRequest.toWeb(request).pipe(Effect.orDie)
+        const text = yield* Effect.promise(() => web.text())
+        return yield* handler({
+          request,
+          text,
+          respond: (body, init) => HttpClientResponse.fromWeb(request, new Response(body, init)),
+        })
+      }),
+    ),
+  )
+
+const compactLayer = (handler: Handler): Layer.Layer<RequestExecutor.Service> =>
+  Layer.provideMerge(RequestExecutor.layer, handlerLayer(handler))
+
+// Fail-over must be immediate: never burn a status-retry budget on compact.
+const noRetries = Effect.provideService(RequestExecutor.CurrentRetryLimit, 0)
+
+const compactResponse = (encryptedContent: string) =>
+  JSON.stringify({ output: [{ type: "compaction", id: "cmp_1", encrypted_content: encryptedContent }] })
+
+// Every test provides its own executor layer: layers are memoized by identity
+// during build, so a shared describe-level layer would leak its HttpClient
+// binding into tests that expect a different handler.
+const noHttpLayer = compactLayer(() => Effect.die(new Error("no HTTP expected")))
+
+describe("remote compaction capability branch", () => {
+  // `live` keeps the real clock so retry backoff (should it ever fire) never
+  // stalls on TestClock.
+  const it = testEffect(Layer.empty)
+
+  it.live("routes canonical OpenAI to the server-side path", () =>
+    Effect.gen(function* () {
+      expect(RemoteCompact.supportsRemoteCompaction(openaiModel)).toBe(true)
+      const outcome = yield* RemoteCompact.attemptRemoteCompaction(input(openaiModel)).pipe(
+        Effect.provide(
+          compactLayer(({ respond }) => Effect.succeed(respond(compactResponse("enc-openai"), { headers: JSON_HEADERS }))),
+        ),
+        noRetries,
+      )
+      expect(outcome).toEqual({ used: "remote", encryptedContent: "enc-openai" })
+      expect(RemoteCompact.EncryptedContentStore.get("ses_remote_compact")).toBe("enc-openai")
+    }),
+  )
+
+  it.live("routes deepseek (verified /responses/compact support) to the server-side path", () =>
+    Effect.gen(function* () {
+      expect(RemoteCompact.supportsRemoteCompaction(deepseekModel)).toBe(true)
+      const outcome = yield* RemoteCompact.attemptRemoteCompaction(input(deepseekModel, "ses_deepseek")).pipe(
+        Effect.provide(
+          compactLayer(({ respond }) => Effect.succeed(respond(compactResponse("enc-deepseek"), { headers: JSON_HEADERS }))),
+        ),
+        noRetries,
+      )
+      expect(outcome).toEqual({ used: "remote", encryptedContent: "enc-deepseek" })
+      expect(RemoteCompact.EncryptedContentStore.get("ses_deepseek")).toBe("enc-deepseek")
+    }),
+  )
+
+  it.live("routes anthropic to the local path without HTTP", () =>
+    Effect.gen(function* () {
+      expect(RemoteCompact.supportsRemoteCompaction(anthropicModel)).toBe(false)
+      const outcome = yield* RemoteCompact.attemptRemoteCompaction(input(anthropicModel, "ses_anthropic")).pipe(
+        Effect.provide(noHttpLayer),
+        noRetries,
+      )
+      expect(outcome.used).toBe("local")
+    }),
+  )
+
+  it.live("falls back to local when no API key is configured", () =>
+    Effect.gen(function* () {
+      const outcome = yield* RemoteCompact.attemptRemoteCompaction({
+        ...input(openaiModel, "ses_no_key"),
+        provider: { ...providerInfo, options: {} },
+      }).pipe(
+        Effect.provide(noHttpLayer),
+        noRetries,
+      )
+      expect(outcome.used).toBe("local")
+      expect(outcome.used === "local" && outcome.reason).toContain("API key")
+    }),
+  )
+})
+
+describe("remote compaction fail-over", () => {
+  const it = testEffect(Layer.empty)
+
+  it.live("fails over to local on provider HTTP errors", () =>
+    RemoteCompact.attemptRemoteCompaction(input(openaiModel, "ses_http_fail")).pipe(
+      Effect.provide(
+        compactLayer(({ respond }) =>
+          Effect.succeed(respond(JSON.stringify({ error: "boom" }), { status: 500, headers: JSON_HEADERS })),
+        ),
+      ),
+      noRetries,
+      Effect.tap((outcome) =>
+        Effect.sync(() => {
+          expect(outcome.used).toBe("local")
+          expect(RemoteCompact.EncryptedContentStore.get("ses_http_fail")).toBeUndefined()
+        }),
+      ),
+    ),
+  )
+
+  it.live("fails over to local when the compact payload is malformed", () =>
+    RemoteCompact.attemptRemoteCompaction(input(openaiModel, "ses_bad_payload")).pipe(
+      Effect.provide(compactLayer(({ respond }) => Effect.succeed(respond("not-json", { headers: JSON_HEADERS })))),
+      noRetries,
+      Effect.tap((outcome) =>
+        Effect.sync(() => {
+          expect(outcome.used).toBe("local")
+        }),
+      ),
+    ),
+  )
+
+  it.live("fails over to local when no compaction item is returned", () =>
+    RemoteCompact.attemptRemoteCompaction(input(openaiModel, "ses_no_item")).pipe(
+      Effect.provide(
+        compactLayer(({ respond }) => Effect.succeed(respond(JSON.stringify({ output: [] }), { headers: JSON_HEADERS }))),
+      ),
+      noRetries,
+      Effect.tap((outcome) =>
+        Effect.sync(() => {
+          expect(outcome.used).toBe("local")
+        }),
+      ),
+    ),
+  )
+
+  // §4.3 same-provenance guard: a blob minted by another provider can never be
+  // replayed — drop it and fall back to local summarization, without HTTP.
+  it.live("clears a foreign-provider blob and fails over to local (§4.3 same source)", () =>
+    Effect.gen(function* () {
+      RemoteCompact.EncryptedContentStore.set("ses_cross_provider", "enc-foreign", { providerID: "deepseek" })
+      const outcome = yield* RemoteCompact.attemptRemoteCompaction(input(openaiModel, "ses_cross_provider")).pipe(
+        Effect.provide(noHttpLayer),
+        noRetries,
+      )
+      expect(outcome.used).toBe("local")
+      expect(outcome.used === "local" && outcome.reason).toContain("belongs to provider deepseek")
+      expect(RemoteCompact.EncryptedContentStore.get("ses_cross_provider")).toBeUndefined()
+    }),
+  )
+
+  // §4.3 capability loss: switching to a model whose route does not serve
+  // /responses/compact invalidates any staged blob so it can never be replayed.
+  it.live("clears a stale blob when the capability probe is false (§4.3)", () =>
+    Effect.gen(function* () {
+      RemoteCompact.EncryptedContentStore.set("ses_capability_lost", "enc-stale")
+      const outcome = yield* RemoteCompact.attemptRemoteCompaction(input(anthropicModel, "ses_capability_lost")).pipe(
+        Effect.provide(noHttpLayer),
+        noRetries,
+      )
+      expect(outcome.used).toBe("local")
+      expect(RemoteCompact.EncryptedContentStore.get("ses_capability_lost")).toBeUndefined()
+    }),
+  )
+})
+
+describe("remote compaction encrypted_content staging", () => {
+  const it = testEffect(Layer.empty)
+
+  it.live("sends the staged encrypted context back on the next compaction", () =>
+    Effect.gen(function* () {
+      const sessionID = "ses_round_trip"
+      const bodies = yield* Ref.make<ReadonlyArray<Record<string, unknown>>>([])
+      const counter = yield* Ref.make(0)
+      const layer: Layer.Layer<RequestExecutor.Service> = compactLayer(({ request, respond }) =>
+        Effect.gen(function* () {
+          const web = yield* HttpClientRequest.toWeb(request).pipe(Effect.orDie)
+          expect(web.url).toBe("https://api.openai.test/v1/responses/compact")
+          const body = (yield* Effect.promise(() => web.json())) as Record<string, unknown>
+          yield* Ref.update(bodies, (items) => [...items, body])
+          const current = yield* Ref.get(counter)
+          yield* Ref.set(counter, current + 1)
+          return respond(compactResponse(`enc-${current + 1}`), { headers: JSON_HEADERS })
+        }),
+      )
+      const first = yield* RemoteCompact.attemptRemoteCompaction(input(openaiModel, sessionID)).pipe(
+        Effect.provide(layer),
+        noRetries,
+      )
+      expect(first).toEqual({ used: "remote", encryptedContent: "enc-1" })
+      expect(RemoteCompact.EncryptedContentStore.get(sessionID)).toBe("enc-1")
+      const second = yield* RemoteCompact.attemptRemoteCompaction(input(openaiModel, sessionID)).pipe(
+        Effect.provide(layer),
+        noRetries,
+      )
+      expect(second).toEqual({ used: "remote", encryptedContent: "enc-2" })
+      const sent = yield* Ref.get(bodies)
+      expect(sent).toHaveLength(2)
+      const firstInput = sent[0]!.input as ReadonlyArray<Record<string, unknown>>
+      const secondInput = sent[1]!.input as ReadonlyArray<Record<string, unknown>>
+      expect(firstInput[0]).toEqual({ role: "user", content: [{ type: "input_text", text: "Fix the failing test." }] })
+      expect(secondInput[0]).toEqual({ type: "compaction", encrypted_content: "enc-1" })
+      expect(sent[1]!.model).toBe("gpt-5-mini")
+      expect(sent[0]!.stream).toBeUndefined()
+    }),
+  )
+
+  it.live("clearing the store drops the staged context (restart semantics)", () =>
+    Effect.gen(function* () {
+      RemoteCompact.EncryptedContentStore.set("ses_restart", "enc-lost")
+      expect(RemoteCompact.EncryptedContentStore.get("ses_restart")).toBe("enc-lost")
+      RemoteCompact.EncryptedContentStore.clear("ses_restart")
+      expect(RemoteCompact.EncryptedContentStore.get("ses_restart")).toBeUndefined()
+    }),
+  )
+})
+
+// Gap 1 durability: with a bound Database handle the blob survives a process
+// restart (fresh Database instance over the same file). The migration is not
+// registered in migration.gen.ts yet (mainline does that), so each phase
+// applies it explicitly via applyOnly — tracked, hence idempotent across the
+// two phases.
+describe("remote compaction encrypted_content durability (Gap 1)", () => {
+  const it = testEffect(Layer.empty)
+
+  const seedSession = (db: Database.Interface["db"], sessionID: string) =>
+    Effect.gen(function* () {
+      yield* db.run(`
+        INSERT INTO project (id, worktree, sandboxes, time_created, time_updated)
+        VALUES ('project-${sessionID}', '/repo', '[]', 1, 1)
+      `)
+      yield* db.run(`
+        INSERT INTO session (
+          id, project_id, slug, directory, title, version, mutation_epoch, time_created, time_updated
+        ) VALUES (
+          '${sessionID}', 'project-${sessionID}', '${sessionID}', '/repo', 'Remote compact', '1', 0, 1, 1
+        )
+      `)
+    })
+
+  it.instance(
+    "set → restart (new Database instance, same file) → get hits with attribution",
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const file = join(test.directory, "remote-compact.db")
+      const sessionID = "ses_persist_round_trip"
+      yield* Effect.addFinalizer(() => Effect.sync(() => RemoteCompact.EncryptedContentStore.bind(undefined)))
+
+      // Phase 1 — first process: bind, seed, store.
+      yield* Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistenceMigration])
+        yield* seedSession(db, sessionID)
+        RemoteCompact.EncryptedContentStore.bind(db)
+        RemoteCompact.EncryptedContentStore.set(sessionID, "enc-durable", {
+          providerID: "openai",
+          modelID: "gpt-5-mini",
+          sourceRunID: "run-persist-1",
+        })
+        expect(RemoteCompact.EncryptedContentStore.get(sessionID)).toBe("enc-durable")
+        RemoteCompact.EncryptedContentStore.bind(undefined)
+        // Unbound store is memory-only: the durable row is invisible here.
+        expect(RemoteCompact.EncryptedContentStore.get(sessionID)).toBeUndefined()
+      }).pipe(Effect.provide(Database.layerFromPath(file)))
+
+      // Phase 2 — restart: a fresh Database instance over the same file sees it.
+      yield* Effect.gen(function* () {
+        const { db } = yield* Database.Service
+        yield* DatabaseMigration.applyOnly(db, [remoteCompactPersistenceMigration])
+        RemoteCompact.EncryptedContentStore.bind(db)
+        expect(RemoteCompact.EncryptedContentStore.get(sessionID)).toBe("enc-durable")
+        const record = RemoteCompact.EncryptedContentStore.getRecord(sessionID)
+        expect(record?.providerID).toBe("openai")
+        expect(record?.modelID).toBe("gpt-5-mini")
+        expect(record?.sourceRunID).toBe("run-persist-1")
+
+        // Latest wins: a second set replaces the row (never a second row).
+        RemoteCompact.EncryptedContentStore.set(sessionID, "enc-durable-2", { providerID: "openai" })
+        expect(RemoteCompact.EncryptedContentStore.get(sessionID)).toBe("enc-durable-2")
+
+        // Fail-over clear removes the durable row as well.
+        RemoteCompact.EncryptedContentStore.clear(sessionID)
+        expect(RemoteCompact.EncryptedContentStore.get(sessionID)).toBeUndefined()
+      }).pipe(Effect.provide(Database.layerFromPath(file)))
+    }),
+  )
+})
diff --git a/packages/deepagent-code/test/session/retry.test.ts b/packages/deepagent-code/test/session/retry.test.ts
index 2593cb83..e3d93876 100644
--- a/packages/deepagent-code/test/session/retry.test.ts
+++ b/packages/deepagent-code/test/session/retry.test.ts
@@ -1,6 +1,14 @@
 import { describe, expect, test } from "bun:test"
 import { SessionV1 } from "@deepagent-code/core/v1/session"
 import type { NamedError } from "@deepagent-code/core/util/error"
+import {
+  LLMError,
+  ProviderInternalReason,
+  QuotaExceededReason,
+  RateLimitReason,
+  TransportReason,
+  type LLMErrorReason,
+} from "@deepagent-code/llm"
 import { APICallError } from "ai"
 import { setTimeout as sleep } from "node:timers/promises"
 import { Effect, Layer, Schedule, Schema } from "effect"
@@ -357,6 +365,86 @@ describe("session.retry.retryable", () => {
   })
 })
 
+describe("session.retry.reason classification", () => {
+  const llmError = (reason: LLMErrorReason) =>
+    new LLMError({ module: "RequestExecutor", method: "execute", reason })
+
+  test("detects llm errors structurally", () => {
+    expect(SessionRetry.isLLMError(llmError(new RateLimitReason({ message: "HTTP 429" })))).toBe(true)
+    // Wrapped/serialized shapes still classify.
+    expect(SessionRetry.isLLMError({ _tag: "LLM.Error", reason: { _tag: "RateLimit" } })).toBe(true)
+    expect(SessionRetry.isLLMError(new TypeError("terminated"))).toBe(false)
+    expect(SessionRetry.isLLMError({ _tag: "LLM.Error" })).toBe(false)
+  })
+
+  test("retries rate limit and provider internal reasons", () => {
+    expect(SessionRetry.retryableViaReason(llmError(new RateLimitReason({ message: "HTTP 429" })))).toEqual({
+      message: "HTTP 429",
+    })
+    expect(
+      SessionRetry.retryableViaReason(llmError(new ProviderInternalReason({ message: "HTTP 503", status: 503 }))),
+    ).toEqual({ message: "HTTP 503" })
+  })
+
+  test("retries only pre-dispatch transport reasons", () => {
+    expect(
+      SessionRetry.retryableViaReason(llmError(new TransportReason({ message: "connect failed", phase: "pre-dispatch" }))),
+    ).toEqual({ message: "connect failed" })
+    // Post-dispatch transport failures may already have been billed.
+    expect(
+      SessionRetry.retryableViaReason(llmError(new TransportReason({ message: "stream broke", phase: "post-dispatch" }))),
+    ).toBeUndefined()
+    expect(SessionRetry.retryableViaReason(llmError(new TransportReason({ message: "ws closed" })))).toBeUndefined()
+  })
+
+  test("terminal reasons are never retried", () => {
+    expect(
+      SessionRetry.retryableViaReason(llmError(new QuotaExceededReason({ message: "insufficient_quota" }))),
+    ).toBeUndefined()
+  })
+
+  test("classification wins over string heuristics when a reason is available", () => {
+    const quota = llmError(new QuotaExceededReason({ message: "rate limited: insufficient_quota" }))
+    // The heuristic alone would retry this parsed message.
+    const heuristicMatch = wrap("rate limit exceeded")
+    expect(SessionRetry.retryable(heuristicMatch, retryProvider)).toBeDefined()
+    expect(SessionRetry.retryableFor(quota, heuristicMatch, retryProvider)).toBeUndefined()
+  })
+
+  test("falls back to string heuristics without an llm reason", () => {
+    const raw = new TypeError("terminated")
+    const parsed = wrap(JSON.stringify({ type: "error", error: { type: "too_many_requests" } }))
+    expect(SessionRetry.retryableFor(raw, parsed, retryProvider)).toEqual({ message: "Too Many Requests" })
+  })
+
+  it.instance("policy classifies raw llm errors before heuristics run", () =>
+    Effect.gen(function* () {
+      const sessionID = SessionID.make("session-retry-classification")
+      const status = yield* SessionStatus.Service
+
+      const step = yield* Schedule.toStepWithMetadata(
+        SessionRetry.policy({
+          provider: "test",
+          parse: (e) => MessageV2.fromError(e, { providerID }),
+          set: (info) =>
+            status.set(sessionID, {
+              type: "retry",
+              attempt: info.attempt,
+              message: info.message,
+              next: info.next,
+            }),
+        }),
+      )
+      yield* step(llmError(new RateLimitReason({ message: "Provider request failed with HTTP 429" })))
+
+      expect(yield* status.get(sessionID)).toMatchObject({
+        type: "retry",
+        message: "Provider request failed with HTTP 429",
+      })
+    }),
+  )
+})
+
 describe("session.message-v2.fromError", () => {
   test.concurrent(
     "converts ECONNRESET socket errors to retryable APIError",
diff --git a/packages/deepagent-code/test/session/revert-compact.test.ts b/packages/deepagent-code/test/session/revert-compact.test.ts
index 99101222..dcc8ab82 100644
--- a/packages/deepagent-code/test/session/revert-compact.test.ts
+++ b/packages/deepagent-code/test/session/revert-compact.test.ts
@@ -15,12 +15,16 @@ import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 import { ProviderV2 } from "@deepagent-code/core/provider"
 import { ModelV2 } from "@deepagent-code/core/model"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { Storage } from "@/storage/storage"
 
 void Log.init({ print: false })
 
 const env = Layer.mergeAll(
   Session.defaultLayer,
+  // QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+  // writes hit the session FK.
+  SessionProjector.defaultLayer,
   SessionRevert.defaultLayer,
   Snapshot.defaultLayer,
   Storage.defaultLayer,
diff --git a/packages/deepagent-code/test/session/snapshot-tool-race.test.ts b/packages/deepagent-code/test/session/snapshot-tool-race.test.ts
index 62f79177..eede6444 100644
--- a/packages/deepagent-code/test/session/snapshot-tool-race.test.ts
+++ b/packages/deepagent-code/test/session/snapshot-tool-race.test.ts
@@ -11,7 +11,7 @@
  * before tools run by hooking into start-step, but the AI SDK executes
  * tools internally during multi-step processing before emitting events.
  */
-import { expect } from "bun:test"
+import { afterEach, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { FetchHttpClient } from "effect/unstable/http"
 import fs from "fs/promises"
@@ -25,13 +25,15 @@ import { MessageV2 } from "../../src/session/message-v2"
 import { SessionV1 } from "@deepagent-code/core/v1/session"
 import { SessionV2 } from "@deepagent-code/core/session"
 import * as Log from "@deepagent-code/core/util/log"
-import { provideTmpdirServer, testInstanceStoreLayer } from "../fixture/fixture"
+import { disposeAllInstances, provideTmpdirServer, testInstanceStoreLayer } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 import { TestLLMServer } from "../lib/llm-server"
 
 // Same layer setup as prompt-effect.test.ts
 import { NodeFileSystem } from "@effect/platform-node"
 import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { DebugService } from "@/debug/service"
 import { RuntimeBase } from "@/runtime/base"
@@ -53,6 +55,7 @@ import { Skill } from "../../src/skill"
 import { SystemPrompt } from "../../src/session/system"
 import { Todo } from "../../src/session/todo"
 import { SessionCompaction } from "../../src/session/compaction"
+import { RequestExecutor } from "@deepagent-code/llm/route"
 import { Instruction } from "../../src/session/instruction"
 import { SessionProcessor } from "../../src/session/processor"
 import { SessionRunState } from "../../src/session/run-state"
@@ -74,6 +77,12 @@ import { PromptEpoch } from "@/session/prompt-epoch"
 import { LocationIdentity } from "@deepagent-code/core/context-federation/identity"
 import { SessionProviderOwner } from "@deepagent-code/core/context-federation/provider-owner"
 
+// Dispose any instances loaded into the process-wide AppRuntime instance
+// store so this file leaves no shared state for files that run after it.
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
 void Log.init({ print: false })
 
 const mcp = Layer.succeed(
@@ -173,6 +182,18 @@ const stubDebugServiceLayer = Layer.succeed(
   }),
 )
 
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Apply it over the tracked history
+// so compaction_run carries the mode columns the drizzle schema already declares.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
 function makeHttp() {
   const deps = Layer.mergeAll(
     Session.defaultLayer,
@@ -191,7 +212,7 @@ function makeHttp() {
     FSUtil.defaultLayer,
     BackgroundJob.defaultLayer,
     status,
-    Database.defaultLayer,
+    database,
     EventV2Bridge.defaultLayer,
     PromptEpoch.defaultLayer,
   ).pipe(Layer.provideMerge(infra))
@@ -227,6 +248,7 @@ function makeHttp() {
   )
   const compact = SessionCompaction.layer.pipe(
     Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true })),
+    Layer.provide(RequestExecutor.defaultLayer),
     Layer.provideMerge(proc),
     Layer.provideMerge(deps),
   )
diff --git a/packages/deepagent-code/test/session/steer.test.ts b/packages/deepagent-code/test/session/steer.test.ts
index 799b41fe..cd58ecfb 100644
--- a/packages/deepagent-code/test/session/steer.test.ts
+++ b/packages/deepagent-code/test/session/steer.test.ts
@@ -2,6 +2,8 @@ import { NodeFileSystem } from "@effect/platform-node"
 import { ConfigV1 } from "@deepagent-code/core/v1/config/config"
 import { SessionV1 } from "@deepagent-code/core/v1/session"
 import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import remoteCompactPersistenceMigration from "@deepagent-code/core/database/migration/20260820000000_remote_compact_persistence"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { FetchHttpClient } from "effect/unstable/http"
 import { expect } from "bun:test"
@@ -24,6 +26,7 @@ import { LLM } from "../../src/session/llm"
 import { MessageV2 } from "../../src/session/message-v2"
 import { FSUtil } from "@deepagent-code/core/fs-util"
 import { SessionCompaction } from "../../src/session/compaction"
+import { RequestExecutor } from "@deepagent-code/llm/route"
 import { SessionSummary } from "../../src/session/summary"
 import { Instruction } from "../../src/session/instruction"
 import { SessionProcessor } from "../../src/session/processor"
@@ -196,6 +199,18 @@ const infra = Layer.mergeAll(NodeFileSystem.layer, CrossSpawnSpawner.defaultLaye
 
 // steeringOn/steeringOff: the ONLY difference is the v4Steering flag, so tests can assert the
 // kill-switch cleanly. The steer buffer shares the same Database as Session (built over `deps`).
+// UPD-005: the Gap 1/Gap 2 persistence migration is not registered in
+// migration.gen.ts yet (mainline registers it). Apply it over the tracked history
+// so compaction_run carries the mode columns the drizzle schema already declares.
+const database = Layer.effect(
+  Database.Service,
+  Effect.gen(function* () {
+    const service = yield* Database.Service
+    yield* DatabaseMigration.applyOnly(service.db, [remoteCompactPersistenceMigration])
+    return service
+  }),
+).pipe(Layer.provide(Database.defaultLayer))
+
 function makePrompt(steering: boolean) {
   const flags = RuntimeFlags.layer({
     experimentalEventSystem: true,
@@ -219,7 +234,7 @@ function makePrompt(steering: boolean) {
     FSUtil.defaultLayer,
     BackgroundJob.defaultLayer,
     status,
-    Database.defaultLayer,
+    database,
     EventV2Bridge.defaultLayer,
     PromptEpoch.defaultLayer,
   ).pipe(Layer.provideMerge(infra))
@@ -250,7 +265,12 @@ function makePrompt(steering: boolean) {
     Layer.provide(flags),
     Layer.provideMerge(deps),
   )
-  const compact = SessionCompaction.layer.pipe(Layer.provide(flags), Layer.provideMerge(proc), Layer.provideMerge(deps))
+  const compact = SessionCompaction.layer.pipe(
+    Layer.provide(flags),
+    Layer.provide(RequestExecutor.defaultLayer),
+    Layer.provideMerge(proc),
+    Layer.provideMerge(deps),
+  )
   return SessionPrompt.layer.pipe(
     Layer.provide(SessionProviderOwner.layer.pipe(Layer.provide(deps))),
     Layer.provide(testInstanceStoreLayer),
diff --git a/packages/deepagent-code/test/session/task-fork.test.ts b/packages/deepagent-code/test/session/task-fork.test.ts
index 7ab44b39..79bd0183 100644
--- a/packages/deepagent-code/test/session/task-fork.test.ts
+++ b/packages/deepagent-code/test/session/task-fork.test.ts
@@ -3,6 +3,7 @@ import { Database } from "@deepagent-code/core/database/database"
 import { ProviderV2 } from "@deepagent-code/core/provider"
 import { ModelV2 } from "@deepagent-code/core/model"
 import { SessionForkIntentTable } from "@deepagent-code/core/session/sql"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { Effect, Layer } from "effect"
 import { eq } from "drizzle-orm"
 import { MessageV2 } from "@/session/message-v2"
@@ -12,7 +13,11 @@ import { MessageID, PartID, SessionID } from "@/session/schema"
 import { TestInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 
-const it = testEffect(Layer.mergeAll(Session.defaultLayer, Database.defaultLayer))
+// QUAL-007: the core SessionProjector is the canonical V1-event projection path (session/message/part
+// rows); without it the minimal layer never materializes sessions created through events.
+const it = testEffect(
+  Layer.mergeAll(Session.defaultLayer.pipe(Layer.provide(SessionProjector.defaultLayer)), Database.defaultLayer),
+)
 const model = { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("test") }
 
 const addUser = Effect.fn("TaskForkTest.addUser")(function* (
diff --git a/packages/deepagent-code/test/session/turn-stage-evidence.test.ts b/packages/deepagent-code/test/session/turn-stage-evidence.test.ts
new file mode 100644
index 00000000..0487c245
--- /dev/null
+++ b/packages/deepagent-code/test/session/turn-stage-evidence.test.ts
@@ -0,0 +1,452 @@
+import { describe, expect } from "bun:test"
+import { ProjectScopeKey, SecurityNamespaceID } from "@deepagent-code/core/context-federation/reference"
+import { ContextFederationRollout } from "@deepagent-code/core/context-federation/rollout"
+import { SessionProviderOwnerLeaseTable } from "@deepagent-code/core/context-federation/session-sql"
+import { ProjectScopeIdentityTable, SecurityNamespaceTable } from "@deepagent-code/core/context-federation/sql"
+import { Database } from "@deepagent-code/core/database/database"
+import { DatabaseMigration } from "@deepagent-code/core/database/migration"
+import turnStageEvidenceMigration from "@deepagent-code/core/database/migration/20260820120000_session_turn_stage_evidence"
+import { DeepAgentReleasedSnapshot } from "@deepagent-code/core/deepagent/released-snapshot"
+import { ModelV2 } from "@deepagent-code/core/model"
+import { ProjectV2 } from "@deepagent-code/core/project"
+import { ProjectTable } from "@deepagent-code/core/project/sql"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { AbsolutePath } from "@deepagent-code/core/schema"
+import { MessageTable, SessionTable } from "@deepagent-code/core/session/sql"
+import { SessionV1 } from "@deepagent-code/core/v1/session"
+import { sql } from "drizzle-orm"
+import { Effect } from "effect"
+import { RuntimeFlags } from "../../src/effect/runtime-flags"
+import { ContextActivationReceipt } from "../../src/context-federation/activation-receipt"
+import {
+  SessionLegacyActivityRunTable,
+  SessionLegacyActivityTable,
+  SessionLegacyActivityTerminalTable,
+} from "../../src/session/activity-sql"
+import { MessageID, PartID, SessionID } from "../../src/session/schema"
+import { SessionPromptIntent } from "../../src/session/prompt-intent"
+import { SessionToolRequestReceiptTable } from "../../src/session/tool-request-receipt.sql"
+import { TurnDeadlineWatchdog } from "../../src/session/turn-deadline-watchdog"
+import { TurnStageEvidence } from "../../src/session/turn-stage-evidence"
+import { testEffect } from "../lib/effect"
+
+const database = Database.layerFromPath(":memory:")
+const it = testEffect(database)
+const sessionID = SessionID.make("ses_turn_stage_evidence_test")
+const namespace = SecurityNamespaceID.make("sec_turn_stage_evidence_test")
+const projectScope = ProjectScopeKey.make("prjctx_turn_stage_evidence_test")
+const providerOwnerToken = "turn-stage-evidence-fixture"
+const releasedKnowledgeBinding = DeepAgentReleasedSnapshot.binding(undefined)
+
+const setup = Effect.gen(function* () {
+  const { db } = yield* Database.Service
+  // The stage-evidence migration ships unregistered (mainline registers it); apply it here.
+  yield* DatabaseMigration.applyOnly(db, [turnStageEvidenceMigration])
+  yield* db
+    .insert(SessionProviderOwnerLeaseTable)
+    .values({
+      owner_token: providerOwnerToken,
+      registered_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`,
+      heartbeat_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`,
+      lease_expires_at: sql`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER) + 31536000000`,
+    })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(SecurityNamespaceTable)
+    .values({ id: namespace, kind: "implicit_local", binding_hash: "stage-evidence-namespace", created_at: 1 })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(ProjectScopeIdentityTable)
+    .values({
+      security_namespace_id: namespace,
+      project_scope_key: projectScope,
+      project_kind: "registered_root",
+      project_identity_hash: "stage-evidence-project",
+      observed_project_id: ProjectV2.ID.global,
+      created_at: 1,
+    })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(ProjectTable)
+    .values({ id: ProjectV2.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(SessionTable)
+    .values({
+      id: sessionID,
+      project_id: ProjectV2.ID.global,
+      slug: "stage-evidence",
+      directory: "/project",
+      title: "stage-evidence",
+      version: "test",
+    })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+})
+
+const claim = (input: { intentID: string; messageID: MessageID }) =>
+  SessionPromptIntent.claim({
+    intentID: input.intentID,
+    sessionID,
+    source: "composer",
+    variant: "original",
+    payloadHash: `payload-${input.intentID}`,
+    messageID: input.messageID,
+  })
+
+const message = (messageID: MessageID): { info: SessionV1.User; parts: SessionV1.Part[] } => ({
+  info: {
+    id: messageID,
+    sessionID,
+    role: "user",
+    time: { created: 1 },
+    agent: "build",
+    model: { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("test") },
+  },
+  parts: [
+    {
+      id: PartID.make(`prt_${messageID}`),
+      messageID,
+      sessionID,
+      type: "text",
+      text: "atomic prompt",
+    },
+  ],
+})
+
+// Drives the durable state machine (claim -> materializeTurn) to a live activity + run,
+// exactly like the provider-turn path does before its first stage-evidence write.
+const liveActivity = (intentID: string) =>
+  Effect.gen(function* () {
+    const trigger = yield* claim({ intentID, messageID: MessageID.make(`msg_${intentID}`) })
+    expect(trigger.kind).toBe("claimed")
+    if (trigger.kind !== "claimed") return yield* Effect.die("claim not claimed")
+    const materialized = yield* SessionPromptIntent.materializeTurn({
+      receipt: trigger.receipt,
+      message: message(trigger.receipt.messageID),
+    })
+    if (!("run" in materialized)) return yield* Effect.die("materializeTurn produced no run")
+    return { run: materialized.run, receipt: trigger.receipt }
+  })
+
+describe("TurnStageEvidence", () => {
+  it.effect("records the provider-turn stage sequence forward-only on a state-machine driven activity", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      const { run } = yield* liveActivity("intent_stage_sequence")
+      const activityID = run.activityID
+
+      // The same single-statement upserts prompt.ts performs at each boundary.
+      yield* TurnStageEvidence.record(db, {
+        sessionID,
+        activityID,
+        stage: "activity_claimed",
+        details: { via: "steer_claim" },
+        now: 100,
+      })
+      yield* TurnStageEvidence.record(db, { sessionID, activityID, stage: "snapshot_started", now: 101 })
+      yield* TurnStageEvidence.record(db, { sessionID, activityID, stage: "snapshot_finished", now: 102 })
+      yield* TurnStageEvidence.record(db, {
+        sessionID,
+        activityID,
+        stage: "history_loaded",
+        details: { messages: 3 },
+        now: 103,
+      })
+      // request_prepared reuses the enclosing receipt transaction in prompt.ts.
+      yield* db
+        .transaction((tx) =>
+          TurnStageEvidence.recordInTransaction(tx, {
+            sessionID,
+            activityID,
+            stage: "request_prepared",
+            details: { receiptID: "receipt-stage-sequence", requestOrdinal: 1 },
+            now: 104,
+          }),
+        )
+        .pipe(Effect.orDie)
+      yield* TurnStageEvidence.record(db, { sessionID, activityID, stage: "provider_dispatch_started", now: 105 })
+      yield* TurnStageEvidence.record(db, {
+        sessionID,
+        activityID,
+        stage: "terminal_settled",
+        details: { state: "completed" },
+        now: 106,
+      })
+
+      // One row per (session_id, activity_id), holding the furthest stage.
+      const rows = yield* TurnStageEvidence.recent(db, { sessionID })
+      expect(rows.filter((row) => row.activity_id === activityID)).toHaveLength(1)
+      const latest = yield* TurnStageEvidence.latest(db, { sessionID, activityID })
+      expect(latest).toMatchObject({
+        session_id: sessionID,
+        activity_id: activityID,
+        stage: "terminal_settled",
+        stage_at: 106,
+        details: { state: "completed" },
+      })
+
+      // Forward-only: an earlier stage from a retried turn cannot regress the row.
+      yield* TurnStageEvidence.record(db, { sessionID, activityID, stage: "snapshot_started", now: 107 })
+      const still = yield* TurnStageEvidence.latest(db, { sessionID, activityID })
+      expect(still).toMatchObject({ stage: "terminal_settled", stage_at: 106, updated_at: latest!.updated_at })
+
+      // Same-stage re-settlement updates attribution details (equal order passes the guard).
+      yield* TurnStageEvidence.record(db, {
+        sessionID,
+        activityID,
+        stage: "terminal_settled",
+        details: { state: "failed", reasonCode: "provider_error" },
+        now: 108,
+      })
+      const rewritten = yield* TurnStageEvidence.latest(db, { sessionID, activityID })
+      expect(rewritten).toMatchObject({
+        stage: "terminal_settled",
+        stage_at: 108,
+        details: { state: "failed", reasonCode: "provider_error" },
+      })
+    }),
+  )
+
+  it.effect("a failed evidence write never interrupts the turn (FK violation is swallowed)", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      // No such session row -> FK violation; record() must log and succeed.
+      yield* TurnStageEvidence.record(db, {
+        sessionID: "ses_missing_fk_target",
+        activityID: "act_missing_fk",
+        stage: "activity_claimed",
+      })
+      const rows = yield* TurnStageEvidence.recent(db, { sessionID: "ses_missing_fk_target" })
+      expect(rows).toEqual([])
+    }),
+  )
+})
+
+describe("TurnDeadlineWatchdog", () => {
+  it.effect("the watchdog flag ships OFF with a ten-minute default deadline", () =>
+    Effect.gen(function* () {
+      const flags = yield* RuntimeFlags.Service
+      expect(flags.providerPreDispatchWatchdog).toBe(false)
+      expect(flags.providerPreDispatchDeadlineMs).toBe(10 * 60_000)
+    }).pipe(Effect.provide(RuntimeFlags.layer({}))),
+  )
+
+  it.effect("flag ON: fails a stale activity without dispatch evidence through the existing terminal path", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const databaseService = yield* Database.Service
+      const { run } = yield* liveActivity("intent_watchdog_stale")
+
+      const outcomes = yield* TurnDeadlineWatchdog.sweep({ database: databaseService, deadlineMs: 0 })
+      expect(outcomes.find((outcome) => outcome.activityID === run.activityID)).toMatchObject({
+        kind: "failed",
+        runID: run.runID,
+      })
+
+      // Existing terminalization path: typed terminal reason on the activity + terminal rows.
+      const { db } = databaseService
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTable)
+          .where(sql`${SessionLegacyActivityTable.activity_id} = ${run.activityID}`)
+          .get()
+          .pipe(Effect.orDie),
+      ).toMatchObject({ state: "failed" })
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTerminalTable)
+          .where(sql`${SessionLegacyActivityTerminalTable.activity_id} = ${run.activityID}`)
+          .get()
+          .pipe(Effect.orDie),
+      ).toMatchObject({
+        state: "failed",
+        reason_code: TurnDeadlineWatchdog.ReasonCode,
+        source: "same_process_recovery",
+        run_id: run.runID,
+      })
+      // Run row is terminalized alongside the activity (exact retry stays possible).
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityRunTable)
+          .where(sql`${SessionLegacyActivityRunTable.run_id} = ${run.runID}`)
+          .get()
+          .pipe(Effect.orDie),
+      ).toMatchObject({ state: "failed", terminal_reason: TurnDeadlineWatchdog.ReasonCode })
+
+      // Record-only evidence shows the watchdog settled the turn.
+      expect(
+        yield* TurnStageEvidence.latest(db, { sessionID, activityID: run.activityID }),
+      ).toMatchObject({
+        stage: "terminal_settled",
+        details: { reasonCode: TurnDeadlineWatchdog.ReasonCode, via: "pre_dispatch_deadline_watchdog" },
+      })
+
+      // Second sweep is a no-op for this activity (no longer active).
+      const rerun = yield* TurnDeadlineWatchdog.sweep({ database: databaseService, deadlineMs: 0 })
+      expect(rerun.some((outcome) => outcome.activityID === run.activityID)).toBe(false)
+    }),
+  )
+
+  it.effect("flag ON: skips an activity whose stage evidence already shows dispatch progress", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const databaseService = yield* Database.Service
+      const { db } = databaseService
+      const { run } = yield* liveActivity("intent_watchdog_dispatched")
+      // Durable dispatch-side evidence (as prompt.ts writes when the receipt is prepared).
+      yield* TurnStageEvidence.record(db, {
+        sessionID,
+        activityID: run.activityID,
+        stage: "request_prepared",
+        details: { receiptID: "receipt-watchdog-dispatched" },
+      })
+
+      const outcomes = yield* TurnDeadlineWatchdog.sweep({ database: databaseService, deadlineMs: 0 })
+      expect(outcomes.find((outcome) => outcome.activityID === run.activityID)).toMatchObject({
+        kind: "skipped",
+        reason: "stage_evidence_present",
+      })
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTable)
+          .where(sql`${SessionLegacyActivityTable.activity_id} = ${run.activityID}`)
+          .get()
+          .pipe(Effect.orDie),
+      ).toMatchObject({ state: "active" })
+    }),
+  )
+
+  it.effect("flag ON: never touches an activity that already has a durable receipt", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const databaseService = yield* Database.Service
+      const { db } = databaseService
+      const { run, receipt } = yield* liveActivity("intent_watchdog_receipt")
+
+      const assistantID = MessageID.make("msg_watchdog_receipt_assistant")
+      yield* db
+        .insert(MessageTable)
+        .values({
+          id: assistantID,
+          session_id: sessionID,
+          time_created: 2,
+          data: {
+            role: "assistant",
+            parentID: receipt.messageID,
+            mode: "build",
+            agent: "build",
+            path: { cwd: "/project", root: "/project" },
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            modelID: ModelV2.ID.make("test"),
+            providerID: ProviderV2.ID.make("test"),
+            time: { created: 2 },
+          } as typeof MessageTable.$inferInsert.data,
+        })
+        .run()
+        .pipe(Effect.orDie)
+      yield* db
+        .insert(SessionToolRequestReceiptTable) // fixture-exempt: seeds durable receipt evidence; no dispatch exists to produce it naturally
+        .values({
+          receipt_id: "receipt-watchdog-present",
+          request_ordinal: 1,
+          session_id: sessionID,
+          user_message_id: receipt.messageID,
+          assistant_message_id: assistantID,
+          context_eligibility: contextEligibility,
+          context_readiness: contextReadiness,
+          context_activation: contextActivation,
+          context_activation_fingerprint: contextActivationFingerprint,
+          released_knowledge_security_namespace_id: namespace,
+          released_knowledge_project_scope_key: projectScope,
+          released_knowledge_binding_state: releasedKnowledgeBinding.state,
+          released_knowledge_exact_refs: releasedKnowledgeBinding.exactRefs,
+          released_knowledge_exact_refs_fingerprint: releasedKnowledgeBinding.exactRefsFingerprint,
+          provider_id: "test",
+          model_id: "test",
+          protocol: "test",
+          registry_tool_ids: [],
+          permission_filtered_tool_ids: [],
+          final_offered_tool_ids: [],
+          call_ids: [],
+          adapter_tool_capability: "unknown",
+          prompt_epoch: 0,
+          prompt_window_id: "window-watchdog-present",
+          effective_history_hash: "history-watchdog-present",
+          request_input_hash: "input-watchdog-present",
+          response_chain_reuse_decision: "not_supported",
+          response_chain_refusal_reason: "fixture_path_not_stateful",
+          provider_state: "preparing",
+          owner_token: providerOwnerToken,
+          request_state: "prepared",
+          created_at: Date.now(),
+        })
+        .run()
+        .pipe(Effect.orDie)
+
+      const outcomes = yield* TurnDeadlineWatchdog.sweep({ database: databaseService, deadlineMs: 0 })
+      expect(outcomes.find((outcome) => outcome.activityID === run.activityID)).toMatchObject({
+        kind: "skipped",
+        reason: "receipt_present",
+      })
+      expect(
+        yield* db
+          .select()
+          .from(SessionLegacyActivityTable)
+          .where(sql`${SessionLegacyActivityTable.activity_id} = ${run.activityID}`)
+          .get()
+          .pipe(Effect.orDie),
+      ).toMatchObject({ state: "active" })
+    }),
+  )
+})
+
+const contextEligibility = ContextFederationRollout.resolveProject(
+  ContextFederationRollout.resolve(
+    {
+      contextFederationShadow: false,
+      locationIndexesV2Shadow: false,
+      contextProjectionV2: false,
+      contextQueryToolsV2: false,
+      coreV2ExecutionOwner: false,
+    },
+    { coreV2ParityVerified: false },
+  ),
+  projectScope,
+  { stage: "all", percentage: 100, internalProjectScopeKeys: [], killSwitch: false },
+)
+const contextReadiness = {
+  ...ContextFederationRollout.READINESS_READY_STUB,
+  revision: "readiness-stage-evidence",
+  projectScopeKey: projectScope,
+  observedAt: 1,
+}
+const contextDecision = ContextFederationRollout.activate(contextEligibility, contextReadiness)
+const contextActivation = ContextActivationReceipt.make({
+  readiness: contextReadiness,
+  decision: contextDecision,
+  recordedAt: 2,
+  projectionEnabled: false,
+  toolsEnabled: false,
+})
+const contextActivationFingerprint = ContextActivationReceipt.fingerprint({
+  eligibility: contextEligibility,
+  readiness: contextReadiness,
+  activation: contextActivation,
+})
diff --git a/packages/deepagent-code/test/session/v4-integration.test.ts b/packages/deepagent-code/test/session/v4-integration.test.ts
index bd1c6f3a..3a8989d2 100644
--- a/packages/deepagent-code/test/session/v4-integration.test.ts
+++ b/packages/deepagent-code/test/session/v4-integration.test.ts
@@ -17,6 +17,7 @@ import { AgentListProviderService } from "@deepagent-code/core/im/agent-list-pro
 import type { AgentDescriptor } from "@deepagent-code/core/im/mention-parser"
 import { RuntimeFlags } from "../../src/effect/runtime-flags"
 import { AgentHandoffConsumer } from "../../src/session/agent-handoff-consumer"
+import { HandoffAdmission } from "@deepagent-code/core/deepagent/handoff-admission"
 import { pollWithTimeout, testEffect } from "../lib/effect"
 
 // V4.0 §I — END-TO-END integration. Wires the real chain across all waves over one in-memory DB:
@@ -80,6 +81,7 @@ const makeLayer = (flags?: Partial<RuntimeFlags.Info>) => {
     Observability.layerWith({ now }),
     ApprovalQueue.layerWith({ now }),
     AgentExecution.layerWith({ now }),
+    HandoffAdmission.layerWith({ now }),
   ).pipe(Layer.provideMerge(database))
   // MultiAgentRuntime is the REAL DispatchPort the dispatcher hands routed events to.
   const runtime = Layer.unwrap(
@@ -242,6 +244,7 @@ describe("V4.1 durable handoff end-to-end", () => {
     Observability.layerWith({ now }),
     ApprovalQueue.layerWith({ now }),
     AgentExecution.layerWith({ now }),
+    HandoffAdmission.layerWith({ now }),
   ).pipe(Layer.provideMerge(database))
   let failed = false
   const handoffRuns: Array<{ readonly agent: string; readonly baseRef?: string }> = []
diff --git a/packages/deepagent-code/test/share/share-next.test.ts b/packages/deepagent-code/test/share/share-next.test.ts
index 84f7b89f..8a0a06f0 100644
--- a/packages/deepagent-code/test/share/share-next.test.ts
+++ b/packages/deepagent-code/test/share/share-next.test.ts
@@ -11,6 +11,7 @@ import { EventV2Bridge } from "../../src/event-v2-bridge"
 import { Config } from "@/config/config"
 import { Provider } from "@/provider/provider"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import type { SessionID } from "../../src/session/schema"
 import { ShareNext } from "@/share/share-next"
 import { SessionShareTable } from "@deepagent-code/core/share/sql"
@@ -22,6 +23,9 @@ import { pollWithTimeout, testEffect } from "../lib/effect"
 
 const env = Layer.mergeAll(
   Session.defaultLayer,
+  // QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+  // writes hit the session FK.
+  SessionProjector.defaultLayer,
   AccountRepo.defaultLayer,
   Database.defaultLayer,
   NodeFileSystem.layer,
diff --git a/packages/deepagent-code/test/snapshot/snapshot-degraded-attribution.test.ts b/packages/deepagent-code/test/snapshot/snapshot-degraded-attribution.test.ts
new file mode 100644
index 00000000..2c8869f4
--- /dev/null
+++ b/packages/deepagent-code/test/snapshot/snapshot-degraded-attribution.test.ts
@@ -0,0 +1,63 @@
+import { afterEach, describe, expect } from "bun:test"
+import { FSUtil } from "@deepagent-code/core/fs-util"
+import { Effect, Layer } from "effect"
+import { DiffLimits, Snapshot } from "../../src/snapshot"
+import { disposeAllInstances, testInstanceStoreLayer, TestInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(Snapshot.defaultLayer, FSUtil.defaultLayer, testInstanceStoreLayer))
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+const write = (file: string, content: string | Uint8Array) =>
+  FSUtil.Service.use((fs) => fs.writeWithDirs(file, content))
+
+describe("Snapshot degraded attribution (BUG-407-012 gap C)", () => {
+  it.instance(
+    "trackOutcome attributes a total-size budget overrun with session identity and budget numbers",
+    Effect.gen(function* () {
+      const tmp = yield* TestInstance
+      const snapshot = yield* Snapshot.Service
+      // Oversized single files (> 2MB capture exclusion) are DROPPED from capture instead
+      // of degrading it, so a degraded outcome requires in-budget files whose TOTAL
+      // crosses captureTotalBytes: 33 files of exactly 2MB = 66MB > 64MB.
+      yield* write(`${tmp.directory}/small.txt`, "within budget")
+      const chunk = "x".repeat(2 * 1024 * 1024)
+      const fileCount = Math.floor(DiffLimits.captureTotalBytes / (2 * 1024 * 1024)) + 1
+      for (const index of Array.from({ length: fileCount }, (_, value) => value)) {
+        yield* write(`${tmp.directory}/bulk-${index}.bin`, chunk)
+      }
+
+      const outcome = yield* snapshot.trackOutcome({ sessionId: "ses_attribution", activityId: "act_attribution" })
+      expect(outcome.hash).toBeUndefined()
+      expect(outcome.degraded).toMatchObject({
+        reason: "snapshot_source_budget_exceeded",
+        sessionId: "ses_attribution",
+        activityId: "act_attribution",
+        totalLimit: DiffLimits.captureTotalBytes,
+        fileLimit: DiffLimits.captureFileBytes,
+      })
+      expect(typeof outcome.degraded?.totalBytes).toBe("number")
+
+      // track() degrades to undefined (callers keep their legacy behavior).
+      expect(yield* snapshot.track({ sessionId: "ses_attribution" })).toBeUndefined()
+    }),
+    { git: true },
+  )
+
+  it.instance(
+    "trackOutcome still returns a hash and no degradation within budget",
+    Effect.gen(function* () {
+      const tmp = yield* TestInstance
+      const snapshot = yield* Snapshot.Service
+      yield* write(`${tmp.directory}/small.txt`, "within budget")
+
+      const outcome = yield* snapshot.trackOutcome({ sessionId: "ses_ok", activityId: "act_ok" })
+      expect(outcome.degraded).toBeUndefined()
+      expect(outcome.hash).toBeTruthy()
+    }),
+    { git: true },
+  )
+})
diff --git a/packages/deepagent-code/test/snapshot/snapshot.test.ts b/packages/deepagent-code/test/snapshot/snapshot.test.ts
index 9e2f9e05..36eac3ba 100644
--- a/packages/deepagent-code/test/snapshot/snapshot.test.ts
+++ b/packages/deepagent-code/test/snapshot/snapshot.test.ts
@@ -1097,6 +1097,42 @@ it.instance(
   { git: true },
 )
 
+// BUG-407-010 §14.2 release acceptance: a 4,500-file discovery must trip the candidate budget
+// deterministically at incident scale, keeping the returned file list and manifest below the
+// approved caps instead of materializing the full discovery output.
+it.instance(
+  "diffFull and diffManifest trip the discovery budget at 4500-file incident scale",
+  withTrackedSnapshot(({ tmp, snapshot, before }) =>
+    Effect.gen(function* () {
+      const incidentFiles = 4_500
+      yield* Effect.forEach(
+        Array.from({ length: incidentFiles }, (_, index) => index),
+        (index) => write(`${tmp.path}/incident/file-${String(index).padStart(4, "0")}.txt`, "content"),
+        { concurrency: 100, discard: true },
+      )
+      const after = yield* snapshot.track()
+      expect(after).toBeTruthy()
+
+      const diffs = yield* snapshot.diffFull(before, after!)
+      expect(diffs.length).toBe(Snapshot.DiffLimits.candidateFiles)
+      expect(diffs[0].file).toBe("incident/file-0000.txt")
+      expect(diffs.at(-1)?.file).toBe("incident/file-0999.txt")
+
+      const manifest = yield* snapshot.diffManifest(before, after!)
+      expect(manifest.completeness).toBe("truncated")
+      expect(manifest.truncationReasons).toContain("candidate_file_limit")
+      expect(manifest.files).toHaveLength(Snapshot.DiffLimits.candidateFiles)
+      expect(manifest.files.every((item) => item.patch === undefined)).toBe(true)
+      expect(manifest.totalFiles).toBe(incidentFiles)
+      expect(manifest.totalFilesExact).toBe(true)
+      expect(manifest.statisticsExact).toBe(false)
+      expect(Buffer.byteLength(JSON.stringify(manifest.files))).toBeLessThanOrEqual(Snapshot.DiffLimits.manifestBytes)
+    }),
+  ),
+  { git: true },
+  30_000,
+)
+
 it.instance(
   "diffManifest preserves visible statuses after a large ignored prefix",
   withTrackedSnapshot(({ tmp, snapshot, before }) =>
diff --git a/packages/deepagent-code/test/tool/degraded-text-recovery.test.ts b/packages/deepagent-code/test/tool/degraded-text-recovery.test.ts
new file mode 100644
index 00000000..8bf90c0c
--- /dev/null
+++ b/packages/deepagent-code/test/tool/degraded-text-recovery.test.ts
@@ -0,0 +1,312 @@
+/**
+ * QUAL-005 (BUG-405-011 residue): degraded_text crash recovery + idempotent foreground metadata
+ * repair, driven through the real task-run state machine (admit → claim → start → research →
+ * finalize → seal evidence). No terminal task_run rows are inserted directly.
+ *
+ * Covers:
+ *   1. recoverExpiredTaskRuns recovers a finalizing run whose executor crashed AFTER sealing its
+ *      degraded_text receipt (persistDegradedStructuredOutput): the durable result must survive
+ *      as completed/structured_output_degraded_text instead of being destroyed as
+ *      execution_lease_expired. Recovered completions are excluded from the returned runs so the
+ *      notification pump never projects them as expired errors.
+ *   2. The idempotent foreground metadata repair (repairDurableSettledRunProjections) projects the
+ *      recovered completion into the child session metadata exactly once.
+ *   3. Unsealed finalizing runs still settle as failed/execution_lease_expired (prior behavior).
+ *   4. Background delivery mode: recovery completes the run and enqueues the terminal
+ *      notification outbox entry.
+ */
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { eq, sql } from "drizzle-orm"
+import { Database } from "@deepagent-code/core/database/database"
+import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
+import { ProjectV2 } from "@deepagent-code/core/project"
+import { ProjectTable } from "@deepagent-code/core/project/sql"
+import { AbsolutePath } from "@deepagent-code/core/schema"
+import {
+  SessionTable,
+  TaskNotificationOutboxTable,
+  TaskRunEventTable,
+  TaskRunTable,
+} from "@deepagent-code/core/session/sql"
+import { Session } from "../../src/session/session"
+import { MessageID, SessionID } from "../../src/session/schema"
+import {
+  admitTaskRun,
+  claimTaskProvisioning,
+  markTaskFinalizing,
+  markTaskResearchCompleted,
+  recoverExpiredTaskRuns,
+  startTaskRun,
+} from "../../src/tool/task-run"
+import {
+  makeDegradedStructuredOutput,
+  persistDegradedStructuredOutput,
+} from "../../src/tool/task-structured-output-evidence"
+import { repairDurableSettledRunProjections } from "../../src/tool/task"
+import { testEffect } from "../lib/effect"
+
+const database = Layer.mergeAll(Database.layerFromPath(":memory:"), CrossSpawnSpawner.defaultLayer)
+const it = testEffect(database)
+const directory = "/project"
+const parentSessionID = SessionID.make("ses_degraded_recovery_parent")
+
+const contract = {
+  schema: {
+    type: "object",
+    properties: { result: { type: "string" } },
+    required: ["result"],
+    additionalProperties: false,
+  },
+  allowTextFallback: true,
+  receiptVersion: 1 as const,
+  maxAttempts: 2 as const,
+}
+
+const receipt = { attempt: 2, transport: "degraded_text", reason: "structured_output_missing" } as const
+const researchText = "persisted degraded research"
+const degradedOutput = makeDegradedStructuredOutput(researchText, receipt)
+
+const setup = Effect.gen(function* () {
+  const { db } = yield* Database.Service
+  yield* db
+    .insert(ProjectTable)
+    .values({ id: ProjectV2.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(SessionTable)
+    .values({
+      id: parentSessionID,
+      project_id: ProjectV2.ID.global,
+      slug: "degraded-recovery-parent",
+      directory,
+      title: "parent",
+      version: "test",
+    })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+})
+
+/**
+ * Drives the real state machine to the exact crash window: the executor finished research,
+ * entered finalize, and persisted the raw result message. The caller decides whether the degraded
+ * receipt gets sealed before the simulated crash.
+ */
+const driveToFinalizing = (suffix: string, deliveryMode: "foreground" | "background" = "foreground") =>
+  Effect.gen(function* () {
+    yield* setup
+    const time = Date.now()
+    const admission = yield* admitTaskRun({
+      parentSessionID,
+      parentMessageID: MessageID.ascending(`msg_degraded_${suffix}`),
+      toolCallID: `call_degraded_${suffix}`,
+      request: { prompt: "research", subagent_type: "researcher" },
+      deliveryMode,
+      executionSpec: {
+        prompt: { text: "research" },
+        agent: "researcher",
+        model: { providerID: "test", modelID: "test" },
+        structuredOutput: contract,
+      },
+    })
+    const claimed = (yield* claimTaskProvisioning({
+      run: admission.run,
+      owner: "worker",
+      now: time,
+      leaseMs: 60_000,
+    }))!
+    const running = (yield* startTaskRun(claimed, "worker", time + 1, 60_000))!
+    const { db } = yield* Database.Service
+    const rawMessageID = MessageID.ascending(`msg_degraded_raw_${suffix}`)
+    yield* db.run(sql`
+      INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_updated)
+      VALUES (
+        ${running.childSessionID}, ${ProjectV2.ID.global},
+        ${`degraded-${suffix}`}, ${directory}, 'child', 'test', ${time}, ${time}
+      )
+    `)
+    yield* db.run(sql`
+      INSERT INTO message (id, session_id, time_created, time_updated, data)
+      VALUES (${rawMessageID}, ${running.childSessionID}, ${time + 2}, ${time + 2}, '{"role":"assistant"}')
+    `)
+    yield* db.run(sql`
+      INSERT INTO part (id, message_id, session_id, time_created, time_updated, data)
+      VALUES (
+        ${`prt_degraded_${suffix}`}, ${rawMessageID}, ${running.childSessionID},
+        ${time + 2}, ${time + 2}, ${JSON.stringify({ type: "text", text: researchText })}
+      )
+    `)
+    yield* markTaskResearchCompleted(running, "worker", rawMessageID, time + 2)
+    yield* markTaskFinalizing(running, "worker", receipt.attempt, rawMessageID, time + 3)
+    return { time, run: running, rawMessageID }
+  })
+
+describe("tool.degraded-text-recovery", () => {
+  it.effect("recovers a sealed degraded_text completion and repairs foreground metadata idempotently", () =>
+    Effect.gen(function* () {
+      const { time, run, rawMessageID } = yield* driveToFinalizing("sealed")
+
+      // Seal the degraded receipt, then crash without settling (the lease simply expires).
+      yield* persistDegradedStructuredOutput({
+        runID: run.runID,
+        childSessionID: run.childSessionID,
+        ownerToken: "worker",
+        claimGeneration: run.claimGeneration,
+        sourceMessageID: rawMessageID,
+        contract,
+        receipt,
+        output: degradedOutput,
+        now: time + 4,
+      })
+      const recovered = yield* recoverExpiredTaskRuns({ directory, now: time + 120_000 })
+
+      // Recovered completions are NOT surfaced for expired-error projection.
+      expect(recovered).toEqual([])
+
+      const { db } = yield* Database.Service
+      const row = (yield* db
+        .select()
+        .from(TaskRunTable)
+        .where(eq(TaskRunTable.run_id, run.runID))
+        .get()
+        .pipe(Effect.orDie))!
+      expect(row.state).toBe("completed")
+      expect(row.phase).toBe("settled")
+      expect(row.control_state).toBe("closed")
+      expect(row.reason).toBe("structured_output_degraded_text")
+      expect(row.output).toBe(degradedOutput)
+      expect(row.structured_output_receipt).toEqual(receipt)
+      expect(row.structured_result_message_id).toBeNull()
+      expect(row.execution_owner).toBeNull()
+      expect(row.time_settled).toBe(time + 120_000)
+
+      expect(
+        yield* db
+          .select({ type: TaskRunEventTable.type, reason: TaskRunEventTable.reason })
+          .from(TaskRunEventTable)
+          .where(eq(TaskRunEventTable.run_id, run.runID))
+          .all()
+          .pipe(Effect.orDie),
+      ).toContainEqual({ type: "structured_response_recovered", reason: "persisted_degraded_receipt" })
+
+      // Idempotent: a second recovery pass finds nothing and changes nothing.
+      expect(yield* recoverExpiredTaskRuns({ directory, now: time + 240_000 })).toEqual([])
+      expect(
+        ((yield* db
+          .select({ version: TaskRunTable.version })
+          .from(TaskRunTable)
+          .where(eq(TaskRunTable.run_id, run.runID))
+          .get()
+          .pipe(Effect.orDie)) as { version: number }).version,
+      ).toBe(row.version)
+
+      // Foreground metadata repair: the child session still believes it is finalizing; the
+      // durable-cp startup repair must project the recovered completion exactly once.
+      const holder: { info: Session.Info } = {
+        info: {
+          id: run.childSessionID,
+          slug: "degraded-child",
+          projectID: ProjectV2.ID.global,
+          directory,
+          parentID: parentSessionID,
+          title: "child",
+          version: "test",
+          metadata: {
+            deepagent: {
+              subagent: {
+                finished: false,
+                state: "finalizing",
+                phase: "finalize",
+                attempts: receipt.attempt,
+                run_id: run.runID,
+                generation: run.generation,
+                raw_result_ref: rawMessageID,
+              },
+            },
+          },
+          time: { created: time, updated: time + 4 },
+        },
+      }
+      const sessions = {
+        get: () => Effect.succeed(holder.info),
+        setMetadata: (input: { readonly metadata: Session.Info["metadata"] }) =>
+          Effect.sync(() => {
+            holder.info = { ...holder.info, metadata: input.metadata }
+          }),
+      } as unknown as Session.Interface
+
+      expect(yield* repairDurableSettledRunProjections(sessions, { directory })).toBe(1)
+      expect(yield* repairDurableSettledRunProjections(sessions, { directory })).toBe(0)
+      expect(holder.info.metadata?.deepagent).toEqual({
+        subagent: {
+          finished: true,
+          state: "completed",
+          phase: "settled",
+          run_id: run.runID,
+          generation: run.generation,
+          settled_at: time + 120_000,
+          reason: "structured_output_degraded_text",
+          attempts: receipt.attempt,
+          raw_result_ref: rawMessageID,
+          structured_output: receipt,
+        },
+      })
+    }),
+  )
+
+  it.effect("still settles unsealed finalizing runs as execution_lease_expired", () =>
+    Effect.gen(function* () {
+      const { time, run } = yield* driveToFinalizing("unsealed")
+
+      // Crash without sealing any receipt — the pre-existing failure path must be preserved.
+      const recovered = yield* recoverExpiredTaskRuns({ directory, now: time + 120_000 })
+      expect(recovered).toHaveLength(1)
+      expect(recovered[0].runID).toBe(run.runID)
+      expect(recovered[0].state).toBe("failed")
+      expect(recovered[0].reason).toBe("execution_lease_expired")
+
+      const { db } = yield* Database.Service
+      expect(
+        yield* db.select().from(TaskNotificationOutboxTable).all().pipe(Effect.orDie),
+      ).toHaveLength(1)
+    }),
+  )
+
+  it.effect("recovers a sealed background completion with its terminal notification", () =>
+    Effect.gen(function* () {
+      const { time, run, rawMessageID } = yield* driveToFinalizing("background", "background")
+      yield* persistDegradedStructuredOutput({
+        runID: run.runID,
+        childSessionID: run.childSessionID,
+        ownerToken: "worker",
+        claimGeneration: run.claimGeneration,
+        sourceMessageID: rawMessageID,
+        contract,
+        receipt,
+        output: degradedOutput,
+        now: time + 4,
+      })
+
+      expect(yield* recoverExpiredTaskRuns({ directory, now: time + 120_000 })).toEqual([])
+
+      const { db } = yield* Database.Service
+      const row = (yield* db
+        .select()
+        .from(TaskRunTable)
+        .where(eq(TaskRunTable.run_id, run.runID))
+        .get()
+        .pipe(Effect.orDie))!
+      expect(row.state).toBe("completed")
+      expect(row.reason).toBe("structured_output_degraded_text")
+      expect(row.structured_output_receipt).toEqual(receipt)
+
+      const notifications = yield* db.select().from(TaskNotificationOutboxTable).all().pipe(Effect.orDie)
+      expect(notifications).toHaveLength(1)
+      expect(notifications[0].payload.text).toContain("Background task completed")
+      expect(notifications[0].payload.text).toContain(run.childSessionID)
+    }),
+  )
+})
diff --git a/packages/deepagent-code/test/tool/output-degeneration.test.ts b/packages/deepagent-code/test/tool/output-degeneration.test.ts
new file mode 100644
index 00000000..bc5af5e4
--- /dev/null
+++ b/packages/deepagent-code/test/tool/output-degeneration.test.ts
@@ -0,0 +1,177 @@
+/**
+ * QUAL-005 (BUG-407-008 residue): deterministic coverage for OutputDegenerationError.
+ *
+ * The processor (session/processor.ts) throws SessionV1.OutputDegenerationError in enforce mode
+ * when the reasoning N-gram degeneration detector confirms a stuck/repetitive stream, and the
+ * retry policy (session/retry.ts) special-cases it as non-retryable. Before this file, the error
+ * had zero dedicated tests. These tests pin:
+ *   1. the error contract (type + detector verdict fields),
+ *   2. the retry special-case (never retryable),
+ *   3. bounded termination — the retry harness stops after the single failed attempt instead of
+ *      retrying forever (contrast case proves the harness would retry a transient 5xx error).
+ */
+import { describe, expect } from "bun:test"
+import { Effect, Exit, Schedule, Schema } from "effect"
+import { SessionV1 } from "@deepagent-code/core/v1/session"
+import type { NamedError } from "@deepagent-code/core/util/error"
+import { SessionRetry } from "../../src/session/retry"
+import { MessageV2 } from "../../src/session/message-v2"
+import { ProviderV2 } from "@deepagent-code/core/provider"
+import { it } from "../lib/effect"
+
+const provider = "test"
+
+// Deterministic degenerate-output path: the processor's detector enables above 20_000 chars and
+// confirms degeneration when the repeated N-gram fraction exceeds 0.7. Reproduce the same metric
+// over a highly repetitive stream so the constructed verdict is grounded in a real degenerate
+// payload rather than arbitrary numbers.
+const DEGENERATION_N = 4
+const degeneratePayload = "degenerate-loop ".repeat(1_500) // 24_000 chars of repetitive text
+
+function repetitionRatio(text: string) {
+  const counts = new Map<string, number>()
+  for (let i = 0; i <= text.length - DEGENERATION_N; i++) {
+    const ngram = text.slice(i, i + DEGENERATION_N)
+    counts.set(ngram, (counts.get(ngram) ?? 0) + 1)
+  }
+  let total = 0
+  let repeated = 0
+  for (const count of counts.values()) {
+    total += count
+    if (count > 1) repeated += count - 1
+  }
+  return total === 0 ? 0 : repeated / total
+}
+
+function degenerationError() {
+  return new SessionV1.OutputDegenerationError({
+    chars: degeneratePayload.length,
+    ratio: repetitionRatio(degeneratePayload),
+    detectorVersion: "1.0",
+  })
+}
+
+type Err = ReturnType<NamedError["toObject"]>
+
+const policy = (attempts: { count: number }) =>
+  SessionRetry.policy({
+    provider,
+    parse: (error) => error as Err,
+    set: () =>
+      Effect.sync(() => {
+        attempts.count += 1
+      }),
+  })
+
+describe("tool.output-degeneration", () => {
+  it.effect("degenerate payload exceeds the detector thresholds", () =>
+    Effect.sync(() => {
+      expect(degeneratePayload.length).toBeGreaterThan(20_000)
+      expect(repetitionRatio(degeneratePayload)).toBeGreaterThan(0.7)
+    }),
+  )
+
+  it.effect("carries the detector verdict with the processor's error contract", () =>
+    Effect.sync(() => {
+      const error = degenerationError()
+      expect(SessionV1.OutputDegenerationError.isInstance(error)).toBe(true)
+      expect(error.toObject().name).toBe("OutputDegenerationError")
+      expect(SessionV1.OutputDegenerationError.isInstance(error.toObject())).toBe(true)
+      expect(error.data.chars).toBe(degeneratePayload.length)
+      expect(error.data.ratio).toBeGreaterThan(0.7)
+      expect(error.data.detectorVersion).toBe("1.0")
+      // Distinct error types must not be confused with the degeneration verdict.
+      expect(SessionV1.ContextOverflowError.isInstance(error)).toBe(false)
+      expect(SessionV1.APIError.isInstance(error)).toBe(false)
+    }),
+  )
+
+  it.effect("retry special-case never treats degeneration as retryable", () =>
+    Effect.sync(() => {
+      const error = degenerationError()
+      expect(SessionRetry.retryable(error.toObject(), provider)).toBeUndefined()
+      // A transient 5xx failure stays retryable — the special case is specific, not a blanket
+      // non-retry fallback.
+      const retryable = Schema.decodeUnknownSync(SessionV1.APIError.Schema)(
+        new SessionV1.APIError({
+          message: "Internal server error",
+          isRetryable: false,
+          statusCode: 500,
+          responseHeaders: { "retry-after-ms": "0" },
+        }).toObject(),
+      )
+      expect(SessionRetry.retryable(retryable, provider)).toEqual({ message: "Internal server error" })
+    }),
+  )
+
+  it.effect("bounded termination: the retry harness stops after the single failed attempt", () =>
+    Effect.gen(function* () {
+      const error = degenerationError()
+      let executions = 0
+      const attempts = { count: 0 }
+      const failing = Effect.gen(function* () {
+        executions += 1
+        return yield* Effect.fail(error.toObject())
+      })
+
+      let captured: unknown = undefined
+      yield* failing.pipe(
+        Effect.retry(policy(attempts)),
+        Effect.catch((error) =>
+          Effect.sync(() => {
+            captured = error
+          }),
+        ),
+      )
+
+      // No retry scheduled, no status published, exactly one provider attempt, original verdict.
+      expect(executions).toBe(1)
+      expect(attempts.count).toBe(0)
+      expect(SessionV1.OutputDegenerationError.isInstance(captured)).toBe(true)
+    }),
+  )
+
+  it.effect("contrast: a retryable provider error does retry under the same harness", () =>
+    Effect.gen(function* () {
+      const retryable = Schema.decodeUnknownSync(SessionV1.APIError.Schema)(
+        new SessionV1.APIError({
+          message: "Internal server error",
+          isRetryable: false,
+          statusCode: 500,
+          responseHeaders: { "retry-after-ms": "0" },
+        }).toObject(),
+      )
+      let executions = 0
+      const attempts = { count: 0 }
+      const failing = Effect.gen(function* () {
+        executions += 1
+        return yield* Effect.fail(retryable)
+      })
+
+      // Bounded by Schedule.recurs(2) so the contrast cannot loop forever: exactly two retries
+      // (three executions). The policy's decision is consulted once more after the recurs bound
+      // trips, so its `set` callback observes three decisions while only two retries execute.
+      const exit = yield* failing.pipe(
+        Effect.retry(policy(attempts).pipe(Schedule.both(Schedule.recurs(2)))),
+        Effect.exit,
+      )
+
+      expect(Exit.isFailure(exit)).toBe(true)
+      expect(executions).toBe(3)
+      expect(attempts.count).toBe(3)
+    }),
+  )
+
+  it.effect("assistant error classification preserves the degeneration verdict untouched", () =>
+    Effect.sync(() => {
+      const error = degenerationError()
+      const classified = MessageV2.fromError(error, { providerID: ProviderV2.ID.make(provider) })
+      expect(SessionV1.OutputDegenerationError.isInstance(classified)).toBe(true)
+      if (SessionV1.OutputDegenerationError.isInstance(classified)) {
+        expect(classified.data.chars).toBe(error.data.chars)
+        expect(classified.data.ratio).toBe(error.data.ratio)
+        expect(classified.data.detectorVersion).toBe("1.0")
+      }
+    }),
+  )
+})
diff --git a/packages/deepagent-code/test/tool/pr-finalize.test.ts b/packages/deepagent-code/test/tool/pr-finalize.test.ts
index 3f5a653e..3b7496c7 100644
--- a/packages/deepagent-code/test/tool/pr-finalize.test.ts
+++ b/packages/deepagent-code/test/tool/pr-finalize.test.ts
@@ -14,6 +14,7 @@ import { EventV2Bridge } from "@/event-v2-bridge"
 import { RuntimeFlags } from "@/effect/runtime-flags"
 import { Git } from "@/git"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { createAgentWorktree } from "@/session/agent-worktree"
 import { SessionRunState } from "@/session/run-state"
 import { SessionStatus } from "@/session/status"
@@ -45,6 +46,9 @@ const layer = Layer.mergeAll(
   Config.defaultLayer,
   CrossSpawnSpawner.defaultLayer,
   Session.defaultLayer,
+  // QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+  // writes hit the session FK.
+  SessionProjector.defaultLayer,
   SessionRunState.defaultLayer,
   SessionStatus.defaultLayer,
   Truncate.defaultLayer,
diff --git a/packages/deepagent-code/test/tool/registry.test.ts b/packages/deepagent-code/test/tool/registry.test.ts
index 02e02333..a9812f76 100644
--- a/packages/deepagent-code/test/tool/registry.test.ts
+++ b/packages/deepagent-code/test/tool/registry.test.ts
@@ -145,6 +145,10 @@ const withBrokenPlugin = testEffect(
 const itNoCodeIntel = testEffect(
   Layer.mergeAll(registryLayer({ flags: { codeIntelTool: false } }), node, Agent.defaultLayer),
 )
+// FEAT-011 T4: the activity facade tools are staged behind DEEPAGENT_CODE_ACTIVITY_FACADE.
+const itActivityFacade = testEffect(
+  Layer.mergeAll(registryLayer({ flags: { activityFacade: true } }), node, Agent.defaultLayer),
+)
 const itContextToolsV2 = testEffect(
   Layer.mergeAll(
     registryLayer({
@@ -243,6 +247,94 @@ describe("tool.registry", () => {
     }),
   )
 
+  // FEAT-011 T4 — flag-gated visibility. The facade flag defaults OFF (staged), so the default
+  // registry output must carry ZERO activity_* tools (byte-identical visibility to pre-facade).
+  it.instance("hides all activity facade tools while DEEPAGENT_CODE_ACTIVITY_FACADE stays staged off", () =>
+    Effect.gen(function* () {
+      const registry = yield* ToolRegistry.Service
+      const agents = yield* Agent.Service
+      const build = yield* agents.get("build")
+
+      const ids = yield* registry.ids()
+      expect(ids).not.toContain("activity_start")
+      expect(ids).not.toContain("activity_status")
+      expect(ids).not.toContain("activity_result")
+      expect(ids).not.toContain("activity_control")
+
+      const projected = (yield* registry.tools({
+        providerID: ProviderV2.ID.make("deepagent-code"),
+        modelID: ModelV2.ID.make("test"),
+        agent: build,
+      })).map((tool) => tool.id)
+      expect(projected.filter((id) => id.startsWith("activity_"))).toHaveLength(0)
+    }),
+    30_000,
+  )
+
+  itActivityFacade.instance("exposes activity facade tools to primary agents only when the flag is on", () =>
+    Effect.gen(function* () {
+      const registry = yield* ToolRegistry.Service
+      const agents = yield* Agent.Service
+      const build = yield* agents.get("build")
+      const reviewer = yield* agents.get("reviewer")
+
+      const primary = (yield* registry.tools({
+        providerID: ProviderV2.ID.make("deepagent-code"),
+        modelID: ModelV2.ID.make("test"),
+        agent: build,
+      })).map((tool) => tool.id)
+      expect(primary).toContain("activity_start")
+      expect(primary).toContain("activity_status")
+      expect(primary).toContain("activity_result")
+      expect(primary).toContain("activity_control")
+
+      // Non-primary agents never see the facade (mirrors the pr_finalize projection fence).
+      const subagent = (yield* registry.tools({
+        providerID: ProviderV2.ID.make("deepagent-code"),
+        modelID: ModelV2.ID.make("test"),
+        agent: reviewer,
+      })).map((tool) => tool.id)
+      expect(subagent.filter((id) => id.startsWith("activity_"))).toHaveLength(0)
+    }),
+    30_000,
+  )
+
+  itActivityFacade.instance("activity facade tool schemas stay bounded (T6)", () =>
+    Effect.gen(function* () {
+      const registry = yield* ToolRegistry.Service
+      const all = yield* registry.all()
+      const status = all.find((tool) => tool.id === "activity_status")
+      const start = all.find((tool) => tool.id === "activity_start")
+      if (!status || !start) throw new Error("activity facade tools missing from registry")
+
+      // status limit: hard ceiling 20.
+      expect(Result.isSuccess(Schema.decodeUnknownResult(status.parameters)({ limit: 20 }))).toBe(true)
+      expect(Result.isSuccess(Schema.decodeUnknownResult(status.parameters)({ limit: 21 }))).toBe(false)
+      expect(Result.isSuccess(Schema.decodeUnknownResult(status.parameters)({ limit: 0 }))).toBe(false)
+
+      // start: subkind is a closed enum, objective is required.
+      expect(Result.isSuccess(Schema.decodeUnknownResult(start.parameters)({ subkind: "task", objective: "x" }))).toBe(
+        true,
+      )
+      expect(Result.isSuccess(Schema.decodeUnknownResult(start.parameters)({ subkind: "other", objective: "x" }))).toBe(
+        false,
+      )
+      expect(Result.isSuccess(Schema.decodeUnknownResult(start.parameters)({ subkind: "goal" }))).toBe(false)
+
+      // budget fields must be positive integers when supplied.
+      expect(
+        Result.isSuccess(
+          Schema.decodeUnknownResult(start.parameters)({ subkind: "goal", objective: "x", budget: { maxTicks: 5 } }),
+        ),
+      ).toBe(true)
+      expect(
+        Result.isSuccess(
+          Schema.decodeUnknownResult(start.parameters)({ subkind: "goal", objective: "x", budget: { maxTicks: -1 } }),
+        ),
+      ).toBe(false)
+    }),
+  )
+
   it.instance("exposes task status, close, and explicit recovery controls", () =>
     Effect.gen(function* () {
       const registry = yield* ToolRegistry.Service
diff --git a/packages/deepagent-code/test/tool/task-read.test.ts b/packages/deepagent-code/test/tool/task-read.test.ts
index e7a7a35a..ae72713c 100644
--- a/packages/deepagent-code/test/tool/task-read.test.ts
+++ b/packages/deepagent-code/test/tool/task-read.test.ts
@@ -6,6 +6,7 @@ import { EventV2Bridge } from "@/event-v2-bridge"
 import { Config } from "@/config/config"
 import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { SessionRunState } from "@/session/run-state"
 import { SessionStatus } from "@/session/status"
 import { Database } from "@deepagent-code/core/database/database"
@@ -33,6 +34,9 @@ const it = testEffect(
     Config.defaultLayer,
     CrossSpawnSpawner.defaultLayer,
     Session.defaultLayer,
+    // QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+    // writes hit the session FK.
+    SessionProjector.defaultLayer,
     SessionRunState.defaultLayer,
     SessionStatus.defaultLayer,
     Truncate.defaultLayer,
diff --git a/packages/deepagent-code/test/tool/task-recovery.test.ts b/packages/deepagent-code/test/tool/task-recovery.test.ts
index fb8d262a..0eb15c54 100644
--- a/packages/deepagent-code/test/tool/task-recovery.test.ts
+++ b/packages/deepagent-code/test/tool/task-recovery.test.ts
@@ -14,6 +14,7 @@ import { ToolRegistry } from "@/tool/registry"
 import { Truncate } from "@/tool/truncate"
 import { and, eq } from "drizzle-orm"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { MessageID } from "@/session/schema"
 import { TaskRecoveryTool } from "@/tool/task_recovery"
 import { testEffect } from "../lib/effect"
@@ -28,6 +29,9 @@ const it = testEffect(
     EventV2Bridge.defaultLayer,
     RuntimeFlags.layer(),
     Session.defaultLayer,
+    // QUAL-007: the core SessionProjector materializes event-created sessions; without it the
+    // TaskRunTable FK to the session row fails.
+    SessionProjector.defaultLayer,
     SessionRunState.defaultLayer,
     SessionStatus.defaultLayer,
     ToolRegistry.defaultLayer,
diff --git a/packages/deepagent-code/test/tool/task-status.test.ts b/packages/deepagent-code/test/tool/task-status.test.ts
index cd3976d5..0d6f3080 100644
--- a/packages/deepagent-code/test/tool/task-status.test.ts
+++ b/packages/deepagent-code/test/tool/task-status.test.ts
@@ -6,6 +6,7 @@ import { EventV2Bridge } from "@/event-v2-bridge"
 import { Config } from "@/config/config"
 import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import { SessionRunState } from "@/session/run-state"
 import { SessionStatus } from "@/session/status"
 import { Database } from "@deepagent-code/core/database/database"
@@ -30,6 +31,9 @@ const it = testEffect(
     Config.defaultLayer,
     CrossSpawnSpawner.defaultLayer,
     Session.defaultLayer,
+    // QUAL-007: the core SessionProjector materializes event-created sessions; without it child
+    // session reads fail with Session not found.
+    SessionProjector.defaultLayer,
     SessionRunState.defaultLayer,
     SessionStatus.defaultLayer,
     Truncate.defaultLayer,
diff --git a/packages/deepagent-code/test/tool/task-takeover.test.ts b/packages/deepagent-code/test/tool/task-takeover.test.ts
index 6da3b8b1..860c8b89 100644
--- a/packages/deepagent-code/test/tool/task-takeover.test.ts
+++ b/packages/deepagent-code/test/tool/task-takeover.test.ts
@@ -9,6 +9,7 @@ import { EventV2Bridge } from "@/event-v2-bridge"
 import { Config } from "@/config/config"
 import { CrossSpawnSpawner } from "@deepagent-code/core/cross-spawn-spawner"
 import { Session } from "@/session/session"
+import { SessionProjector } from "@deepagent-code/core/session/projector"
 import type { SessionPrompt } from "../../src/session/prompt"
 import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { SessionRunState } from "@/session/run-state"
@@ -36,6 +37,9 @@ const layer = (flags: Partial<RuntimeFlags.Info> = {}) =>
     Config.defaultLayer,
     CrossSpawnSpawner.defaultLayer,
     Session.defaultLayer,
+    // QUAL-007: the core SessionProjector materializes event-created sessions; without it message
+    // writes hit the session FK.
+    SessionProjector.defaultLayer,
     SessionRunState.defaultLayer,
     SessionStatus.defaultLayer,
     Truncate.defaultLayer,
diff --git a/packages/deepagent-code/test/wiki/wiki-events.test.ts b/packages/deepagent-code/test/wiki/wiki-events.test.ts
new file mode 100644
index 00000000..9a6fc151
--- /dev/null
+++ b/packages/deepagent-code/test/wiki/wiki-events.test.ts
@@ -0,0 +1,245 @@
+import { afterEach, describe, expect } from "bun:test"
+import { rmSync } from "node:fs"
+import path from "node:path"
+import { Effect, Layer, Stream } from "effect"
+import { DeepAgentEventBus } from "@deepagent-code/core/deepagent/deepagent-event-bus"
+import { LMNEvents } from "@deepagent-code/core/deepagent/lmn-events"
+import { Database } from "@deepagent-code/core/database/database"
+import { DocumentStore } from "@deepagent-code/core/deepagent/document-store"
+import { Global } from "@deepagent-code/core/global"
+import { WikiService, WikiGraph, EXECUTION_ARCHIVE_TYPES } from "../../src/wiki/wiki-service"
+import * as WikiEvents from "../../src/wiki/wiki-events"
+import { archiveSessionOnCompletion } from "../../src/wiki/session-archive"
+import { EventDrivenArchiver } from "../../src/wiki/event-driven-archiver"
+import { testEffect } from "../lib/effect"
+import { freshStore, knowledgeInput } from "./helpers"
+
+// FEAT-006 — wiki/knowledge change eventing (LMNEvents.WIKI_PAGE_CHANGED):
+//   1. editKnowledge publishes after the governed write commits (type/payload/idempotency key);
+//   2. the same write redelivered (same docId+version) never double-publishes (bus dedup on key);
+//   3. the archive path (archiveSessionOnCompletion) publishes with the `archive` marker in the key;
+//   4. SELF-LOOP isolation: wiki.page.changed is not an archive trigger, and the archiver ignores it;
+//   5. the bus port is injectable (constructor) AND resolvable from the Effect environment (the
+//      production seam — the unmodified wikiEdit handler's runtime provides the bus layer).
+
+const roots: string[] = []
+afterEach(() => {
+  for (const r of roots.splice(0)) rmSync(r, { recursive: true, force: true })
+})
+
+// Seed a session's run-scoped context store (the SAME root archiveSessionOnCompletion persists
+// into) with one trajectory doc, so archival produces a REAL persisted archive page to emit for.
+const seedSessionStore = (sessionID: string) => {
+  const root = path.join(Global.Path.agent.data, "state", "context", sessionID)
+  const store = new DocumentStore(root)
+  store.create({
+    type: "plan",
+    scope: `run:${sessionID}`,
+    body: "goal: ship it",
+    description: "plan",
+    provenance: { source: "runner", run_ref: `run:${sessionID}` },
+  })
+  roots.push(root)
+}
+
+let clock = 0
+const now = () => clock
+const database = Database.layerFromPath(":memory:")
+const busLayer = DeepAgentEventBus.layerWith({ now }).pipe(Layer.provideMerge(database))
+// runLoop:false → no background subscription; handle() is driven directly for the self-loop test.
+const archiverLayer = EventDrivenArchiver.layerWith({ runLoop: false }).pipe(Layer.provideMerge(busLayer))
+const it = testEffect(archiverLayer)
+
+// Every wiki.page.changed event currently on the bus (durable replay — deterministic).
+const replayWikiEvents = Effect.gen(function* () {
+  const bus = yield* DeepAgentEventBus.Service
+  const chunk = yield* Stream.runCollect(bus.replay({ from: 0, type: LMNEvents.WIKI_PAGE_CHANGED }))
+  return Array.from(chunk)
+})
+
+const WORKSPACE = "/tmp/feat-006-ws"
+
+describe("FEAT-006 editKnowledge → wiki.page.changed", () => {
+  it.effect("publishes AFTER a committed edit: type/payload/idempotency key (injected bus port)", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const { store, root } = freshStore()
+      roots.push(root)
+      const k = store.create(knowledgeInput({ body: "v1" }))
+      // explicit port injection (the constructor seam) — workspacePath labels the payload.
+      const service = new WikiService(new WikiGraph([store]), undefined, { bus, workspacePath: WORKSPACE })
+      const page = yield* service.editKnowledge({ docId: k.id, body: "v2 edited", editor: { id: "alice" } })
+      expect(page.version).toBe(2)
+
+      const events = yield* replayWikiEvents
+      expect(events).toHaveLength(1)
+      const ev = events[0]!
+      expect(ev.type).toBe(LMNEvents.WIKI_PAGE_CHANGED)
+      expect(ev.idempotencyKey).toBe(WikiEvents.wikiPageChangedIdempotencyKey({ docId: k.id, version: 2 }))
+      expect(ev.idempotencyKey).toBe(`wiki.page.changed:${k.id}:2`) // docId+version, no archive marker
+      const payload = ev.payload as Record<string, unknown>
+      expect(payload.workspacePath).toBe(WORKSPACE)
+      expect(payload.docId).toBe(k.id)
+      expect(payload.type).toBe("knowledge")
+      expect(payload.version).toBe(2)
+      expect(payload.editor).toBe("alice")
+      expect(payload.archive).toBeUndefined() // a human edit is NOT an archive write
+    }),
+  )
+
+  it.effect("environment seam: no injected port → the bus is resolved from the Effect runtime", () =>
+    Effect.gen(function* () {
+      // The production construction point (handlers/deepagent.ts) passes NO bus — the route runtime
+      // provides DeepAgentEventBus.defaultLayer, and editKnowledge falls back to the environment's
+      // service. This test reproduces that seam exactly: ports carry only workspacePath.
+      const { store, root } = freshStore()
+      roots.push(root)
+      const k = store.create(knowledgeInput({ body: "v1" }))
+      const service = new WikiService(new WikiGraph([store]), undefined, { workspacePath: WORKSPACE })
+      yield* service.editKnowledge({ docId: k.id, body: "v2", editor: { id: "bob" } })
+      const events = yield* replayWikiEvents
+      expect(events).toHaveLength(1)
+      expect((events[0]!.payload as Record<string, unknown>).editor).toBe("bob")
+    }),
+  )
+
+  it.effect("a bus-less edit never fails and never emits (graceful degradation without any bus)", () =>
+    Effect.gen(function* () {
+      // No injected port AND no bus in the environment: run the edit through a bare runtime
+      // (Effect.runPromise in a plain Effect below — no bus layer provided), so resolveBus's
+      // serviceOption sees None. The edit must still commit: publishing is best-effort, never a
+      // dependency of the write itself.
+      const { store, root } = freshStore()
+      roots.push(root)
+      const k = store.create(knowledgeInput({ body: "v1" }))
+      const service = new WikiService(new WikiGraph([store]))
+      const page = yield* Effect.promise(() =>
+        Effect.runPromise(service.editKnowledge({ docId: k.id, body: "v2", editor: { id: "carol" } })),
+      )
+      expect(page.version).toBe(2)
+      expect(store.get(k.id)!.version).toBe(2)
+      // no bus anywhere → nothing was published anywhere this test can see; the write is intact.
+    }),
+  )
+
+  it.effect("idempotency: same docId+version published twice → ONE event (no duplicate)", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const { store, root } = freshStore()
+      roots.push(root)
+      const k = store.create(knowledgeInput({ body: "v1" }))
+      const service = new WikiService(new WikiGraph([store]), undefined, { bus, workspacePath: WORKSPACE })
+      yield* service.editKnowledge({ docId: k.id, body: "v2", editor: { id: "alice" } })
+      // Simulate a redelivery of the SAME committed write (docId+version identical): the publisher
+      // re-emits with the same idempotency key → the bus dedupes, no second event row.
+      yield* WikiEvents.publishWikiPageChanged(bus, {
+        workspacePath: WORKSPACE,
+        docId: k.id,
+        type: "knowledge",
+        version: 2,
+        editor: "alice",
+      })
+      const events = yield* replayWikiEvents
+      expect(events).toHaveLength(1) // deduped on wiki.page.changed:<docId>:2
+      // a GENUINELY new edit bumps the version → a NEW key → a second event (not swallowed).
+      yield* service.editKnowledge({ docId: k.id, body: "v3", editor: { id: "alice" } })
+      expect((yield* replayWikiEvents)).toHaveLength(2)
+    }),
+  )
+})
+
+describe("FEAT-006 archive path → wiki.page.changed (archive marker)", () => {
+  it.effect("archiveSessionOnCompletion publishes with archive:true + `archive:` idempotency key", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const sessionID = "sess-feat006-archive"
+      seedSessionStore(sessionID)
+      const archive = yield* archiveSessionOnCompletion({ workspacePath: WORKSPACE, sessionID, bus })
+      expect(archive).not.toBeNull()
+
+      const events = yield* replayWikiEvents
+      expect(events).toHaveLength(1)
+      const ev = events[0]!
+      expect(ev.type).toBe(LMNEvents.WIKI_PAGE_CHANGED)
+      const payload = ev.payload as Record<string, unknown>
+      expect(payload.archive).toBe(true) // the archive marker
+      expect(payload.sessionID).toBe(sessionID)
+      expect(payload.workspacePath).toBe(WORKSPACE)
+      expect(payload.editor).toBe("system:archiver")
+      expect(payload.type).toBe("context_snapshot") // the persisted archive page's doc type
+      expect(ev.idempotencyKey!.startsWith("wiki.page.changed:archive:")).toBe(true)
+      expect(ev.idempotencyKey).toBe(
+        WikiEvents.wikiPageChangedIdempotencyKey({
+          docId: payload.docId as string,
+          version: payload.version as number,
+          archive: { sessionID },
+        }),
+      )
+    }),
+  )
+
+  it.effect("redelivered archive trigger → SAME docId+version → no duplicate event (idempotent)", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const sessionID = "sess-feat006-redeliver"
+      seedSessionStore(sessionID)
+      yield* archiveSessionOnCompletion({ workspacePath: WORKSPACE, sessionID, bus })
+      // A redelivered session.completed re-runs the archive: the trajectory is unchanged, so
+      // DocumentStore.upsert is a fingerprint no-op (same doc at the same version) → the event's
+      // idempotency key is identical → the bus dedupes.
+      yield* archiveSessionOnCompletion({ workspacePath: WORKSPACE, sessionID, bus })
+      yield* archiveSessionOnCompletion({ workspacePath: WORKSPACE, sessionID, bus })
+      const events = yield* replayWikiEvents
+      expect(events).toHaveLength(1) // three runs, ONE event
+    }),
+  )
+})
+
+describe("FEAT-006 self-loop protection (archiver ⇏ wiki.page.changed ⇏ archiver)", () => {
+  it.effect("isolation proof: wiki.page.changed is NOT an archive trigger; archiver ignores it", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const archiver = yield* EventDrivenArchiver.Service
+      // 1. Type-level isolation: the consumer-type filter is the guard (see LMNEvents comment —
+      //    DLQ_ALERT guards at the producer instead; here the archiver simply never matches).
+      expect(LMNEvents.isArchiveTrigger(LMNEvents.WIKI_PAGE_CHANGED)).toBe(false)
+      // 2. Content-level isolation: the persisted archive page is a context_snapshot — outside
+      //    EXECUTION_ARCHIVE_TYPES — so it could never be folded into a later archive either.
+      expect(EXECUTION_ARCHIVE_TYPES.includes("context_snapshot")).toBe(false)
+      // 3. Behavioral proof: feed a REAL published wiki.page.changed to the archiver's handler —
+      //    it acks it as "not our concern" and produces NO archive.
+      const ev = yield* bus.publish({
+        type: LMNEvents.WIKI_PAGE_CHANGED,
+        source: "system",
+        workspaceID: WORKSPACE,
+        idempotencyKey: "self-loop-1",
+        payload: { workspacePath: WORKSPACE, docId: "doc:knowledge:x", type: "knowledge", version: 2, editor: "alice" },
+      })
+      expect(yield* archiver.handle(ev)).toBe(false) // not an archive trigger → skipped, no write
+    }),
+  )
+
+  it.effect("archiver-driven archive emits wiki.page.changed without re-triggering itself", () =>
+    Effect.gen(function* () {
+      const bus = yield* DeepAgentEventBus.Service
+      const archiver = yield* EventDrivenArchiver.Service
+      const sessionID = "sess-feat006-selfloop"
+      seedSessionStore(sessionID)
+      // Drive the archiver end-to-end: session.completed → archive persist → wiki.page.changed.
+      const trigger = yield* bus.publish({
+        type: LMNEvents.SESSION_COMPLETED,
+        source: "system",
+        workspaceID: WORKSPACE,
+        idempotencyKey: "sc-selfloop",
+        payload: { sessionID, workspacePath: WORKSPACE },
+      })
+      expect(yield* archiver.handle(trigger)).toBe(true) // archive produced (bus injected by layer)
+      const wikiEvents = yield* replayWikiEvents
+      expect(wikiEvents).toHaveLength(1)
+      // The emitted event is inert for the archiver: handle() on it produces nothing.
+      expect(yield* archiver.handle(wikiEvents[0]!)).toBe(false)
+      // …and no SECOND archive-derived event appeared (no cascade, no duplicate).
+      expect((yield* replayWikiEvents)).toHaveLength(1)
+    }),
+  )
+})
diff --git a/packages/desktop/package.json b/packages/desktop/package.json
index b2b71243..8df5a771 100644
--- a/packages/desktop/package.json
+++ b/packages/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@deepagent-code/desktop",
   "private": true,
-  "version": "1.4.6",
+  "version": "1.4.7",
   "type": "module",
   "license": "AGPL-3.0-or-later",
   "homepage": "https://deepagent-code.ai",
diff --git a/packages/llm/src/protocols/index.ts b/packages/llm/src/protocols/index.ts
index bd8c8d3d..d00d517a 100644
--- a/packages/llm/src/protocols/index.ts
+++ b/packages/llm/src/protocols/index.ts
@@ -3,4 +3,5 @@ export * as BedrockConverse from "./bedrock-converse"
 export * as Gemini from "./gemini"
 export * as OpenAIChat from "./openai-chat"
 export * as OpenAICompatibleChat from "./openai-compatible-chat"
+export * as OpenAICompatibleResponses from "./openai-compatible-responses"
 export * as OpenAIResponses from "./openai-responses"
diff --git a/packages/llm/src/protocols/openai-compatible-responses.ts b/packages/llm/src/protocols/openai-compatible-responses.ts
new file mode 100644
index 00000000..f5f5bc27
--- /dev/null
+++ b/packages/llm/src/protocols/openai-compatible-responses.ts
@@ -0,0 +1,29 @@
+import { Route, type RouteRoutedModelInput } from "../route/client"
+import { Endpoint } from "../route/endpoint"
+import { Framing } from "../route/framing"
+import * as OpenAIResponses from "./openai-responses"
+
+const ADAPTER = "openai-compatible-responses"
+
+export type OpenAICompatibleResponsesModelInput = RouteRoutedModelInput
+
+/**
+ * Route for non-OpenAI providers that expose an OpenAI Responses-compatible
+ * `/responses` endpoint (e.g. DeepSeek). Reuses `OpenAIResponses.protocol`
+ * end-to-end and overrides only the route id so providers can be resolved
+ * per-family without colliding with native OpenAI.
+ *
+ * It intentionally does NOT reuse `OpenAIResponses.route`, which hardcodes
+ * `provider: "openai"`; `Route.model` prefers the route-owned provider
+ * (see route/client.ts `makeRouteModel`) and would mis-attribute a DeepSeek
+ * model to OpenAI. Provider helpers configure the route endpoint and provider
+ * before model selection.
+ */
+export const route = Route.make({
+  id: ADAPTER,
+  protocol: OpenAIResponses.protocol,
+  endpoint: Endpoint.path("/responses"),
+  framing: Framing.sse,
+})
+
+export * as OpenAICompatibleResponses from "./openai-compatible-responses"
diff --git a/packages/llm/src/protocols/openai-responses.ts b/packages/llm/src/protocols/openai-responses.ts
index 42e0bbe2..52133025 100644
--- a/packages/llm/src/protocols/openai-responses.ts
+++ b/packages/llm/src/protocols/openai-responses.ts
@@ -2,6 +2,7 @@ import { Effect, Schema } from "effect"
 import { Route } from "../route/client"
 import { Auth } from "../route/auth"
 import { Endpoint } from "../route/endpoint"
+import { RequestExecutor } from "../route/executor"
 import { HttpTransport, WebSocketTransport } from "../route/transport"
 import { Protocol } from "../route/protocol"
 import {
@@ -9,6 +10,7 @@ import {
   ToolDefinition,
   Usage,
   type FinishReason,
+  type LLMError,
   type LLMRequest,
   type ProviderMetadata,
   type ReasoningPart,
@@ -27,6 +29,21 @@ const ADAPTER = "openai-responses"
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/responses"
 
+// UPD-005 (/responses/compact): OpenAI-specific UNARY endpoint that compacts
+// conversation history server-side and returns a new item list. Served from
+// the same base URL as `/responses`. The Protocol/Route abstraction is
+// streaming-only (SSE state machine), so compact is deliberately implemented
+// as a standalone unary client below instead of extending Protocol.make —
+// that keeps the blast radius inside this single file.
+export const COMPACT_PATH = "/responses/compact"
+
+/**
+ * UPD-005: whether this protocol's canonical provider serves `/responses/compact`.
+ * True only for the OpenAI Responses route; OpenAI-compatible families must
+ * opt in per profile (`supportsResponsesCompact`) and are NOT assumed to.
+ */
+export const supportsRemoteCompaction = true
+
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -63,6 +80,15 @@ const OpenAIResponsesItemReference = Schema.Struct({
   id: Schema.String,
 })
 
+// UPD-005 (/responses/compact): a prior server-side compaction's opaque
+// encrypted context. Sent ahead of the new messages so the provider can
+// expand it during the next compaction. Never interpreted client-side.
+const OpenAIResponsesCompactionItem = Schema.Struct({
+  type: Schema.tag("compaction"),
+  encrypted_content: Schema.String,
+})
+type OpenAIResponsesCompactionItem = Schema.Schema.Type<typeof OpenAIResponsesCompactionItem>
+
 // `function_call_output.output` accepts either a plain string or an ordered
 // array of content items so tools can return images in addition to text.
 // https://platform.openai.com/docs/api-reference/responses/object
@@ -75,6 +101,7 @@ const OpenAIResponsesFunctionCallOutput = Schema.Union([
 
 const OpenAIResponsesInputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
+  OpenAIResponsesCompactionItem,
   Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenAIResponsesInputContent) }),
   Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenAIResponsesOutputText) }),
   OpenAIResponsesReasoningItem,
@@ -168,6 +195,15 @@ const OpenAIResponsesCoreFields = {
   text: Schema.optional(
     Schema.Struct({
       verbosity: Schema.optional(OpenAIOptions.OpenAITextVerbosity),
+      // UPD-002: wire-level structured output (json_schema constrained text).
+      format: Schema.optional(
+        Schema.Struct({
+          type: Schema.Literal("json_schema"),
+          name: Schema.String,
+          schema: Schema.Record(Schema.String, Schema.Unknown),
+          strict: Schema.optional(Schema.Boolean),
+        }),
+      ),
     }),
   ),
   max_output_tokens: Schema.optional(Schema.Number),
@@ -267,6 +303,12 @@ interface ParserState {
   readonly lifecycle: Lifecycle.State
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
   readonly store: boolean | undefined
+  // UPD-002: when the request asked for wire-level json_schema output, this
+  // holds the requested format name and the parser accumulates the streamed
+  // output text so `response.completed` can verify the provider actually
+  // returned well-formed JSON (failure ⇒ InvalidProviderOutput).
+  readonly jsonFormatName: string | undefined
+  readonly accumulatedText: string
 }
 
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
@@ -525,6 +567,21 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
     : input
 })
 
+// UPD-002: lower the canonical `responseFormat` json variant onto OpenAI
+// Responses' wire shape. `strict` stays opt-in: session schemas are not
+// authored against OpenAI's strict-mode restrictions (additionalProperties,
+// required-field enumeration), so defaulting to false keeps every schema valid.
+const lowerTextFormat = (request: LLMRequest) => {
+  const format = request.responseFormat
+  if (!format || format.type !== "json") return undefined
+  return {
+    type: "json_schema" as const,
+    name: format.name ?? "structured_output",
+    schema: format.schema,
+    ...(format.strict !== undefined ? { strict: format.strict } : {}),
+  }
+}
+
 const lowerOptions = Effect.fn("OpenAIResponses.lowerOptions")(function* (request: LLMRequest) {
   const store = OpenAIOptions.store(request)
   const promptCacheKey = OpenAIOptions.promptCacheKey(request)
@@ -536,13 +593,16 @@ const lowerOptions = Effect.fn("OpenAIResponses.lowerOptions")(function* (reques
   const verbosity = OpenAIOptions.textVerbosity(request)
   const instructions = OpenAIOptions.instructions(request)
   const serviceTier = OpenAIOptions.serviceTier(request)
+  const format = lowerTextFormat(request)
+  const text =
+    verbosity || format ? { ...(verbosity ? { verbosity } : {}), ...(format ? { format } : {}) } : undefined
   return {
     ...(instructions ? { instructions } : {}),
     ...(store !== undefined ? { store } : {}),
     ...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
     ...(include ? { include } : {}),
     ...(effort || summary ? { reasoning: { effort, summary } } : {}),
-    ...(verbosity ? { text: { verbosity } } : {}),
+    ...(text ? { text } : {}),
     ...(serviceTier ? { service_tier: serviceTier } : {}),
   }
 })
@@ -686,7 +746,13 @@ const onOutputTextDelta = (state: ParserState, event: OpenAIResponsesEvent): Ste
   if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
   return [
-    { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, event.item_id ?? "text-0", event.delta) },
+    {
+      ...state,
+      lifecycle: Lifecycle.textDelta(state.lifecycle, events, event.item_id ?? "text-0", event.delta),
+      // Only accumulate when a wire json_schema format was requested — keeps
+      // the free-form path allocation-free.
+      accumulatedText: state.jsonFormatName ? state.accumulatedText + event.delta : state.accumulatedText,
+    },
     events,
   ]
 }
@@ -970,7 +1036,21 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
   return [state, NO_EVENTS] satisfies StepResult
 })
 
-const onResponseFinish = (state: ParserState, event: OpenAIResponsesEvent): StepResult => {
+const onResponseFinish = Effect.fn("OpenAIResponses.onResponseFinish")(function* (
+  state: ParserState,
+  event: OpenAIResponsesEvent,
+) {
+  // UPD-002: wire-level structured-output guarantee. When the request carried
+  // a json_schema text format, the accumulated output text MUST parse as JSON;
+  // a provider that ignored the format (or a truncated stream) surfaces here
+  // as InvalidProviderOutput instead of leaking prose to the caller.
+  if (state.jsonFormatName && !state.hasFunctionCall) {
+    yield* ProviderShared.parseJson(
+      ADAPTER,
+      state.accumulatedText,
+      `OpenAI Responses text.format json_schema output is not valid JSON (format: ${state.jsonFormatName})`,
+    )
+  }
   const reason = mapFinishReason(event, state.hasFunctionCall)
   const releaseTools = event.type === "response.completed" && reason !== "length" && reason !== "content-filter"
   const events: LLMEvent[] = releaseTools ? [...state.pendingToolEvents] : []
@@ -985,8 +1065,8 @@ const onResponseFinish = (state: ParserState, event: OpenAIResponsesEvent): Step
           })
         : undefined,
   })
-  return [{ ...state, lifecycle, pendingToolEvents: [] }, events]
-}
+  return [{ ...state, lifecycle, pendingToolEvents: [] }, events] satisfies StepResult
+})
 
 // Build a single human-readable message from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
@@ -1043,7 +1123,7 @@ const step = (state: ParserState, event: OpenAIResponsesEvent) => {
   if (event.type === "response.custom_tool_call_input.delta") return onCustomToolCallInputDelta(state, event)
   if (event.type === "response.output_item.done") return onOutputItemDone(state, event)
   if (event.type === "response.completed" || event.type === "response.incomplete")
-    return Effect.succeed(onResponseFinish(state, event))
+    return onResponseFinish(state, event)
   if (event.type === "response.failed") return Effect.succeed(onResponseFailed(state, event))
   if (event.type === "error") return Effect.succeed(onError(state, event))
   return Effect.succeed<StepResult>([state, NO_EVENTS])
@@ -1072,6 +1152,9 @@ export const protocol = Protocol.make({
       lifecycle: Lifecycle.initial(),
       reasoningItems: {},
       store: OpenAIOptions.store(request),
+      jsonFormatName:
+        request.responseFormat?.type === "json" ? (request.responseFormat.name ?? "structured_output") : undefined,
+      accumulatedText: "",
     }),
     step,
     terminal: (event) => TERMINAL_TYPES.has(event.type),
@@ -1119,4 +1202,108 @@ export const webSocketRoute = Route.make({
   transport: webSocketTransport,
 })
 
+// =============================================================================
+// UPD-005: Unary Remote Compaction Client (/responses/compact)
+// =============================================================================
+// OpenAI-only unary endpoint (reference: codex `compact_remote_v2`). The
+// request body mirrors `/responses` minus `stream`; the response is a JSON
+// object whose `output` is the compacted item list — a `compaction` item
+// carries `encrypted_content`, an opaque server-encrypted context blob the
+// caller stages in memory and sends back on the next compaction.
+//
+// This is deliberately NOT part of `Protocol.make`: the protocol abstraction
+// models SSE streams (body → frames → event state machine) and adding a unary
+// axis would ripple protocol.ts / client.ts / transport (>2 files). A local
+// function reusing the existing lowering helpers confines the change here.
+const OpenAIResponsesCompactOutputItem = Schema.Struct({
+  type: Schema.String,
+  id: Schema.optional(Schema.String),
+  encrypted_content: optionalNull(Schema.String),
+})
+
+const OpenAIResponsesCompactResponse = Schema.Struct({
+  output: Schema.Array(OpenAIResponsesCompactOutputItem),
+})
+
+const decodeCompactResponse = ProviderShared.validateWith(
+  Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIResponsesCompactResponse)),
+)
+
+export interface CompactResult {
+  /** Opaque server-encrypted compacted context from the `compaction` item. */
+  readonly encryptedContent: string
+  /** Full compacted output item list (loose shapes) for round-tripping. */
+  readonly output: ReadonlyArray<{
+    readonly type: string
+    readonly id?: string
+    readonly encrypted_content?: string | null
+  }>
+}
+
+/**
+ * Compact a conversation server-side via `POST /responses/compact`. Requires
+ * `RequestExecutor.Service` in the environment. On success returns the
+ * compaction item's `encrypted_content`; on any failure (transport, HTTP ≥
+ * 400, malformed payload, missing compaction item) fails with `LLMError` so
+ * callers can fail over to local summarization. Fails with InvalidRequest
+ * when the request is not bound to this route.
+ */
+export const compactConversation = (
+  input: {
+    readonly request: LLMRequest
+    /** Prior compaction's encrypted context; prepended as a compaction item. */
+    readonly previousEncryptedContent?: string | undefined
+  },
+): Effect.Effect<CompactResult, LLMError, RequestExecutor.Service> =>
+  Effect.gen(function* () {
+  const request = input.request
+  // The compatible-responses route reuses this protocol end-to-end (DeepSeek serves
+  // /responses/compact, verified per UPD-005); capability gating stays in the caller's
+  // per-profile supportsResponsesCompact probe, so both Responses routes are admissible here.
+  if (request.model.route.id !== ADAPTER && request.model.route.id !== "openai-compatible-responses")
+    return yield* invalid(`Remote compaction requires the ${ADAPTER} route (got ${request.model.route.id})`)
+
+  const base = yield* fromRequest(request)
+  // `/responses/compact` is unary: strip `stream`; the compact endpoint takes
+  // no tool choice, and a json_schema text format is meaningless for a
+  // compaction — both are dropped rather than forwarded.
+  const { stream: _stream, tool_choice: _toolChoice, text: _text, ...core } = base
+  const lowered = yield* lowerMessages(request)
+  const compactItem: OpenAIResponsesCompactionItem | undefined = input.previousEncryptedContent
+    ? { type: "compaction", encrypted_content: input.previousEncryptedContent }
+    : undefined
+  const body = {
+    ...core,
+    input: compactItem ? [compactItem, ...lowered] : lowered,
+  }
+
+  const compactEndpoint = Endpoint.merge(request.model.route.endpoint, { path: COMPACT_PATH })
+  const parts = yield* HttpTransport.jsonRequestParts({
+    request,
+    body,
+    endpoint: compactEndpoint,
+    auth: request.model.route.auth,
+    encodeBody: ProviderShared.encodeJson,
+  })
+  const httpRequest = ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers })
+  const response = yield* (yield* RequestExecutor.Service).execute(httpRequest)
+  const rawText = yield* response.text.pipe(
+    Effect.mapError(() =>
+      ProviderShared.eventError(ADAPTER, "Failed to read OpenAI Responses compact response body"),
+    ),
+  )
+  const decoded = yield* decodeCompactResponse(rawText).pipe(
+    Effect.mapError(() =>
+      ProviderShared.eventError(ADAPTER, "OpenAI Responses compact response is not a valid compact payload", rawText),
+    ),
+  )
+  const compaction = decoded.output.find(
+    (item): item is typeof item & { readonly encrypted_content: string } =>
+      item.type === "compaction" && typeof item.encrypted_content === "string" && item.encrypted_content.length > 0,
+  )
+  if (!compaction)
+    return yield* ProviderShared.invalidRequest("OpenAI Responses compact response is missing a compaction item")
+  return { encryptedContent: compaction.encrypted_content, output: decoded.output } satisfies CompactResult
+  })
+
 export * as OpenAIResponses from "./openai-responses"
diff --git a/packages/llm/src/providers/openai-compatible-profile.ts b/packages/llm/src/providers/openai-compatible-profile.ts
index 30770c96..028a5e19 100644
--- a/packages/llm/src/providers/openai-compatible-profile.ts
+++ b/packages/llm/src/providers/openai-compatible-profile.ts
@@ -1,13 +1,43 @@
 export interface OpenAICompatibleProfile {
   readonly provider: string
   readonly baseURL: string
+  /**
+   * The family also serves the OpenAI Responses API (`/responses`). Route
+   * selection branches to the Responses route only when this is true;
+   * everyone else defaults to the Chat route.
+   */
+  readonly supportsResponses?: boolean
+  /**
+   * UPD-005: the family also serves the OpenAI-specific UNARY
+   * `/responses/compact` endpoint. Defaults to false — never assumed for
+   * compatible families without verified support. Canonical OpenAI and DeepSeek
+   * serve it (user-verified 2026-08-18); every other family stays on local
+   * summarization.
+   */
+  readonly supportsResponsesCompact?: boolean
+  /**
+   * UPD-002: the family honors the Responses API `text.format` json_schema
+   * (wire-level structured output). This is the CANONICAL capability
+   * declaration for wire structured output — independent of `supportsResponses`
+   * (a Responses-capable family may still lack constrained text output, so it
+   * is NEVER assumed from Responses support). Defaults to false; opt in per
+   * family only with verified support. No compatible family advertises it
+   * today: deepseek serves Responses but NOT constrained `text.format`.
+   */
+  readonly supportsStructuredTextFormat?: boolean
 }
 
 export const profiles = {
   baseten: { provider: "baseten", baseURL: "https://inference.baseten.co/v1" },
   cerebras: { provider: "cerebras", baseURL: "https://api.cerebras.ai/v1" },
   deepinfra: { provider: "deepinfra", baseURL: "https://api.deepinfra.com/v1/openai" },
-  deepseek: { provider: "deepseek", baseURL: "https://api.deepseek.com/v1" },
+  deepseek: {
+    provider: "deepseek",
+    baseURL: "https://api.deepseek.com/v1",
+    supportsResponses: true,
+    // UPD-005: DeepSeek 官方 API 支持 Responses 的 /responses/compact(用户 2026-08-18 确认)。
+    supportsResponsesCompact: true,
+  },
   fireworks: { provider: "fireworks", baseURL: "https://api.fireworks.ai/inference/v1" },
   groq: { provider: "groq", baseURL: "https://api.groq.com/openai/v1" },
   openrouter: { provider: "openrouter", baseURL: "https://openrouter.ai/api/v1" },
diff --git a/packages/llm/src/providers/openai-compatible.ts b/packages/llm/src/providers/openai-compatible.ts
index a79f65f6..a02c41e4 100644
--- a/packages/llm/src/providers/openai-compatible.ts
+++ b/packages/llm/src/providers/openai-compatible.ts
@@ -1,5 +1,6 @@
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
+import * as OpenAICompatibleResponses from "../protocols/openai-compatible-responses"
 import type { RouteDefaultsInput } from "../route/client"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile"
@@ -17,20 +18,28 @@ export type FamilyModelOptions = RouteDefaultsInput &
     readonly baseURL?: string
   }
 
-export const routes = [OpenAICompatibleChat.route]
+export const routes = [OpenAICompatibleResponses.route, OpenAICompatibleChat.route]
 
 export const configure = (input: GenericModelOptions) => {
   const provider = input.provider ?? "openai-compatible"
   const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
-  const route = OpenAICompatibleChat.route.with({
+  const patch = {
     ...rest,
     provider,
     endpoint: { baseURL },
     auth: AuthOptions.bearer(input, []),
-  })
+  }
+  const chatRoute = OpenAICompatibleChat.route.with(patch)
+  const responsesRoute = OpenAICompatibleResponses.route.with(patch)
+  const chat = (modelID: string | ModelID) =>
+    chatRoute.model({ id: modelID, provider: ProviderID.make(provider) })
+  const responses = (modelID: string | ModelID) =>
+    responsesRoute.model({ id: modelID, provider: ProviderID.make(provider) })
   return {
     id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model({ id: modelID, provider: ProviderID.make(provider) }),
+    model: chat,
+    chat,
+    responses,
     configure,
   }
 }
@@ -45,6 +54,8 @@ const define = (profile: OpenAICompatibleProfile) => {
     return {
       id: ProviderID.make(profile.provider),
       model: facade.model,
+      chat: facade.chat,
+      responses: facade.responses,
       configure: configureProfile,
     }
   }
diff --git a/packages/llm/src/route/executor.ts b/packages/llm/src/route/executor.ts
index 7dd8d70d..303b37c4 100644
--- a/packages/llm/src/route/executor.ts
+++ b/packages/llm/src/route/executor.ts
@@ -20,6 +20,7 @@ import {
   ProviderInternalReason,
   QuotaExceededReason,
   RateLimitReason,
+  TransportPhase,
   TransportReason,
   UnknownProviderReason,
 } from "../schema"
@@ -69,15 +70,38 @@ export function wireRequestHash(input: {
 }
 
 const BODY_LIMIT = 16_384
-const MAX_RETRIES = 2
+const TRANSPORT_RETRY_LIMIT = 2
+const STATUS_RETRY_LIMIT = 2
 const BASE_DELAY_MS = 500
 const MAX_DELAY_MS = 10_000
 const REDACTED = "<redacted>"
 
-/** Per-request transport retry budget. Durable provider attempts override this to zero. */
-export const CurrentRetryLimit = Context.Reference<number>("@deepagent-code/LLM/RequestExecutor/CurrentRetryLimit", {
-  defaultValue: () => MAX_RETRIES,
-})
+/**
+ * Per-request transport retry budget for pre-dispatch connection failures.
+ * Post-dispatch transport errors are never retried (double-billing risk), so
+ * this budget only ever applies to `TransportReason.phase === "pre-dispatch"`.
+ */
+export const CurrentTransportRetryLimit = Context.Reference<number>(
+  "@deepagent-code/LLM/RequestExecutor/CurrentTransportRetryLimit",
+  { defaultValue: () => TRANSPORT_RETRY_LIMIT },
+)
+
+/** Per-request retry budget for retryable HTTP status failures (429 / 5xx). */
+export const CurrentStatusRetryLimit = Context.Reference<number>(
+  "@deepagent-code/LLM/RequestExecutor/CurrentStatusRetryLimit",
+  { defaultValue: () => STATUS_RETRY_LIMIT },
+)
+
+/**
+ * Umbrella override for BOTH retry budgets. Durable provider attempts provide
+ * `0` here (the seal is recomputed before every attempt, so executor-internal
+ * retries would only multiply sealed physical requests). When unset
+ * (`undefined`), the per-class limits above apply independently.
+ */
+export const CurrentRetryLimit = Context.Reference<number | undefined>(
+  "@deepagent-code/LLM/RequestExecutor/CurrentRetryLimit",
+  { defaultValue: () => undefined },
+)
 
 // One source of truth for what counts as a sensitive name across headers,
 // URL query keys, and field names embedded inside request/response bodies.
@@ -389,7 +413,62 @@ const statusError =
       })
     })
 
+// Error codes that prove the request never reached the provider: DNS/TCP
+// connect failures, connection-phase timeouts, and TLS handshake rejections.
+// Anything else (ECONNRESET mid-exchange, header/body timeouts, unknown
+// errors) is ambiguous-or-delivered and classified post-dispatch.
+const PRE_DISPATCH_ERROR_CODES = new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "EADDRNOTAVAIL",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "CERT_HAS_EXPIRED",
+  "CERT_NOT_YET_VALID",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+])
+
+const hasPreDispatchCode = (error: unknown, seen: Set<unknown> = new Set()): boolean => {
+  if (!error || typeof error !== "object" || seen.has(error)) return false
+  seen.add(error)
+  const code = "code" in error ? (error as { readonly code?: unknown }).code : undefined
+  if (typeof code === "string" && PRE_DISPATCH_ERROR_CODES.has(code)) return true
+  const cause = "cause" in error ? (error as { readonly cause?: unknown }).cause : undefined
+  return hasPreDispatchCode(cause, seen)
+}
+
+/**
+ * Classifies a raw transport failure by dispatch phase. The executor only
+ * ever sees failures from `http.execute`, i.e. before response headers, but
+ * fetch cannot tell "connection refused" (nothing sent) from "connection
+ * dropped while awaiting headers" (request possibly delivered and billed).
+ * So pre-dispatch requires positive evidence from the underlying error codes;
+ * every ambiguous case degrades to post-dispatch, which is never retried.
+ */
+const transportPhase = (error: unknown): TransportPhase => {
+  // Effect timeouts carry no dispatch information; the request may already
+  // have been on the wire when the deadline fired.
+  if (!HttpClientError.isHttpClientError(error)) return "post-dispatch"
+  switch (error.reason._tag) {
+    // The request body/URL failed before anything was written to the wire.
+    case "EncodeError":
+    case "InvalidUrlError":
+      return "pre-dispatch"
+    case "TransportError":
+      return hasPreDispatchCode(error.reason.cause) ? "pre-dispatch" : "post-dispatch"
+    default:
+      return "post-dispatch"
+  }
+}
+
 const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: unknown) => {
+  const phase = transportPhase(error)
   const transportError = (input: {
     readonly message: string
     readonly kind?: string | undefined
@@ -401,6 +480,7 @@ const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: u
       reason: new TransportReason({
         message: input.message,
         kind: input.kind,
+        phase,
         url: input.request ? redactUrl(input.request.url) : undefined,
         http: input.request ? new HttpContext({ request: requestDetails(input.request, redactedNames) }) : undefined,
       }),
@@ -435,16 +515,30 @@ const retryDelay = (error: LLMError, attempt: number) => {
   ).pipe(Effect.map((delay) => Math.round(delay)))
 }
 
-const retryStatusFailures = <A, R>(
+const retryFailures = <A, R>(
   effect: Effect.Effect<A, LLMError, R>,
-  retries = MAX_RETRIES,
+  limits: { readonly transport: number; readonly status: number },
+  used: { readonly transport: number; readonly status: number } = { transport: 0, status: 0 },
   attempt = 0,
 ): Effect.Effect<A, LLMError, R> =>
   Effect.catchTag(effect, "LLM.Error", (error): Effect.Effect<A, LLMError, R> => {
-    if (!error.retryable || retries <= 0) return Effect.fail(error)
+    // Transport and status failures consume independent budgets: a flapping
+    // connection must not eat the 429/5xx budget and vice versa. Only
+    // pre-dispatch transport errors are retryable (see TransportReason).
+    const isTransport = error.reason._tag === "Transport"
+    const spent = isTransport ? used.transport : used.status
+    const limit = isTransport ? limits.transport : limits.status
+    if (!error.retryable || spent >= limit) return Effect.fail(error)
     return retryDelay(error, attempt).pipe(
       Effect.flatMap((delay) => Effect.sleep(delay)),
-      Effect.flatMap(() => retryStatusFailures(effect, retries - 1, attempt + 1)),
+      Effect.flatMap(() =>
+        retryFailures(
+          effect,
+          limits,
+          isTransport ? { transport: spent + 1, status: used.status } : { transport: used.transport, status: spent + 1 },
+          attempt + 1,
+        ),
+      ),
     )
   })
 
@@ -463,7 +557,10 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
     return Service.of({
       execute: (request) =>
         Effect.gen(function* () {
-          return yield* retryStatusFailures(executeOnce(request), yield* CurrentRetryLimit)
+          const override = yield* CurrentRetryLimit
+          const transportLimit = override ?? (yield* CurrentTransportRetryLimit)
+          const statusLimit = override ?? (yield* CurrentStatusRetryLimit)
+          return yield* retryFailures(executeOnce(request), { transport: transportLimit, status: statusLimit })
         }),
     })
   }),
diff --git a/packages/llm/src/schema/errors.ts b/packages/llm/src/schema/errors.ts
index 35546ca3..92153ae2 100644
--- a/packages/llm/src/schema/errors.ts
+++ b/packages/llm/src/schema/errors.ts
@@ -4,6 +4,21 @@ import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids"
 export const ProviderFailureClassification = Schema.Literal("context-overflow")
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type
 
+/**
+ * Where a transport failure occurred relative to request dispatch.
+ *
+ * - `pre-dispatch` — the request never reached the provider (DNS/TCP connect
+ *   failure, TLS handshake rejection, request encoding failure). Retrying is
+ *   safe: no physical request can have been billed.
+ * - `post-dispatch` — the request was (or may have been) delivered: response
+ *   headers arrived and the body stream broke, or the failure point is
+ *   ambiguous. Retrying would duplicate the physical request (double
+ *   billing), so these are never auto-retried; recovery belongs to the
+ *   provider-attempt replay channel.
+ */
+export const TransportPhase = Schema.Literals(["pre-dispatch", "post-dispatch"])
+export type TransportPhase = typeof TransportPhase.Type
+
 export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("LLM.HttpRequestDetails")({
   method: Schema.String,
   url: Schema.String,
@@ -123,11 +138,14 @@ export class TransportReason extends Schema.Class<TransportReason>("LLM.Error.Tr
   _tag: Schema.tag("Transport"),
   message: Schema.String,
   kind: Schema.optional(Schema.String),
+  phase: Schema.optional(TransportPhase),
   url: Schema.optional(Schema.String),
   http: Schema.optional(HttpContext),
 }) {
   get retryable() {
-    return false
+    // Only failures proven to predate dispatch are safe to re-send. Absent a
+    // phase (e.g. websocket transport errors) we conservatively refuse.
+    return this.phase === "pre-dispatch"
   }
 }
 
diff --git a/packages/llm/src/schema/messages.ts b/packages/llm/src/schema/messages.ts
index 7c94730f..8858780e 100644
--- a/packages/llm/src/schema/messages.ts
+++ b/packages/llm/src/schema/messages.ts
@@ -394,9 +394,17 @@ export namespace ToolChoice {
   }
 }
 
+// UPD-002: the `json` variant carries wire-level structured-output details.
+// `name`/`strict` map onto OpenAI Responses' `text.format` json_schema shape;
+// they are optional so routes without wire structured output can ignore them.
 export const ResponseFormat = Schema.Union([
   Schema.Struct({ type: Schema.Literal("text") }),
-  Schema.Struct({ type: Schema.Literal("json"), schema: JsonSchema }),
+  Schema.Struct({
+    type: Schema.Literal("json"),
+    schema: JsonSchema,
+    name: Schema.optional(Schema.String),
+    strict: Schema.optional(Schema.Boolean),
+  }),
   Schema.Struct({ type: Schema.Literal("tool"), tool: ToolDefinitionSchema }),
 ]).pipe(Schema.toTaggedUnion("type"))
 export type ResponseFormat = Schema.Schema.Type<typeof ResponseFormat>
diff --git a/packages/llm/test/executor.test.ts b/packages/llm/test/executor.test.ts
index c6951c33..d3e48ef5 100644
--- a/packages/llm/test/executor.test.ts
+++ b/packages/llm/test/executor.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect, Fiber, Layer, Random, Ref } from "effect"
 import * as TestClock from "effect/testing/TestClock"
-import { Headers, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { LLM, LLMError } from "../src"
 import { LLMClient, RequestExecutor } from "../src/route"
 import * as OpenAIChat from "../src/protocols/openai-chat"
@@ -59,6 +59,54 @@ const countedResponsesLayer = (attempts: Ref.Ref<number>, responses: ReadonlyArr
     ),
   )
 
+type ScriptedOutcome =
+  | { readonly kind: "response"; readonly response: Response }
+  | { readonly kind: "transport"; readonly cause: unknown }
+
+// Scripts a mix of successful responses and raw transport failures (the shape
+// FetchHttpClient produces: HttpClientError wrapping a TransportError whose
+// `cause` carries the platform error code) so tests can exercise pre- and
+// post-dispatch classification without real network access.
+const scriptedOutcomesLayer = (attempts: Ref.Ref<number>, outcomes: ReadonlyArray<ScriptedOutcome>) =>
+  RequestExecutor.layer.pipe(
+    Layer.provide(
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const cursor = yield* Ref.make(0)
+          return Layer.succeed(
+            HttpClient.HttpClient,
+            HttpClient.make((request) =>
+              Effect.gen(function* () {
+                yield* Ref.update(attempts, (value) => value + 1)
+                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
+                const outcome = outcomes[index] ?? outcomes[outcomes.length - 1]
+                if (!outcome) return yield* Effect.die(new Error("no scripted outcome"))
+                if (outcome.kind === "transport")
+                  return yield* Effect.fail(
+                    new HttpClientError.HttpClientError({
+                      reason: new HttpClientError.TransportError({ request, cause: outcome.cause }),
+                    }),
+                  )
+                return HttpClientResponse.fromWeb(request, outcome.response)
+              }),
+            ),
+          )
+        }),
+      ),
+    ),
+  )
+
+// TCP connect refused: proves the request never reached the provider.
+const connectRefusedCause = new TypeError("fetch failed", {
+  cause: Object.assign(new Error("connect ECONNREFUSED 10.0.0.1:443"), { code: "ECONNREFUSED" }),
+})
+// Mid-exchange reset: the request may already have been delivered.
+const connectionResetCause = new TypeError("fetch failed", {
+  cause: Object.assign(new Error("read ECONNRESET"), { code: "ECONNRESET" }),
+})
+
+const busy503 = () => new Response("busy", { status: 503, headers: { "retry-after-ms": "0" } })
+
 const randomMidpoint = {
   nextDoubleUnsafe: () => 0.5,
   nextIntUnsafe: () => 0,
@@ -493,6 +541,110 @@ describe("RequestExecutor", () => {
     }).pipe(Effect.provideService(Random.Random, randomMidpoint)),
   )
 
+  it.effect("retries pre-dispatch transport failures up to the transport budget", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      return yield* Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service
+        const fiber = yield* executor.execute(request).pipe(Effect.flip, Effect.forkChild)
+
+        yield* Effect.yieldNow
+        yield* TestClock.adjust(600_000)
+        const error = yield* Fiber.join(fiber)
+
+        expectLLMError(error)
+        expect(error.reason).toMatchObject({ _tag: "Transport", phase: "pre-dispatch" })
+        expect(error.retryable).toBe(true)
+        // 1 initial attempt + 2 transport-budget retries.
+        expect(yield* Ref.get(attempts)).toBe(3)
+      }).pipe(
+        Effect.provide(scriptedOutcomesLayer(attempts, [{ kind: "transport", cause: connectRefusedCause }])),
+      )
+    }),
+  )
+
+  it.effect("does not retry post-dispatch transport failures", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      return yield* Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service
+        const error = yield* executor.execute(request).pipe(Effect.flip)
+
+        expectLLMError(error)
+        expect(error.reason).toMatchObject({ _tag: "Transport", phase: "post-dispatch" })
+        expect(error.retryable).toBe(false)
+        expect(yield* Ref.get(attempts)).toBe(1)
+      }).pipe(
+        Effect.provide(scriptedOutcomesLayer(attempts, [{ kind: "transport", cause: connectionResetCause }])),
+      )
+    }),
+  )
+
+  it.effect("classifies ambiguous transport failures as post-dispatch", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      return yield* Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service
+        const error = yield* executor.execute(request).pipe(Effect.flip)
+
+        expectLLMError(error)
+        expect(error.reason).toMatchObject({ _tag: "Transport", phase: "post-dispatch" })
+        expect(error.retryable).toBe(false)
+        expect(yield* Ref.get(attempts)).toBe(1)
+      }).pipe(
+        Effect.provide(
+          scriptedOutcomesLayer(attempts, [{ kind: "transport", cause: new TypeError("terminated") }]),
+        ),
+      )
+    }),
+  )
+
+  it.effect("tracks transport and status retry budgets independently", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      return yield* Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service
+        const fiber = yield* executor.execute(request).pipe(Effect.forkChild)
+
+        yield* Effect.yieldNow
+        yield* TestClock.adjust(600_000)
+        const response = yield* Fiber.join(fiber)
+
+        // 503 -> ECONNREFUSED -> 503 -> 200: two status retries and one
+        // transport retry succeed because the budgets count independently.
+        // A shared budget of 2 would have stopped after the third attempt.
+        expect(response.status).toBe(200)
+        expect(yield* Ref.get(attempts)).toBe(4)
+      }).pipe(
+        Effect.provide(
+          scriptedOutcomesLayer(attempts, [
+            { kind: "response", response: busy503() },
+            { kind: "transport", cause: connectRefusedCause },
+            { kind: "response", response: busy503() },
+            { kind: "response", response: new Response("ok", { status: 200 }) },
+          ]),
+        ),
+      )
+    }),
+  )
+
+  it.effect("umbrella retry limit zero disables pre-dispatch transport retries", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      return yield* Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service
+        const error = yield* executor.execute(request).pipe(Effect.flip)
+
+        expectLLMError(error)
+        expect(error.reason).toMatchObject({ _tag: "Transport", phase: "pre-dispatch" })
+        expect(yield* Ref.get(attempts)).toBe(1)
+      }).pipe(
+        Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+        Effect.provide(scriptedOutcomesLayer(attempts, [{ kind: "transport", cause: connectRefusedCause }])),
+      )
+    }),
+  )
+
   it.effect("does not retry after a successful response reaches stream parsing", () =>
     Effect.gen(function* () {
       const attempts = yield* Ref.make(0)
diff --git a/packages/llm/test/exports.test.ts b/packages/llm/test/exports.test.ts
index f0d56e0b..66b5ff31 100644
--- a/packages/llm/test/exports.test.ts
+++ b/packages/llm/test/exports.test.ts
@@ -14,7 +14,7 @@ import {
   Google,
 } from "@deepagent-code/llm/providers/compat"
 import * as MainProviders from "@deepagent-code/llm/providers"
-import { OpenAIChat, OpenAICompatibleChat, OpenAIResponses } from "@deepagent-code/llm/protocols"
+import { OpenAIChat, OpenAICompatibleChat, OpenAICompatibleResponses, OpenAIResponses } from "@deepagent-code/llm/protocols"
 import * as AnthropicMessages from "@deepagent-code/llm/protocols/anthropic-messages"
 
 describe("public exports", () => {
@@ -41,6 +41,8 @@ describe("public exports", () => {
     expect(OpenAI.provider.responsesWebSocket).toBe(OpenAI.responsesWebSocket)
     expect(OpenAI.configure({ apiKey: "fixture" }).responses).toBeFunction()
     expect(OpenAICompatible.deepseek.model).toBeFunction()
+    expect(OpenAICompatible.deepseek.responses).toBeFunction()
+    expect(OpenAICompatible.deepseek.chat).toBeFunction()
     expect(Anthropic.model).toBeFunction()
     expect(CloudflareAIGateway.configure).toBeFunction()
     expect(CloudflareAIGateway.configure({ accountId: "fixture", gatewayApiKey: "fixture" }).model).toBeFunction()
@@ -67,6 +69,7 @@ describe("public exports", () => {
   test("protocol barrels expose supported low-level routes", () => {
     expect(OpenAIChat.route.id).toBe("openai-chat")
     expect(OpenAICompatibleChat.route.id).toBe("openai-compatible-chat")
+    expect(OpenAICompatibleResponses.route.id).toBe("openai-compatible-responses")
     expect(OpenAIResponses.route.id).toBe("openai-responses")
     expect(OpenAIResponses.webSocketRoute.id).toBe("openai-responses-websocket")
     expect(AnthropicMessages.route.id).toBe("anthropic-messages")
diff --git a/packages/llm/test/provider/bug407008-reasoning.test.ts b/packages/llm/test/provider/bug407008-reasoning.test.ts
new file mode 100644
index 00000000..4e66ea5d
--- /dev/null
+++ b/packages/llm/test/provider/bug407008-reasoning.test.ts
@@ -0,0 +1,456 @@
+// BUG-407-008 §7.3 — Provider protocol non-regression tests (items 30–34).
+//
+// The BUG-407-008 fix is scoped to App/progress projection; it must not touch
+// provider-side reasoning handling. These tests pin the deterministic
+// input → lowered-provider-request (and response → canonical event) shapes for
+// every reasoning replay mode listed in the spec:
+//
+//   #30 Kimi active continuation: reasoning/tool chain survives lowering verbatim
+//   #31 signed reasoning provider: signature/redacted block order unchanged
+//   #32 encrypted reasoning provider: encrypted content never removed by UI metadata
+//   #33 settled plain reasoning is not re-injected across the terminal boundary
+//   #34 raw reasoning + tool results stay fully parseable for DB/export persistence
+//
+// All assertions are deterministic snapshots: identical inputs must always lower
+// to identical wire shapes, before and after the projection fix.
+
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM, Message, ToolCallPart, ToolDefinition } from "../../src"
+import { Auth, LLMClient } from "../../src/route"
+import * as AnthropicMessages from "../../src/protocols/anthropic-messages"
+import * as OpenAIChat from "../../src/protocols/openai-chat"
+import * as OpenAIResponses from "../../src/protocols/openai-responses"
+import { it } from "../lib/effect"
+import { fixedResponse } from "../lib/http"
+import { sseEvents } from "../lib/sse"
+
+// Kimi-style interleaved reasoning provider: OpenAI-compatible chat route.
+// `reasoningReplayCapability` maps it to `active-continuation`, i.e. plain
+// reasoning is replayed via `reasoning_content` for the active sub-turn.
+const kimiModel = OpenAIChat.route
+  .with({ endpoint: { baseURL: "https://api.moonshot.test/v1/" }, auth: Auth.bearer("test") })
+  .model({ id: "kimi-k2" })
+
+// Signed reasoning provider (Anthropic family): thinking blocks carry a
+// signature; redacted blocks round-trip their opaque blob as the signature.
+const signedModel = AnthropicMessages.route
+  .with({ endpoint: { baseURL: "https://api.anthropic.test/v1/" }, auth: Auth.header("x-api-key", "test") })
+  .model({ id: "claude-sonnet-4-5" })
+
+// Encrypted reasoning provider (OpenAI Responses family): stateless turns
+// (store: false) replay reasoning via `encrypted_content`.
+const encryptedModel = OpenAIResponses.route
+  .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
+  .model({ id: "gpt-5.2" })
+
+// The incident's distinguishing shape: revision 8 and revision 9 emitted
+// verbatim-identical reasoning followed by different tool calls. Replay of the
+// identical text in BOTH sub-turns is legitimate provider history and must not
+// be deduplicated or dropped by lowering.
+const SHARED_REASONING = [
+  "用户在等 w70_stress.py 的四个用户全部打出 FINAL @~950K。",
+  "上一轮已确认 user0 / user1 / user3 三个 FINAL，user2 还没出现。",
+  "需要再次检查 stress log 尾部并确认 w70_stress 进程仍在运行，",
+  "然后再等待 user2 的 FINAL 输出。",
+].join("\n")
+
+const REVISION_8_TOOL_OUTPUT = "user1 FINAL @~950K\nuser0 FINAL @~950K\nuser3 FINAL @~950K\n===PROC===\npython -u /data1/fyl/w70_stress.py"
+const REVISION_9_TOOL_OUTPUT = "user1 FINAL @~950K\nuser0 FINAL @~950K\nuser3 FINAL @~950K"
+
+const bashTool = ToolDefinition.make({
+  name: "bash",
+  description: "Run a shell command.",
+  inputSchema: {
+    type: "object",
+    properties: { command: { type: "string" } },
+    required: ["command"],
+    additionalProperties: false,
+  },
+})
+
+describe("BUG-407-008 §7.3 provider protocol non-regression", () => {
+  it.effect("#30 Kimi active continuation keeps the reasoning/tool chain intact in the lowered request", () =>
+    Effect.gen(function* () {
+      // Deterministic incident-shaped history: two consecutive reasoning-only
+      // sub-turns (revision 8 / 9) with verbatim-identical reasoning and
+      // different tool calls, followed by their tool results.
+      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+        LLM.request({
+          id: "req_bug407008_kimi_active_continuation",
+          model: kimiModel,
+          system: "You are a careful operations assistant.",
+          messages: [
+            Message.user("请你再查询确认一下，是不是四个用户每个用户都有950K的上下文空间。"),
+            Message.assistant([
+              { type: "reasoning", text: SHARED_REASONING },
+              ToolCallPart.make({
+                id: "tool_sd47zQa3WQeOSa1BKPhv6mF1",
+                name: "bash",
+                input: { command: "tail -n 4 stress.log; ps aux | grep w70_stress" },
+              }),
+            ]),
+            Message.tool({
+              id: "tool_sd47zQa3WQeOSa1BKPhv6mF1",
+              name: "bash",
+              result: REVISION_8_TOOL_OUTPUT,
+              resultType: "text",
+            }),
+            Message.assistant([
+              { type: "reasoning", text: SHARED_REASONING },
+              ToolCallPart.make({
+                id: "tool_ZSTCdihDT0jY74tJVeAZLZ45",
+                name: "bash",
+                input: { command: "tail -n 4 stress.log" },
+              }),
+            ]),
+            Message.tool({
+              id: "tool_ZSTCdihDT0jY74tJVeAZLZ45",
+              name: "bash",
+              result: REVISION_9_TOOL_OUTPUT,
+              resultType: "text",
+            }),
+          ],
+          tools: [bashTool],
+          cache: "none",
+        }),
+      )
+
+      // Snapshot of the required reasoning/tool chain: every reasoning payload
+      // verbatim, every tool call paired with its result, order preserved.
+      expect(prepared.body.messages).toEqual([
+        { role: "system", content: "You are a careful operations assistant." },
+        { role: "user", content: "请你再查询确认一下，是不是四个用户每个用户都有950K的上下文空间。" },
+        {
+          role: "assistant",
+          content: null,
+          reasoning_content: SHARED_REASONING,
+          tool_calls: [
+            {
+              id: "tool_sd47zQa3WQeOSa1BKPhv6mF1",
+              type: "function",
+              function: {
+                name: "bash",
+                arguments: '{"command":"tail -n 4 stress.log; ps aux | grep w70_stress"}',
+              },
+            },
+          ],
+        },
+        { role: "tool", tool_call_id: "tool_sd47zQa3WQeOSa1BKPhv6mF1", content: REVISION_8_TOOL_OUTPUT },
+        {
+          role: "assistant",
+          content: null,
+          reasoning_content: SHARED_REASONING,
+          tool_calls: [
+            {
+              id: "tool_ZSTCdihDT0jY74tJVeAZLZ45",
+              type: "function",
+              function: { name: "bash", arguments: '{"command":"tail -n 4 stress.log"}' },
+            },
+          ],
+        },
+        { role: "tool", tool_call_id: "tool_ZSTCdihDT0jY74tJVeAZLZ45", content: REVISION_9_TOOL_OUTPUT },
+      ])
+
+      // The identical reasoning text must be replayed twice — once per
+      // sub-turn. Lowering must never deduplicate cross-turn reasoning.
+      const reasoningPayloads = prepared.body.messages
+        .filter((message) => message.role === "assistant")
+        .map((message) => message.reasoning_content)
+      expect(reasoningPayloads).toEqual([SHARED_REASONING, SHARED_REASONING])
+    }),
+  )
+
+  it.effect("#31 signed reasoning provider preserves signature/redacted block order", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+        LLM.request({
+          id: "req_bug407008_signed_reasoning_order",
+          model: signedModel,
+          messages: [
+            Message.user("Confirm all four users reached 950K."),
+            Message.assistant([
+              {
+                type: "reasoning",
+                text: "rev8: check the stress log tail and the w70_stress process",
+                providerMetadata: { anthropic: { signature: "sig_rev8" } },
+              },
+              ToolCallPart.make({
+                id: "tool_rev8",
+                name: "bash",
+                input: { command: "tail -n 4 stress.log" },
+              }),
+              // Redacted block: opaque provider blob round-trips as the
+              // thinking signature with no visible text.
+              { type: "reasoning", text: "", encrypted: "redacted_blob_rev8" },
+              {
+                type: "reasoning",
+                text: "rev9: poll the stress log again for user2 FINAL",
+                providerMetadata: { anthropic: { signature: "sig_rev9" } },
+              },
+            ]),
+          ],
+          cache: "none",
+        }),
+      )
+
+      // Block order is part of the signed-reasoning contract: lowering must
+      // keep signature and redacted blocks exactly where the parts were.
+      expect(prepared.body.messages).toEqual([
+        { role: "user", content: [{ type: "text", text: "Confirm all four users reached 950K." }] },
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "thinking",
+              thinking: "rev8: check the stress log tail and the w70_stress process",
+              signature: "sig_rev8",
+            },
+            { type: "tool_use", id: "tool_rev8", name: "bash", input: { command: "tail -n 4 stress.log" } },
+            { type: "thinking", thinking: "", signature: "redacted_blob_rev8" },
+            { type: "thinking", thinking: "rev9: poll the stress log again for user2 FINAL", signature: "sig_rev9" },
+          ],
+        },
+      ])
+    }),
+  )
+
+  it.effect("#32 encrypted reasoning content is never removed by App projection metadata", () =>
+    Effect.gen(function* () {
+      // The same provider chain, once without and once with the App-side
+      // computed progress marker attached to the reasoning part. The marker is
+      // a UI/API view only — the lowered provider request must be identical.
+      const chain = (withAppProjection: boolean) => [
+        Message.user("Continue the stress check."),
+        Message.assistant([
+          {
+            type: "reasoning",
+            text: "checking stress log tail",
+            ...(withAppProjection
+              ? {
+                  metadata: {
+                    deepagent_activity_progress: {
+                      activity_id: "a6d06b2a82ef234ab9dc71e3fd940292a21b34f4732f28aa19ba8416c4c5e5a9",
+                      revision: 8,
+                      state: "progress",
+                    },
+                  },
+                }
+              : {}),
+            providerMetadata: {
+              openai: { itemId: "rs_rev8", reasoningEncryptedContent: "encrypted-rev8" },
+            },
+          },
+          ToolCallPart.make({
+            id: "call_rev8",
+            name: "bash",
+            input: { command: "tail -n 4 stress.log" },
+          }),
+        ]),
+        Message.tool({ id: "call_rev8", name: "bash", result: REVISION_8_TOOL_OUTPUT, resultType: "text" }),
+      ]
+      const build = (withAppProjection: boolean) =>
+        LLM.request({
+          id: withAppProjection
+            ? "req_bug407008_encrypted_with_projection"
+            : "req_bug407008_encrypted_without_projection",
+          model: encryptedModel,
+          messages: chain(withAppProjection),
+          tools: [bashTool],
+          cache: "none",
+          providerOptions: { openai: { store: false, include: ["reasoning.encrypted_content"] } },
+        })
+
+      const withoutProjection = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(build(false))
+      const withProjection = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(build(true))
+
+      // App projection metadata must not change the wire request at all.
+      expect(withProjection.body.input).toEqual(withoutProjection.body.input)
+
+      // The encrypted reasoning item survives lowering verbatim, ahead of the
+      // tool chain it belongs to.
+      expect(withProjection.body.input).toEqual([
+        { role: "user", content: [{ type: "input_text", text: "Continue the stress check." }] },
+        {
+          type: "reasoning",
+          id: "rs_rev8",
+          summary: [{ type: "summary_text", text: "checking stress log tail" }],
+          encrypted_content: "encrypted-rev8",
+        },
+        {
+          type: "function_call",
+          call_id: "call_rev8",
+          name: "bash",
+          arguments: '{"command":"tail -n 4 stress.log"}',
+        },
+        { type: "function_call_output", call_id: "call_rev8", output: REVISION_8_TOOL_OUTPUT },
+      ])
+    }),
+  )
+
+  it.effect("#33 settled plain reasoning is not re-injected across the store:false terminal boundary", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+        LLM.request({
+          id: "req_bug407008_terminal_boundary",
+          model: encryptedModel,
+          messages: [
+            Message.assistant([
+              // Audit-only reasoning without any provider state is never
+              // replayed into a new provider request.
+              { type: "reasoning", text: "audit-only reasoning without provider state" },
+              // Settled reasoning item whose encrypted state was not captured:
+              // the terminal boundary filter must not re-inject it.
+              {
+                type: "reasoning",
+                text: "settled plain reasoning from revision 8",
+                providerMetadata: { openai: { itemId: "rs_rev8_plain" } },
+              },
+              // Active reasoning item with encrypted state: replay is allowed.
+              {
+                type: "reasoning",
+                text: "active encrypted reasoning from revision 9",
+                providerMetadata: {
+                  openai: { itemId: "rs_rev9", reasoningEncryptedContent: "encrypted-rev9" },
+                },
+              },
+              ToolCallPart.make({
+                id: "call_rev9",
+                name: "bash",
+                input: { command: "tail -n 4 stress.log" },
+              }),
+            ]),
+            Message.tool({ id: "call_rev9", name: "bash", result: REVISION_9_TOOL_OUTPUT, resultType: "text" }),
+          ],
+          tools: [bashTool],
+          cache: "none",
+          providerOptions: { openai: { store: false, include: ["reasoning.encrypted_content"] } },
+        }),
+      )
+
+      // The boundary keeps exactly the encrypted reasoning item plus the intact
+      // tool chain; nothing plain or stateless sneaks back into the request.
+      expect(prepared.body.input).toEqual([
+        {
+          type: "reasoning",
+          id: "rs_rev9",
+          summary: [{ type: "summary_text", text: "active encrypted reasoning from revision 9" }],
+          encrypted_content: "encrypted-rev9",
+        },
+        {
+          type: "function_call",
+          call_id: "call_rev9",
+          name: "bash",
+          arguments: '{"command":"tail -n 4 stress.log"}',
+        },
+        { type: "function_call_output", call_id: "call_rev9", output: REVISION_9_TOOL_OUTPUT },
+      ])
+
+      const reasoningItems = prepared.body.input.filter(
+        (item) => "type" in item && item.type === "reasoning",
+      )
+      expect(reasoningItems).toHaveLength(1)
+      expect(prepared.body.input.some((item) => "id" in item && item.id === "rs_rev8_plain")).toBe(false)
+    }),
+  )
+
+  it.effect("#34 parser keeps full raw reasoning text and tool results for DB/export persistence", () =>
+    Effect.gen(function* () {
+      // One deterministic stream per provider sub-turn (revision 8 / 9), both
+      // carrying the verbatim-identical reasoning and their own tool call.
+      // This is the llm-side half of the invariant: every raw provider token
+      // must reach canonical events untouched so persistence/export can store
+      // it. (Actual DB/export reads live in packages/deepagent-code.)
+      const revisionStream = (input: { itemID: string; callID: string; command: string }) => {
+        const args = JSON.stringify({ command: input.command })
+        return sseEvents(
+          { type: "response.output_item.added", item: { type: "reasoning", id: input.itemID, encrypted_content: null } },
+          { type: "response.reasoning_summary_part.added", item_id: input.itemID, summary_index: 0 },
+          { type: "response.reasoning_summary_text.delta", item_id: input.itemID, summary_index: 0, delta: SHARED_REASONING },
+          { type: "response.reasoning_summary_part.done", item_id: input.itemID, summary_index: 0 },
+          {
+            type: "response.output_item.done",
+            item: { type: "reasoning", id: input.itemID, encrypted_content: `enc_${input.itemID}` },
+          },
+          {
+            type: "response.output_item.added",
+            item: { type: "function_call", id: `fc_${input.callID}`, call_id: input.callID, name: "bash", arguments: "" },
+          },
+          { type: "response.function_call_arguments.delta", item_id: `fc_${input.callID}`, delta: args },
+          { type: "response.function_call_arguments.done", item_id: `fc_${input.callID}`, arguments: args },
+          {
+            type: "response.output_item.done",
+            item: {
+              type: "function_call",
+              id: `fc_${input.callID}`,
+              call_id: input.callID,
+              name: "bash",
+              arguments: args,
+            },
+          },
+          {
+            type: "response.completed",
+            response: { id: `resp_${input.itemID}`, usage: { input_tokens: 10, output_tokens: 5 } },
+          },
+        )
+      }
+      const turnRequest = (id: string) =>
+        LLM.request({
+          id,
+          model: encryptedModel,
+          prompt: "Continue the stress check.",
+          tools: [bashTool],
+          providerOptions: { openai: { store: false, include: ["reasoning.encrypted_content"] } },
+        })
+
+      const revision8 = yield* LLMClient.generate(turnRequest("req_bug407008_raw_rev8")).pipe(
+        Effect.provide(
+          fixedResponse(revisionStream({ itemID: "rs_rev8", callID: "call_rev8", command: "tail stress.log; ps aux" })),
+        ),
+      )
+      const revision9 = yield* LLMClient.generate(turnRequest("req_bug407008_raw_rev9")).pipe(
+        Effect.provide(
+          fixedResponse(revisionStream({ itemID: "rs_rev9", callID: "call_rev9", command: "tail stress.log" })),
+        ),
+      )
+
+      // Full raw reasoning text survives parsing in BOTH revisions — identical
+      // content is not merged, truncated, or dropped on the parse side.
+      expect(revision8.reasoning).toBe(SHARED_REASONING)
+      expect(revision9.reasoning).toBe(SHARED_REASONING)
+
+      // Replay state (encrypted content + item id) needed for later turns is
+      // attached to the reasoning events of each revision.
+      expect(revision8.events).toContainEqual(
+        expect.objectContaining({
+          type: "reasoning-end",
+          id: "rs_rev8:0",
+          providerMetadata: { openai: { itemId: "rs_rev8", reasoningEncryptedContent: "enc_rs_rev8" } },
+        }),
+      )
+      expect(revision9.events).toContainEqual(
+        expect.objectContaining({
+          type: "reasoning-end",
+          id: "rs_rev9:0",
+          providerMetadata: { openai: { itemId: "rs_rev9", reasoningEncryptedContent: "enc_rs_rev9" } },
+        }),
+      )
+
+      // Raw tool inputs stay complete and distinct per revision.
+      const toolCall8 = revision8.events.find((event) => event.type === "tool-call")
+      const toolCall9 = revision9.events.find((event) => event.type === "tool-call")
+      expect(toolCall8).toMatchObject({
+        type: "tool-call",
+        id: "call_rev8",
+        name: "bash",
+        input: { command: "tail stress.log; ps aux" },
+      })
+      expect(toolCall9).toMatchObject({
+        type: "tool-call",
+        id: "call_rev9",
+        name: "bash",
+        input: { command: "tail stress.log" },
+      })
+    }),
+  )
+})
diff --git a/packages/llm/test/provider/openai-compatible-responses.test.ts b/packages/llm/test/provider/openai-compatible-responses.test.ts
new file mode 100644
index 00000000..deeb582f
--- /dev/null
+++ b/packages/llm/test/provider/openai-compatible-responses.test.ts
@@ -0,0 +1,145 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Schema } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+import { LLM } from "../../src"
+import { Auth, LLMClient } from "../../src/route"
+import * as OpenAICompatible from "../../src/providers/openai-compatible"
+import { byProvider, profiles } from "../../src/providers/openai-compatible-profile"
+import * as OpenAICompatibleResponses from "../../src/protocols/openai-compatible-responses"
+import { it } from "../lib/effect"
+import { dynamicResponse } from "../lib/http"
+import { sseEvents } from "../lib/sse"
+
+const Json = Schema.fromJsonString(Schema.Unknown)
+const decodeJson = Schema.decodeUnknownSync(Json)
+
+const model = OpenAICompatibleResponses.route
+  .with({
+    provider: "deepseek",
+    endpoint: { baseURL: "https://api.deepseek.test/v1/" },
+    auth: Auth.bearer("test-key"),
+  })
+  .model({ id: "deepseek-reasoner" })
+
+const request = LLM.request({
+  id: "req_1",
+  model,
+  system: "You are concise.",
+  prompt: "Say hello.",
+  generation: { maxTokens: 20, temperature: 0 },
+})
+
+describe("OpenAI-compatible Responses route", () => {
+  it.effect("prepares a Responses body owned by the deepseek route, not openai", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare(request)
+
+      expect(prepared.route).toBe("openai-compatible-responses")
+      expect(prepared.protocol).toBe("openai-responses")
+      expect(prepared.model).toMatchObject({
+        id: "deepseek-reasoner",
+        provider: "deepseek",
+        route: { id: "openai-compatible-responses" },
+      })
+      expect(prepared.model.provider).not.toBe("openai")
+      expect(prepared.body).toEqual({
+        model: "deepseek-reasoner",
+        input: [
+          { role: "system", content: "You are concise." },
+          { role: "user", content: [{ type: "input_text", text: "Say hello." }] },
+        ],
+        stream: true,
+        max_output_tokens: 20,
+        temperature: 0,
+      })
+      expect(prepared.body).not.toHaveProperty("include")
+      expect(prepared.body).not.toHaveProperty("store")
+    }),
+  )
+
+  it.effect("never emits include/store for non-openai providerOptions keys", () =>
+    Effect.gen(function* () {
+      // DeepSeek's Responses compatibility set has not been proven to support
+      // encrypted reasoning, so include/store must never reach the wire. The
+      // shared protocol lowerOptions only reads `providerOptions.openai`, and
+      // compatible families key their options under their own provider id.
+      const prepared = yield* LLMClient.prepare(
+        LLM.updateRequest(request, {
+          providerOptions: { deepseek: { store: false, include: ["reasoning.encrypted_content"] } },
+        }),
+      )
+      expect(prepared.body).not.toHaveProperty("include")
+      expect(prepared.body).not.toHaveProperty("store")
+      expect(prepared.body).not.toHaveProperty("reasoning")
+    }),
+  )
+
+  it.effect("exposes chat and responses factories per compatible family", () =>
+    Effect.gen(function* () {
+      const deepseek = OpenAICompatible.deepseek.configure({ apiKey: "test-key" })
+      expect(deepseek.responses("deepseek-reasoner")).toMatchObject({
+        id: "deepseek-reasoner",
+        provider: "deepseek",
+        route: { id: "openai-compatible-responses" },
+      })
+      expect(deepseek.responses("deepseek-reasoner").route.endpoint.baseURL).toBe("https://api.deepseek.com/v1")
+      expect(deepseek.chat("deepseek-chat").route.id).toBe("openai-compatible-chat")
+      expect(deepseek.model("deepseek-chat").route.id).toBe("openai-compatible-chat")
+
+      const groq = OpenAICompatible.groq.configure({ apiKey: "test-key" })
+      expect(groq.model("llama-3.3-70b").route.id).toBe("openai-compatible-chat")
+
+      const generic = OpenAICompatible.configure({
+        provider: "custom",
+        baseURL: "https://custom.example.test/v1",
+        apiKey: "test-key",
+      })
+      expect(generic.responses("any-model")).toMatchObject({
+        provider: "custom",
+        route: { id: "openai-compatible-responses" },
+      })
+    }),
+  )
+
+  test("declares Responses capability only for deepseek profiles", () => {
+    expect(profiles.deepseek.supportsResponses).toBe(true)
+    for (const profile of Object.values(byProvider)) {
+      if (profile.provider === "deepseek") continue
+      expect(profile.supportsResponses ?? false).toBe(false)
+    }
+    expect(byProvider["deepseek"]?.supportsResponses).toBe(true)
+    expect(byProvider["groq"]?.supportsResponses).toBeUndefined()
+  })
+
+  it.effect("posts to the configured /responses endpoint and parses the stream", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          dynamicResponse((input) =>
+            Effect.gen(function* () {
+              const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
+              expect(web.url).toBe("https://api.deepseek.test/v1/responses")
+              expect(web.headers.get("authorization")).toBe("Bearer test-key")
+              expect(decodeJson(input.text)).toMatchObject({ model: "deepseek-reasoner", stream: true })
+              return input.respond(
+                sseEvents(
+                  { type: "response.output_text.delta", item_id: "msg_1", delta: "Hello" },
+                  { type: "response.output_text.delta", item_id: "msg_1", delta: "!" },
+                  {
+                    type: "response.completed",
+                    response: { id: "resp_1", usage: { input_tokens: 5, output_tokens: 2, total_tokens: 7 } },
+                  },
+                ),
+                { headers: { "content-type": "text/event-stream" } },
+              )
+            }),
+          ),
+        ),
+      )
+
+      expect(response.text).toBe("Hello!")
+      expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
+    }),
+  )
+})
diff --git a/packages/llm/test/provider/openai-responses-compact.test.ts b/packages/llm/test/provider/openai-responses-compact.test.ts
new file mode 100644
index 00000000..d984cb89
--- /dev/null
+++ b/packages/llm/test/provider/openai-responses-compact.test.ts
@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+import { LLM, LLMError } from "../../src"
+import { Auth, RequestExecutor } from "../../src/route"
+import * as OpenAIChat from "../../src/protocols/openai-chat"
+import * as OpenAIResponses from "../../src/protocols/openai-responses"
+import { byProvider as OpenAICompatibleProfiles, type OpenAICompatibleProfile } from "../../src/providers/openai-compatible-profile"
+import { it } from "../lib/effect"
+import { dynamicResponse, fixedResponse } from "../lib/http"
+
+const JSON_HEADERS = { "content-type": "application/json" } as const
+
+const model = OpenAIResponses.route
+  .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
+  .model({ id: "gpt-4.1-mini" })
+
+const request = LLM.request({
+  id: "req_compact",
+  model,
+  system: "You are concise.",
+  prompt: "Summarize this session.",
+  generation: { maxTokens: 20, temperature: 0 },
+})
+
+const compactBody = (encryptedContent = "enc-blob") =>
+  JSON.stringify({ output: [{ type: "compaction", id: "cmp_1", encrypted_content: encryptedContent }] })
+
+// Unary compaction must never consume a status-retry budget: a failed compact
+// should fail over to local summarization immediately, not burn retries.
+// Applied inside each pipe exactly like executor.test.ts does.
+
+const readBody = (request: HttpClientRequest.HttpClientRequest) =>
+  HttpClientRequest.toWeb(request).pipe(
+    Effect.orDie,
+    Effect.flatMap((web) => Effect.promise(() => web.json())),
+  )
+
+describe("OpenAI Responses unary compaction (/responses/compact)", () => {
+  it.effect("posts a unary compact request with the stream field stripped", () =>
+    OpenAIResponses.compactConversation({ request }).pipe(
+      Effect.provide(
+        dynamicResponse((input) =>
+          Effect.gen(function* () {
+            const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
+            expect(web.url).toBe("https://api.openai.test/v1/responses/compact")
+            expect(web.method).toBe("POST")
+            expect(web.headers.get("content-type")).toBe("application/json")
+            const body = (yield* Effect.promise(() => web.json())) as Record<string, unknown>
+            expect(body.model).toBe("gpt-4.1-mini")
+            expect(body.stream).toBeUndefined()
+            expect(body.tool_choice).toBeUndefined()
+            expect(body.input).toEqual([
+              { role: "system", content: "You are concise." },
+              { role: "user", content: [{ type: "input_text", text: "Summarize this session." }] },
+            ])
+            return input.respond(compactBody(), { headers: JSON_HEADERS })
+          }),
+        ),
+      ),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+    ),
+  )
+
+  it.effect("prepends the prior compaction item when previousEncryptedContent is staged", () =>
+    OpenAIResponses.compactConversation({ request, previousEncryptedContent: "prior-enc" }).pipe(
+      Effect.provide(
+        dynamicResponse((input) =>
+          Effect.gen(function* () {
+            const body = (yield* readBody(input.request)) as Record<string, unknown>
+            const inputItems = body.input as ReadonlyArray<Record<string, unknown>>
+            expect(inputItems[0]).toEqual({ type: "compaction", encrypted_content: "prior-enc" })
+            expect(inputItems[1]).toEqual({ role: "system", content: "You are concise." })
+            return input.respond(compactBody("enc-blob-2"), { headers: JSON_HEADERS })
+          }),
+        ),
+      ),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+    ),
+  )
+
+  it.effect("parses the compact response and surfaces the encrypted context", () =>
+    OpenAIResponses.compactConversation({ request }).pipe(
+      Effect.provide(fixedResponse(compactBody("enc-abc"), { headers: JSON_HEADERS })),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.encryptedContent).toBe("enc-abc")
+          expect(result.output).toEqual([{ type: "compaction", id: "cmp_1", encrypted_content: "enc-abc" }])
+        }),
+      ),
+    ),
+  )
+
+  it.effect("round-trips encrypted_content across successive compactions", () =>
+    Effect.gen(function* () {
+      const first = yield* OpenAIResponses.compactConversation({ request }).pipe(
+        Effect.provide(fixedResponse(compactBody("enc-round-1"), { headers: JSON_HEADERS })),
+        Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      )
+      expect(first.encryptedContent).toBe("enc-round-1")
+      const second = yield* OpenAIResponses.compactConversation({
+        request,
+        previousEncryptedContent: first.encryptedContent,
+      }).pipe(
+        Effect.provide(
+          dynamicResponse((input) =>
+            Effect.gen(function* () {
+              const body = (yield* readBody(input.request)) as Record<string, unknown>
+              expect((body.input as ReadonlyArray<Record<string, unknown>>)[0]).toEqual({
+                type: "compaction",
+                encrypted_content: "enc-round-1",
+              })
+              return input.respond(compactBody("enc-round-2"), { headers: JSON_HEADERS })
+            }),
+          ),
+        ),
+        Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      )
+      expect(second.encryptedContent).toBe("enc-round-2")
+    }),
+  )
+
+  it.effect("fails when the response carries no compaction item (local fail-over signal)", () =>
+    OpenAIResponses.compactConversation({ request }).pipe(
+      Effect.provide(fixedResponse(JSON.stringify({ output: [] }), { headers: JSON_HEADERS })),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      Effect.flip,
+      Effect.tap((error) =>
+        Effect.sync(() => {
+          expect(error).toBeInstanceOf(LLMError)
+          expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
+        }),
+      ),
+    ),
+  )
+
+  it.effect("fails on a malformed compact payload (local fail-over signal)", () =>
+    OpenAIResponses.compactConversation({ request }).pipe(
+      Effect.provide(fixedResponse("not-json", { headers: JSON_HEADERS })),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      Effect.flip,
+      Effect.tap((error) =>
+        Effect.sync(() => {
+          expect(error).toBeInstanceOf(LLMError)
+        }),
+      ),
+    ),
+  )
+
+  it.effect("fails on provider HTTP errors (local fail-over signal)", () =>
+    OpenAIResponses.compactConversation({ request }).pipe(
+      Effect.provide(fixedResponse(JSON.stringify({ error: "boom" }), { status: 500, headers: JSON_HEADERS })),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      Effect.flip,
+      Effect.tap((error) =>
+        Effect.sync(() => {
+          expect(error).toBeInstanceOf(LLMError)
+          expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
+        }),
+      ),
+    ),
+  )
+
+  it.effect("rejects requests bound to a non-responses route", () =>
+    OpenAIResponses.compactConversation({
+      request: LLM.request({
+        id: "req_chat",
+        model: OpenAIChat.route.model({ id: "gpt-4.1-mini" }),
+        prompt: "hi",
+      }),
+    }).pipe(
+      // The route check fails before any HTTP happens; the layer only exists
+      // to satisfy the environment requirement.
+      Effect.provide(fixedResponse("unused", { headers: JSON_HEADERS })),
+      Effect.provideService(RequestExecutor.CurrentRetryLimit, 0),
+      Effect.flip,
+      Effect.tap((error) =>
+        Effect.sync(() => {
+          expect(error).toBeInstanceOf(LLMError)
+          expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
+        }),
+      ),
+    ),
+  )
+})
+
+describe("remote compaction capability flags", () => {
+  test("exposes compact support on the OpenAI Responses protocol", () => {
+    expect(OpenAIResponses.supportsRemoteCompaction).toBe(true)
+    expect(OpenAIResponses.COMPACT_PATH).toBe("/responses/compact")
+  })
+
+  test("only verified opt-ins assume compact support among OpenAI-compatible families", () => {
+    // 2026-08-18 用户决策:DeepSeek 官方 API 支持 /responses/compact,为已验证 opt-in;
+    // 其余 openai-compatible 家族(含 vLLM/SGLang 类)永不默认假设。
+    expect(OpenAICompatibleProfiles["deepseek"]?.supportsResponsesCompact).toBe(true)
+    for (const [provider, profile] of Object.entries(OpenAICompatibleProfiles)) {
+      if (provider === "deepseek") continue
+      expect((profile as OpenAICompatibleProfile).supportsResponsesCompact ?? false).toBe(false)
+    }
+  })
+})
diff --git a/packages/llm/test/provider/openai-responses.test.ts b/packages/llm/test/provider/openai-responses.test.ts
index 55c5e09f..947a483a 100644
--- a/packages/llm/test/provider/openai-responses.test.ts
+++ b/packages/llm/test/provider/openai-responses.test.ts
@@ -1638,3 +1638,86 @@ describe("OpenAI Responses route", () => {
     }),
   )
 })
+
+// UPD-002: wire-level structured output (text.format json_schema).
+describe("OpenAI Responses wire structured output", () => {
+  const wireSchema = {
+    type: "object",
+    properties: { answer: { type: "number" } },
+    required: ["answer"],
+  }
+  const wireRequest = LLM.updateRequest(request, {
+    responseFormat: { type: "json", schema: wireSchema, name: "answer_format" },
+  })
+
+  it.effect("lowers responseFormat json onto text.format", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(wireRequest)
+
+      expect(prepared.body.text).toEqual({
+        format: { type: "json_schema", name: "answer_format", schema: wireSchema },
+      })
+    }),
+  )
+
+  it.effect("defaults the format name and keeps strict opt-in absent", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+        LLM.updateRequest(request, { responseFormat: { type: "json", schema: wireSchema } }),
+      )
+
+      expect(prepared.body.text?.format).toEqual({ type: "json_schema", name: "structured_output", schema: wireSchema })
+      expect(prepared.body.text?.format).not.toHaveProperty("strict")
+    }),
+  )
+
+  it.effect("omits text.format without a json responseFormat", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(request)
+
+      expect(prepared.body).not.toHaveProperty("text")
+    }),
+  )
+
+  it.effect("accepts well-formed JSON output under wire format", () =>
+    Effect.gen(function* () {
+      const body = sseEvents(
+        { type: "response.output_text.delta", item_id: "msg_1", delta: '{"ans' },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: 'wer": 4}' },
+        { type: "response.completed", response: { id: "resp_wire" } },
+      )
+      const response = yield* LLMClient.generate(wireRequest).pipe(Effect.provide(fixedResponse(body)))
+
+      const text = response.events.filter((event) => event.type.startsWith("text"))
+      expect(text.length).toBeGreaterThan(0)
+      expect(response.events.some((event) => event.type === "finish")).toBe(true)
+    }),
+  )
+
+  it.effect("fails with InvalidProviderOutput when wire output is not JSON", () =>
+    Effect.gen(function* () {
+      const body = sseEvents(
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Sure! The answer is " },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "four." },
+        { type: "response.completed", response: { id: "resp_wire_bad" } },
+      )
+      const error = yield* LLMClient.generate(wireRequest).pipe(Effect.provide(fixedResponse(body)), Effect.flip)
+
+      expect(error).toBeInstanceOf(LLMError)
+      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput" })
+      expect(error.message).toContain("not valid JSON")
+    }),
+  )
+
+  it.effect("does not validate text as JSON without a wire format", () =>
+    Effect.gen(function* () {
+      const body = sseEvents(
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "plain prose" },
+        { type: "response.completed", response: { id: "resp_plain" } },
+      )
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
+
+      expect(response.events.some((event) => event.type === "finish")).toBe(true)
+    }),
+  )
+})
diff --git a/packages/sdk/js/src/gen/sdk.gen.ts b/packages/sdk/js/src/gen/sdk.gen.ts
index a62ef350..8288d50f 100644
--- a/packages/sdk/js/src/gen/sdk.gen.ts
+++ b/packages/sdk/js/src/gen/sdk.gen.ts
@@ -381,6 +381,8 @@ import type {
   SessionCommandResponses,
   SessionContextAttemptResolveErrors,
   SessionContextAttemptResolveResponses,
+  SessionContextCohortErrors,
+  SessionContextCohortResponses,
   SessionContextDiagnosticsErrors,
   SessionContextDiagnosticsResponses,
   SessionCreateErrors,
@@ -395,10 +397,14 @@ import type {
   SessionDiffArtifactManifestResponses,
   SessionDiffErrors,
   SessionDiffResponses,
+  SessionExportSnapshotErrors,
+  SessionExportSnapshotResponses,
   SessionForkErrors,
   SessionForkResponses,
   SessionGetErrors,
   SessionGetResponses,
+  SessionImportSnapshotErrors,
+  SessionImportSnapshotResponses,
   SessionInitErrors,
   SessionInitResponses,
   SessionListErrors,
@@ -8483,6 +8489,44 @@ export class Session2 extends HeyApiClient {
     })
   }
 
+  /**
+   * Aggregate federated context selections across sessions
+   *
+   * FEAT-005: durable cohort aggregation over [sinceMs, untilMs], bucketed by readiness (ready/building/degraded/blocked) so rollout decisions are not skewed by cold-start noise.
+   */
+  public contextCohort<ThrowOnError extends boolean = false>(
+    parameters: {
+      directory?: string
+      workspace?: string
+      sinceMs: string
+      untilMs?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "sinceMs" },
+            { in: "query", key: "untilMs" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).get<
+      SessionContextCohortResponses,
+      SessionContextCohortErrors,
+      ThrowOnError
+    >({
+      url: "/session/context/cohort",
+      ...options,
+      ...params,
+    })
+  }
+
   /**
    * List provider recovery decisions
    *
@@ -8578,6 +8622,57 @@ export class Session2 extends HeyApiClient {
       },
     })
   }
+
+  /**
+   * Export a session snapshot
+   *
+   * Export the session's conversation (session + messages + parts) as a self-describing snapshot bundle (JSON). The bundle re-imports on another device as a fresh, continuable session.
+   */
+  public exportSnapshot<ThrowOnError extends boolean = false>(
+    parameters: {
+      sessionID: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }])
+    return (options?.client ?? this.client).get<
+      SessionExportSnapshotResponses,
+      SessionExportSnapshotErrors,
+      ThrowOnError
+    >({
+      url: "/session/{sessionID}/export",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Import a session snapshot
+   *
+   * Import a previously exported session bundle into the current instance as a fresh, continuable session (new IDs, re-rooted to the current project/directory).
+   */
+  public importSnapshot<ThrowOnError extends boolean = false>(
+    parameters: {
+      bundle: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "body", key: "bundle" }] }])
+    return (options?.client ?? this.client).post<
+      SessionImportSnapshotResponses,
+      SessionImportSnapshotErrors,
+      ThrowOnError
+    >({
+      url: "/session/import-snapshot",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
 }
 
 export class Part extends HeyApiClient {
diff --git a/packages/sdk/js/src/gen/types.gen.ts b/packages/sdk/js/src/gen/types.gen.ts
index 8582e1fe..3596df6f 100644
--- a/packages/sdk/js/src/gen/types.gen.ts
+++ b/packages/sdk/js/src/gen/types.gen.ts
@@ -92,11 +92,11 @@ export type Event =
   | EventSessionIdle
   | EventSessionCompacted
   | EventPlanUpdated
+  | EventGoalUpdated
   | EventDebugStopped
   | EventDebugOutput
   | EventDebugTerminated
   | EventDebugUpdated
-  | EventGoalUpdated
   | EventVcsBranchUpdated
   | EventWorkspaceReady
   | EventWorkspaceFailed
@@ -1797,6 +1797,24 @@ export type GlobalEvent = {
           changes?: Array<string>
         }
       }
+    | {
+        id: string
+        type: "goal.updated"
+        properties: {
+          sessionID: string
+          goalId: string
+          planDocId: string
+          phase: string
+          ledger: {
+            ticks: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+            tokens: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+            cost: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+            wallclockMs: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+          }
+          stallCount: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+          gaps: Array<string>
+        }
+      }
     | {
         id: string
         type: "debug.stopped"
@@ -1830,24 +1848,6 @@ export type GlobalEvent = {
           status: string
         }
       }
-    | {
-        id: string
-        type: "goal.updated"
-        properties: {
-          sessionID: string
-          goalId: string
-          planDocId: string
-          phase: string
-          ledger: {
-            ticks: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-            tokens: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-            cost: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-            wallclockMs: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-          }
-          stallCount: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-          gaps: Array<string>
-        }
-      }
     | {
         id: string
         type: "vcs.branch.updated"
@@ -2201,6 +2201,7 @@ export type ProviderConfig = {
           [key: string]: unknown
         }
       }
+      disabled?: boolean
     }
   }
   groups?: {
@@ -6993,6 +6994,25 @@ export type EventPlanUpdated = {
   }
 }
 
+export type EventGoalUpdated = {
+  id: string
+  type: "goal.updated"
+  properties: {
+    sessionID: string
+    goalId: string
+    planDocId: string
+    phase: string
+    ledger: {
+      ticks: number | "NaN" | "Infinity" | "-Infinity"
+      tokens: number | "NaN" | "Infinity" | "-Infinity"
+      cost: number | "NaN" | "Infinity" | "-Infinity"
+      wallclockMs: number | "NaN" | "Infinity" | "-Infinity"
+    }
+    stallCount: number | "NaN" | "Infinity" | "-Infinity"
+    gaps: Array<string>
+  }
+}
+
 export type EventDebugStopped = {
   id: string
   type: "debug.stopped"
@@ -7030,25 +7050,6 @@ export type EventDebugUpdated = {
   }
 }
 
-export type EventGoalUpdated = {
-  id: string
-  type: "goal.updated"
-  properties: {
-    sessionID: string
-    goalId: string
-    planDocId: string
-    phase: string
-    ledger: {
-      ticks: number | "NaN" | "Infinity" | "-Infinity"
-      tokens: number | "NaN" | "Infinity" | "-Infinity"
-      cost: number | "NaN" | "Infinity" | "-Infinity"
-      wallclockMs: number | "NaN" | "Infinity" | "-Infinity"
-    }
-    stallCount: number | "NaN" | "Infinity" | "-Infinity"
-    gaps: Array<string>
-  }
-}
-
 export type EventVcsBranchUpdated = {
   id: string
   type: "vcs.branch.updated"
@@ -15380,6 +15381,72 @@ export type SessionContextAttemptResolveResponses = {
 export type SessionContextAttemptResolveResponse =
   SessionContextAttemptResolveResponses[keyof SessionContextAttemptResolveResponses]
 
+export type SessionContextCohortData = {
+  body?: never
+  path?: never
+  query: {
+    directory?: string
+    workspace?: string
+    sinceMs: string
+    untilMs?: string
+  }
+  url: "/session/context/cohort"
+}
+
+export type SessionContextCohortErrors = {
+  /**
+   * BadRequest | InvalidRequestError
+   */
+  400: EffectHttpApiErrorBadRequest | InvalidRequestError
+}
+
+export type SessionContextCohortError = SessionContextCohortErrors[keyof SessionContextCohortErrors]
+
+export type SessionContextCohortResponses = {
+  /**
+   * Cohort-level federated context aggregation
+   */
+  200: {
+    window: {
+      sinceMs: number
+      untilMs: number
+    }
+    selections: number
+    sessions: number
+    tokens: number
+    readiness: {
+      ready: number
+      building: number
+      degraded: number
+      blocked: number
+    }
+    graphs: {
+      code: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+      knowledge: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+      memory: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+      documents: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+    }
+  }
+}
+
+export type SessionContextCohortResponse = SessionContextCohortResponses[keyof SessionContextCohortResponses]
+
 export type SessionProviderResolutionListData = {
   body?: never
   path: {
@@ -15485,6 +15552,68 @@ export type SessionProviderResolutionResolveResponses = {
 export type SessionProviderResolutionResolveResponse =
   SessionProviderResolutionResolveResponses[keyof SessionProviderResolutionResolveResponses]
 
+export type SessionExportSnapshotData = {
+  body?: never
+  path: {
+    sessionID: string
+  }
+  query?: never
+  url: "/session/{sessionID}/export"
+}
+
+export type SessionExportSnapshotErrors = {
+  /**
+   * BadRequest | InvalidRequestError
+   */
+  400: EffectHttpApiErrorBadRequest | InvalidRequestError
+  /**
+   * NotFoundError
+   */
+  404: NotFoundError
+}
+
+export type SessionExportSnapshotError = SessionExportSnapshotErrors[keyof SessionExportSnapshotErrors]
+
+export type SessionExportSnapshotResponses = {
+  /**
+   * Session snapshot bundle as a JSON string
+   */
+  200: string
+}
+
+export type SessionExportSnapshotResponse = SessionExportSnapshotResponses[keyof SessionExportSnapshotResponses]
+
+export type SessionImportSnapshotData = {
+  body?: {
+    bundle: string
+  }
+  path?: never
+  query?: never
+  url: "/session/import-snapshot"
+}
+
+export type SessionImportSnapshotErrors = {
+  /**
+   * BadRequest | InvalidRequestError
+   */
+  400: EffectHttpApiErrorBadRequest | InvalidRequestError
+}
+
+export type SessionImportSnapshotError = SessionImportSnapshotErrors[keyof SessionImportSnapshotErrors]
+
+export type SessionImportSnapshotResponses = {
+  /**
+   * Imported session summary
+   */
+  200: {
+    sessionID: string
+    messages: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+    parts: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+  }
+}
+
+export type SessionImportSnapshotResponse = SessionImportSnapshotResponses[keyof SessionImportSnapshotResponses]
+
 export type SyncStartData = {
   body?: never
   path?: never
diff --git a/packages/sdk/js/src/v2/gen/sdk.gen.ts b/packages/sdk/js/src/v2/gen/sdk.gen.ts
index a62ef350..8288d50f 100644
--- a/packages/sdk/js/src/v2/gen/sdk.gen.ts
+++ b/packages/sdk/js/src/v2/gen/sdk.gen.ts
@@ -381,6 +381,8 @@ import type {
   SessionCommandResponses,
   SessionContextAttemptResolveErrors,
   SessionContextAttemptResolveResponses,
+  SessionContextCohortErrors,
+  SessionContextCohortResponses,
   SessionContextDiagnosticsErrors,
   SessionContextDiagnosticsResponses,
   SessionCreateErrors,
@@ -395,10 +397,14 @@ import type {
   SessionDiffArtifactManifestResponses,
   SessionDiffErrors,
   SessionDiffResponses,
+  SessionExportSnapshotErrors,
+  SessionExportSnapshotResponses,
   SessionForkErrors,
   SessionForkResponses,
   SessionGetErrors,
   SessionGetResponses,
+  SessionImportSnapshotErrors,
+  SessionImportSnapshotResponses,
   SessionInitErrors,
   SessionInitResponses,
   SessionListErrors,
@@ -8483,6 +8489,44 @@ export class Session2 extends HeyApiClient {
     })
   }
 
+  /**
+   * Aggregate federated context selections across sessions
+   *
+   * FEAT-005: durable cohort aggregation over [sinceMs, untilMs], bucketed by readiness (ready/building/degraded/blocked) so rollout decisions are not skewed by cold-start noise.
+   */
+  public contextCohort<ThrowOnError extends boolean = false>(
+    parameters: {
+      directory?: string
+      workspace?: string
+      sinceMs: string
+      untilMs?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "sinceMs" },
+            { in: "query", key: "untilMs" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).get<
+      SessionContextCohortResponses,
+      SessionContextCohortErrors,
+      ThrowOnError
+    >({
+      url: "/session/context/cohort",
+      ...options,
+      ...params,
+    })
+  }
+
   /**
    * List provider recovery decisions
    *
@@ -8578,6 +8622,57 @@ export class Session2 extends HeyApiClient {
       },
     })
   }
+
+  /**
+   * Export a session snapshot
+   *
+   * Export the session's conversation (session + messages + parts) as a self-describing snapshot bundle (JSON). The bundle re-imports on another device as a fresh, continuable session.
+   */
+  public exportSnapshot<ThrowOnError extends boolean = false>(
+    parameters: {
+      sessionID: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }])
+    return (options?.client ?? this.client).get<
+      SessionExportSnapshotResponses,
+      SessionExportSnapshotErrors,
+      ThrowOnError
+    >({
+      url: "/session/{sessionID}/export",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Import a session snapshot
+   *
+   * Import a previously exported session bundle into the current instance as a fresh, continuable session (new IDs, re-rooted to the current project/directory).
+   */
+  public importSnapshot<ThrowOnError extends boolean = false>(
+    parameters: {
+      bundle: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "body", key: "bundle" }] }])
+    return (options?.client ?? this.client).post<
+      SessionImportSnapshotResponses,
+      SessionImportSnapshotErrors,
+      ThrowOnError
+    >({
+      url: "/session/import-snapshot",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
 }
 
 export class Part extends HeyApiClient {
diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts
index 8582e1fe..3596df6f 100644
--- a/packages/sdk/js/src/v2/gen/types.gen.ts
+++ b/packages/sdk/js/src/v2/gen/types.gen.ts
@@ -92,11 +92,11 @@ export type Event =
   | EventSessionIdle
   | EventSessionCompacted
   | EventPlanUpdated
+  | EventGoalUpdated
   | EventDebugStopped
   | EventDebugOutput
   | EventDebugTerminated
   | EventDebugUpdated
-  | EventGoalUpdated
   | EventVcsBranchUpdated
   | EventWorkspaceReady
   | EventWorkspaceFailed
@@ -1797,6 +1797,24 @@ export type GlobalEvent = {
           changes?: Array<string>
         }
       }
+    | {
+        id: string
+        type: "goal.updated"
+        properties: {
+          sessionID: string
+          goalId: string
+          planDocId: string
+          phase: string
+          ledger: {
+            ticks: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+            tokens: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+            cost: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+            wallclockMs: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+          }
+          stallCount: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+          gaps: Array<string>
+        }
+      }
     | {
         id: string
         type: "debug.stopped"
@@ -1830,24 +1848,6 @@ export type GlobalEvent = {
           status: string
         }
       }
-    | {
-        id: string
-        type: "goal.updated"
-        properties: {
-          sessionID: string
-          goalId: string
-          planDocId: string
-          phase: string
-          ledger: {
-            ticks: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-            tokens: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-            cost: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-            wallclockMs: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-          }
-          stallCount: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
-          gaps: Array<string>
-        }
-      }
     | {
         id: string
         type: "vcs.branch.updated"
@@ -2201,6 +2201,7 @@ export type ProviderConfig = {
           [key: string]: unknown
         }
       }
+      disabled?: boolean
     }
   }
   groups?: {
@@ -6993,6 +6994,25 @@ export type EventPlanUpdated = {
   }
 }
 
+export type EventGoalUpdated = {
+  id: string
+  type: "goal.updated"
+  properties: {
+    sessionID: string
+    goalId: string
+    planDocId: string
+    phase: string
+    ledger: {
+      ticks: number | "NaN" | "Infinity" | "-Infinity"
+      tokens: number | "NaN" | "Infinity" | "-Infinity"
+      cost: number | "NaN" | "Infinity" | "-Infinity"
+      wallclockMs: number | "NaN" | "Infinity" | "-Infinity"
+    }
+    stallCount: number | "NaN" | "Infinity" | "-Infinity"
+    gaps: Array<string>
+  }
+}
+
 export type EventDebugStopped = {
   id: string
   type: "debug.stopped"
@@ -7030,25 +7050,6 @@ export type EventDebugUpdated = {
   }
 }
 
-export type EventGoalUpdated = {
-  id: string
-  type: "goal.updated"
-  properties: {
-    sessionID: string
-    goalId: string
-    planDocId: string
-    phase: string
-    ledger: {
-      ticks: number | "NaN" | "Infinity" | "-Infinity"
-      tokens: number | "NaN" | "Infinity" | "-Infinity"
-      cost: number | "NaN" | "Infinity" | "-Infinity"
-      wallclockMs: number | "NaN" | "Infinity" | "-Infinity"
-    }
-    stallCount: number | "NaN" | "Infinity" | "-Infinity"
-    gaps: Array<string>
-  }
-}
-
 export type EventVcsBranchUpdated = {
   id: string
   type: "vcs.branch.updated"
@@ -15380,6 +15381,72 @@ export type SessionContextAttemptResolveResponses = {
 export type SessionContextAttemptResolveResponse =
   SessionContextAttemptResolveResponses[keyof SessionContextAttemptResolveResponses]
 
+export type SessionContextCohortData = {
+  body?: never
+  path?: never
+  query: {
+    directory?: string
+    workspace?: string
+    sinceMs: string
+    untilMs?: string
+  }
+  url: "/session/context/cohort"
+}
+
+export type SessionContextCohortErrors = {
+  /**
+   * BadRequest | InvalidRequestError
+   */
+  400: EffectHttpApiErrorBadRequest | InvalidRequestError
+}
+
+export type SessionContextCohortError = SessionContextCohortErrors[keyof SessionContextCohortErrors]
+
+export type SessionContextCohortResponses = {
+  /**
+   * Cohort-level federated context aggregation
+   */
+  200: {
+    window: {
+      sinceMs: number
+      untilMs: number
+    }
+    selections: number
+    sessions: number
+    tokens: number
+    readiness: {
+      ready: number
+      building: number
+      degraded: number
+      blocked: number
+    }
+    graphs: {
+      code: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+      knowledge: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+      memory: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+      documents: {
+        statuses: number
+        ready: number
+        notReady: number
+      }
+    }
+  }
+}
+
+export type SessionContextCohortResponse = SessionContextCohortResponses[keyof SessionContextCohortResponses]
+
 export type SessionProviderResolutionListData = {
   body?: never
   path: {
@@ -15485,6 +15552,68 @@ export type SessionProviderResolutionResolveResponses = {
 export type SessionProviderResolutionResolveResponse =
   SessionProviderResolutionResolveResponses[keyof SessionProviderResolutionResolveResponses]
 
+export type SessionExportSnapshotData = {
+  body?: never
+  path: {
+    sessionID: string
+  }
+  query?: never
+  url: "/session/{sessionID}/export"
+}
+
+export type SessionExportSnapshotErrors = {
+  /**
+   * BadRequest | InvalidRequestError
+   */
+  400: EffectHttpApiErrorBadRequest | InvalidRequestError
+  /**
+   * NotFoundError
+   */
+  404: NotFoundError
+}
+
+export type SessionExportSnapshotError = SessionExportSnapshotErrors[keyof SessionExportSnapshotErrors]
+
+export type SessionExportSnapshotResponses = {
+  /**
+   * Session snapshot bundle as a JSON string
+   */
+  200: string
+}
+
+export type SessionExportSnapshotResponse = SessionExportSnapshotResponses[keyof SessionExportSnapshotResponses]
+
+export type SessionImportSnapshotData = {
+  body?: {
+    bundle: string
+  }
+  path?: never
+  query?: never
+  url: "/session/import-snapshot"
+}
+
+export type SessionImportSnapshotErrors = {
+  /**
+   * BadRequest | InvalidRequestError
+   */
+  400: EffectHttpApiErrorBadRequest | InvalidRequestError
+}
+
+export type SessionImportSnapshotError = SessionImportSnapshotErrors[keyof SessionImportSnapshotErrors]
+
+export type SessionImportSnapshotResponses = {
+  /**
+   * Imported session summary
+   */
+  200: {
+    sessionID: string
+    messages: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+    parts: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
+  }
+}
+
+export type SessionImportSnapshotResponse = SessionImportSnapshotResponses[keyof SessionImportSnapshotResponses]
+
 export type SyncStartData = {
   body?: never
   path?: never
diff --git a/packages/ui/src/components/file.tsx b/packages/ui/src/components/file.tsx
index 891947b1..6a9abb76 100644
--- a/packages/ui/src/components/file.tsx
+++ b/packages/ui/src/components/file.tsx
@@ -533,6 +533,11 @@ function preserve(viewer: Viewer) {
   }
 }
 
+// The diff virtualizer binds to the nearest overflow-y: auto/scroll ancestor. When no such
+// ancestor exists below an outer row-level virtualizer (e.g. the session timeline's virtua
+// scroller), both virtualizers share the same scroll root and inner height changes force the
+// outer one to re-measure. Callers enabling `virtualize` inside an outer virtualized list
+// should wrap the viewer in a bounded-height overflow-y: auto container (UX-001, message-part.tsx).
 function scrollParent(el: HTMLElement): HTMLElement | undefined {
   let parent = el.parentElement
   while (parent) {
diff --git a/packages/ui/src/components/message-part-chunk.test.ts b/packages/ui/src/components/message-part-chunk.test.ts
new file mode 100644
index 00000000..76eb77e3
--- /dev/null
+++ b/packages/ui/src/components/message-part-chunk.test.ts
@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test"
+import { CHUNK_THRESHOLD, chunkCacheKey, partChunks, splitPartChunks } from "./message-part-chunk"
+
+const KB = 1024
+
+/** Builds `count` paragraphs of ~4KB each (content + trailing blank line). */
+function paragraphs(count: number) {
+  return Array.from({ length: count }, (_, i) => `paragraph-${i} ` + "x".repeat(4 * KB) + "\n\n").join("")
+}
+
+describe("partChunks (chunk decision)", () => {
+  test("does not chunk text at or below the threshold", () => {
+    expect(partChunks("x".repeat(CHUNK_THRESHOLD), false)).toBeUndefined()
+    expect(partChunks("small text", false)).toBeUndefined()
+    expect(partChunks("", false)).toBeUndefined()
+  })
+
+  test("chunks completed text above the threshold", () => {
+    const chunks = partChunks(paragraphs(100), false)
+    expect(chunks).toBeDefined()
+    expect(chunks!.length).toBeGreaterThan(1)
+  })
+
+  test("never chunks while streaming, even above the threshold", () => {
+    expect(partChunks(paragraphs(100), true)).toBeUndefined()
+    expect(partChunks("x".repeat(CHUNK_THRESHOLD * 4), true)).toBeUndefined()
+  })
+})
+
+describe("splitPartChunks", () => {
+  test("returns the text untouched when it is a single chunk", () => {
+    const text = paragraphs(10)
+    expect(splitPartChunks(text)).toEqual([text])
+  })
+
+  test("preserves content exactly (join === original)", () => {
+    const text = paragraphs(100)
+    expect(splitPartChunks(text).join("")).toBe(text)
+  })
+
+  test("keeps chunk sizes within 64-256KB", () => {
+    const chunks = splitPartChunks(paragraphs(100))
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeGreaterThan(0)
+      expect(chunk.length).toBeLessThanOrEqual(256 * KB)
+    }
+    for (const chunk of chunks.slice(0, -1)) {
+      expect(chunk.length).toBeGreaterThanOrEqual(64 * KB)
+    }
+  })
+
+  test("cuts at paragraph boundaries", () => {
+    const chunks = splitPartChunks(paragraphs(100))
+    for (const chunk of chunks.slice(0, -1)) {
+      expect(chunk.endsWith("\n\n")).toBe(true)
+    }
+  })
+
+  test("splits an oversized paragraph at newline boundaries", () => {
+    const huge = Array.from({ length: 400 }, (_, i) => `line-${i}-` + "y".repeat(1 * KB)).join("\n") + "\n\n"
+    const text = huge + paragraphs(10)
+    expect(text.length).toBeGreaterThan(CHUNK_THRESHOLD)
+    const chunks = splitPartChunks(text)
+    expect(chunks.length).toBeGreaterThan(1)
+    expect(chunks.join("")).toBe(text)
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(256 * KB)
+    }
+  })
+
+  test("hard-slices a single line longer than the max chunk size", () => {
+    const text = "z".repeat(600 * KB)
+    const chunks = splitPartChunks(text)
+    expect(chunks.join("")).toBe(text)
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(256 * KB)
+    }
+  })
+})
+
+describe("chunkCacheKey", () => {
+  test("is stable and follows the partID:chunk:index format", () => {
+    expect(chunkCacheKey("part_1", 0)).toBe("part_1:chunk:0")
+    expect(chunkCacheKey("part_1", 3)).toBe("part_1:chunk:3")
+    expect(chunkCacheKey("part_1", 0)).toBe(chunkCacheKey("part_1", 0))
+  })
+
+  test("produces distinct keys per chunk and per part", () => {
+    const keys = new Set([
+      chunkCacheKey("part_1", 0),
+      chunkCacheKey("part_1", 1),
+      chunkCacheKey("part_2", 0),
+    ])
+    expect(keys.size).toBe(3)
+  })
+})
diff --git a/packages/ui/src/components/message-part-chunk.ts b/packages/ui/src/components/message-part-chunk.ts
new file mode 100644
index 00000000..8a4be75c
--- /dev/null
+++ b/packages/ui/src/components/message-part-chunk.ts
@@ -0,0 +1,91 @@
+// UX-002: inline chunking for oversized text/reasoning parts. Row-level virtua
+// virtualization groups rows by turn, so a single huge part (observed up to ~16MB)
+// was mounted and morphdom-diffed as one monolithic Markdown block. We split the
+// completed text into 64-256KB pieces at paragraph/newline boundaries and render
+// each piece as an independent Markdown instance (see ChunkedText in
+// message-part.tsx). Kept as a pure, dependency-free module so the chunk logic is
+// unit-testable without pulling Solid component imports into the test runtime.
+
+export const CHUNK_THRESHOLD = 256 * 1024
+const CHUNK_MIN = 64 * 1024
+const CHUNK_MAX = 256 * 1024
+
+// Deterministic per (part text, index): part text is frozen once the message is
+// completed, so cache keys are stable across re-renders and re-mounts.
+export function chunkCacheKey(partID: string, index: number) {
+  return `${partID}:chunk:${index}`
+}
+
+function pushChunk(chunks: string[], buffer: string[]) {
+  const value = buffer.join("")
+  if (value) chunks.push(value)
+  buffer.length = 0
+}
+
+// Last-resort splitter for a single line longer than CHUNK_MAX (e.g. minified or
+// binary-ish dumps): hard slice; no newline boundary exists to respect.
+function pushOversized(chunks: string[], line: string) {
+  for (let start = 0; start < line.length; start += CHUNK_MAX) {
+    chunks.push(line.slice(start, start + CHUNK_MAX))
+  }
+}
+
+function flushLines(chunks: string[], block: string) {
+  const lines = block.split(/(?<=\n)/)
+  let buffer = ""
+  for (const line of lines) {
+    if (line.length >= CHUNK_MAX) {
+      if (buffer) {
+        chunks.push(buffer)
+        buffer = ""
+      }
+      pushOversized(chunks, line)
+      continue
+    }
+    if (buffer && buffer.length + line.length > CHUNK_MAX) {
+      chunks.push(buffer)
+      buffer = ""
+    }
+    buffer += line
+    if (buffer.length >= CHUNK_MIN) {
+      chunks.push(buffer)
+      buffer = ""
+    }
+  }
+  if (buffer) chunks.push(buffer)
+}
+
+// Splits completed part text into 64-256KB chunks. Primary boundaries are blank
+// lines (paragraphs); a paragraph larger than CHUNK_MAX is further split at
+// newline boundaries. Concatenating all chunks reproduces the input exactly.
+export function splitPartChunks(text: string): string[] {
+  if (text.length <= CHUNK_THRESHOLD) return [text]
+
+  const chunks: string[] = []
+  let buffer: string[] = []
+  const size = () => buffer.reduce((sum, item) => sum + item.length, 0)
+
+  const flush = () => pushChunk(chunks, buffer)
+
+  for (const paragraph of text.split(/(?<=\n\n)/)) {
+    if (paragraph.length >= CHUNK_MAX) {
+      if (size() >= CHUNK_MIN) flush()
+      else if (buffer.length > 0) flush()
+      flushLines(chunks, paragraph)
+      continue
+    }
+    if (size() + paragraph.length > CHUNK_MAX) flush()
+    buffer.push(paragraph)
+    if (size() >= CHUNK_MIN) flush()
+  }
+  flush()
+  return chunks
+}
+
+// Chunk decision: never split while the part is still streaming (a growing
+// buffer would shift chunk boundaries on every update); split only once the
+// completed text exceeds the threshold.
+export function partChunks(text: string, streaming: boolean): string[] | undefined {
+  if (streaming || text.length <= CHUNK_THRESHOLD) return
+  return splitPartChunks(text)
+}
diff --git a/packages/ui/src/components/message-part.tsx b/packages/ui/src/components/message-part.tsx
index 27fdf313..a587e104 100644
--- a/packages/ui/src/components/message-part.tsx
+++ b/packages/ui/src/components/message-part.tsx
@@ -58,6 +58,7 @@ import { animate } from "motion"
 import { useLocation } from "@solidjs/router"
 import { attached, inline, kind } from "./message-file"
 import { readPartText } from "./message-part-text"
+import { chunkCacheKey, partChunks } from "./message-part-chunk"
 
 async function writeClipboard(text: string): Promise<boolean> {
   const body = typeof document === "undefined" ? undefined : document.body
@@ -276,6 +277,37 @@ function PacedMarkdown(props: { text: string; cacheKey: string; streaming: boole
   )
 }
 
+// UX-002: chunking constants, boundary splitting and the streaming-safe chunk
+// decision live in ./message-part-chunk (pure module, unit-tested separately).
+
+// UX-002 lazy mount: each chunk wrapper carries content-visibility: auto so the
+// browser skips style/layout/paint of off-screen chunks entirely. Chosen over an
+// IntersectionObserver-based deferred mount because it is pure CSS: no observer
+// bookkeeping, no mount/unmount churn fighting with virtua row recycling, and the
+// Markdown parse cache still warms up on first scroll-past.
+const CHUNK_LAZY_STYLE: JSX.CSSProperties = {
+  "content-visibility": "auto",
+  "contain-intrinsic-size": "auto 480px",
+}
+
+// Chunks only exist once the part has completed (chunking is skipped while
+// streaming), so every chunk — including the last one — is rendered once through
+// the shared block cache. The streaming path stays monolithic (PacedMarkdown)
+// until completion, then the part flips to this chunked view in a single swap.
+function ChunkedText(props: { chunks: string[]; cacheKey: string }) {
+  return (
+    <div data-component="chunked-text" data-chunk-count={props.chunks.length}>
+      <For each={props.chunks}>
+        {(chunk, indexAccessor) => (
+          <div data-slot="text-chunk" data-chunk-index={indexAccessor()} style={CHUNK_LAZY_STYLE}>
+            <Markdown text={chunk} cacheKey={chunkCacheKey(props.cacheKey, indexAccessor())} streaming={false} />
+          </div>
+        )}
+      </For>
+    </div>
+  )
+}
+
 function relativizeProjectPath(path: string, directory?: string) {
   if (!path) return ""
   if (!directory) return path
@@ -1301,6 +1333,18 @@ export interface ToolProps {
 
 export type ToolComponent = Component<ToolProps>
 
+// UX-001: when a tool diff is virtualized, give it a bounded, independently scrollable
+// container. file.tsx binds the diff virtualizer to the nearest overflow-y: auto/scroll
+// ancestor (see scrollParent()); without isolation the inner virtualizer would share the
+// session page's outer virtua row-level scroll root, and inner height changes would make
+// the outer virtualizer re-measure repeatedly (jitter). Bounding the height also keeps a
+// huge completed diff from stretching the timeline row indefinitely.
+const VIRTUAL_DIFF_SCROLL_STYLE: JSX.CSSProperties = { "max-height": "480px", "overflow-y": "auto" }
+
+function virtualDiffScrollStyle(enabled: boolean | undefined): JSX.CSSProperties | undefined {
+  return enabled ? VIRTUAL_DIFF_SCROLL_STYLE : undefined
+}
+
 const state: Record<
   string,
   {
@@ -1512,6 +1556,9 @@ PART_MAPPING["text"] = function TextPartDisplay(props) {
     () => props.message.role === "assistant" && typeof (props.message as AssistantMessage).time.completed !== "number",
   )
   const text = () => readPartText(data.store.part_text_accum_delta, part())
+  // UX-002: chunk only after the part stops streaming; split once, at paragraph
+  // boundaries, on completion.
+  const chunks = createMemo(() => partChunks(text(), streaming()))
   const isLastTextPart = createMemo(() => {
     const last = (data.store.part?.[props.message.id] ?? [])
       .filter((item): item is TextPart => item?.type === "text" && !!item.text?.trim())
@@ -1553,8 +1600,13 @@ PART_MAPPING["text"] = function TextPartDisplay(props) {
     <Show when={text()}>
       <div data-component="text-part" data-timeline-part-id={part().id}>
         <div data-slot="text-part-body">
-          <Show when={streaming()} fallback={<Markdown text={text()} cacheKey={part().id} streaming={false} />}>
-            <PacedMarkdown text={text()} cacheKey={part().id} streaming={streaming()} />
+          <Show
+            when={!chunks()}
+            fallback={<ChunkedText chunks={chunks()!} cacheKey={part().id} />}
+          >
+            <Show when={streaming()} fallback={<Markdown text={text()} cacheKey={part().id} streaming={false} />}>
+              <PacedMarkdown text={text()} cacheKey={part().id} streaming={streaming()} />
+            </Show>
           </Show>
         </div>
         <Show when={showCopy()}>
@@ -1605,12 +1657,19 @@ PART_MAPPING["reasoning"] = function ReasoningPartDisplay(props) {
     () => props.message.role === "assistant" && typeof (props.message as AssistantMessage).time.completed !== "number",
   )
   const text = () => readPartText(data.store.part_text_accum_delta, part())
+  // UX-002: see TextPartDisplay — never chunk while streaming.
+  const chunks = createMemo(() => partChunks(text(), streaming()))
 
   return (
     <Show when={text()}>
       <div data-component="reasoning-part" data-timeline-part-id={part().id}>
-        <Show when={streaming()} fallback={<Markdown text={text()} cacheKey={part().id} streaming={false} />}>
-          <PacedMarkdown text={text()} cacheKey={part().id} streaming={streaming()} />
+        <Show
+          when={!chunks()}
+          fallback={<ChunkedText chunks={chunks()!} cacheKey={part().id} />}
+        >
+          <Show when={streaming()} fallback={<Markdown text={text()} cacheKey={part().id} streaming={false} />}>
+            <PacedMarkdown text={text()} cacheKey={part().id} streaming={streaming()} />
+          </Show>
         </Show>
       </div>
     </Show>
@@ -2066,7 +2125,7 @@ ToolRegistry.register({
                 </Show>
               }
             >
-              <div data-component="edit-content">
+              <div data-component="edit-content" style={virtualDiffScrollStyle(props.virtualizeDiff)}>
                 <Dynamic component={fileComponent} mode="diff" virtualize={props.virtualizeDiff} {...fileCompProps()} />
               </div>
             </ToolFileAccordion>
@@ -2247,7 +2306,10 @@ ToolRegistry.register({
                           </StickyAccordionHeader>
                           <Accordion.Content>
                             <Show when={props.deferContent === false || visible()}>
-                              <div data-component="apply-patch-file-diff">
+                              <div
+                                data-component="apply-patch-file-diff"
+                                style={virtualDiffScrollStyle(props.virtualizeDiff)}
+                              >
                                 <Dynamic
                                   component={fileComponent}
                                   mode="diff"
@@ -2323,7 +2385,7 @@ ToolRegistry.register({
                 </Switch>
               }
             >
-              <div data-component="apply-patch-file-diff">
+              <div data-component="apply-patch-file-diff" style={virtualDiffScrollStyle(props.virtualizeDiff)}>
                 <Dynamic
                   component={fileComponent}
                   mode="diff"
diff --git a/packages/web/src/content/docs/ar/github.mdx b/packages/web/src/content/docs/ar/github.mdx
index a0ce1f4a..186d6c63 100644
--- a/packages/web/src/content/docs/ar/github.mdx
+++ b/packages/web/src/content/docs/ar/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 قم بتجاوز الموجه الافتراضي لتخصيص سلوك DeepAgent Code ضمن الـworkflow لديك.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/bs/github.mdx b/packages/web/src/content/docs/bs/github.mdx
index 0601db44..c138beb4 100644
--- a/packages/web/src/content/docs/bs/github.mdx
+++ b/packages/web/src/content/docs/bs/github.mdx
@@ -61,7 +61,7 @@ Ili ga možete postaviti ručno.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -134,7 +134,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -171,7 +171,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -227,7 +227,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -249,7 +249,7 @@ Za `issues` događaje, `prompt` unos je **potreban** jer nema komentara za izvla
 Zaobiđite zadani prompt da biste prilagodili ponašanje DeepAgent Code za vaš tok posla.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/da/github.mdx b/packages/web/src/content/docs/da/github.mdx
index 053bb21f..50ab451d 100644
--- a/packages/web/src/content/docs/da/github.mdx
+++ b/packages/web/src/content/docs/da/github.mdx
@@ -64,7 +64,7 @@ Eller du kan indstille det manuelt.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ For `issues` begivenheder er `prompt` input **påkrævet**, da der ikke er nogen
 Tilsidesæt standardprompten for at tilpasse DeepAgent Codes adfærd til din arbejdsgang.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/de/github.mdx b/packages/web/src/content/docs/de/github.mdx
index ba302b22..36079045 100644
--- a/packages/web/src/content/docs/de/github.mdx
+++ b/packages/web/src/content/docs/de/github.mdx
@@ -64,7 +64,7 @@ Oder Sie können es manuell einrichten.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ Für `issues`-Ereignisse ist die Eingabe `prompt` **erforderlich**, da es keinen
 Überschreiben Sie die Standardaufforderung, um das Verhalten von DeepAgent Code für Ihren Workflow anzupassen.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/es/github.mdx b/packages/web/src/content/docs/es/github.mdx
index e0516979..5f63c6cb 100644
--- a/packages/web/src/content/docs/es/github.mdx
+++ b/packages/web/src/content/docs/es/github.mdx
@@ -64,7 +64,7 @@ O puede configurarlo manualmente.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ Para eventos `issues`, la entrada `prompt` es **obligatoria** ya que no hay ning
 Anule el mensaje predeterminado para personalizar el comportamiento de DeepAgent Code para su flujo de trabajo.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/fr/github.mdx b/packages/web/src/content/docs/fr/github.mdx
index 960fd061..e0e459aa 100644
--- a/packages/web/src/content/docs/fr/github.mdx
+++ b/packages/web/src/content/docs/fr/github.mdx
@@ -64,7 +64,7 @@ Ajoutez le fichier de workflow suivant à `.github/workflows/deepagent-code.yml`
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ Pour les événements `issues`, l'entrée `prompt` est **obligatoire** car il n'
 Remplacez l'invite par défaut pour personnaliser le comportement de DeepAgent Code pour votre workflow.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/github.mdx b/packages/web/src/content/docs/github.mdx
index c5884fc8..088fa4b7 100644
--- a/packages/web/src/content/docs/github.mdx
+++ b/packages/web/src/content/docs/github.mdx
@@ -64,7 +64,7 @@ Or you can set it up manually.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ For `issues` events, the `prompt` input is **required** since there's no comment
 Override the default prompt to customize DeepAgent Code's behavior for your workflow.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/it/github.mdx b/packages/web/src/content/docs/it/github.mdx
index 7fe42131..7653a53c 100644
--- a/packages/web/src/content/docs/it/github.mdx
+++ b/packages/web/src/content/docs/it/github.mdx
@@ -64,7 +64,7 @@ In alternativa, puoi configurarlo manualmente.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ Per gli eventi `issues`, l'input `prompt` e' **obbligatorio** dato che non c'e'
 Sovrascrivi il prompt di default per personalizzare il comportamento di DeepAgent Code nel tuo workflow.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/ja/github.mdx b/packages/web/src/content/docs/ja/github.mdx
index 9d82a9ea..21b98b73 100644
--- a/packages/web/src/content/docs/ja/github.mdx
+++ b/packages/web/src/content/docs/ja/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 デフォルトのプロンプトをオーバーライドして、ワークフローに合わせて DeepAgent Code の動作をカスタマイズします。
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/ko/github.mdx b/packages/web/src/content/docs/ko/github.mdx
index 213aac11..ac0a06ee 100644
--- a/packages/web/src/content/docs/ko/github.mdx
+++ b/packages/web/src/content/docs/ko/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 기본 prompt를 override해 워크플로에 맞게 DeepAgent Code 동작을 커스터마이즈할 수 있습니다.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/nb/github.mdx b/packages/web/src/content/docs/nb/github.mdx
index 1f04f2b1..948cd757 100644
--- a/packages/web/src/content/docs/nb/github.mdx
+++ b/packages/web/src/content/docs/nb/github.mdx
@@ -64,7 +64,7 @@ Eller du kan sette den opp manuelt.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ For `issues`-hendelser er `prompt`-inngangen **påkrevd** siden det ikke er noen
 Overstyr standardprompten for å tilpasse oppførselen til DeepAgent Code for arbeidsflyten din.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/pl/github.mdx b/packages/web/src/content/docs/pl/github.mdx
index 1cebf40e..6cd72170 100644
--- a/packages/web/src/content/docs/pl/github.mdx
+++ b/packages/web/src/content/docs/pl/github.mdx
@@ -64,7 +64,7 @@ Można też uszkodzić to rozwiązanie.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ W przypadku zdarzenia `issues` wprowadzenie `prompt` jest **wymagane**, poniewa
 Zastąp domyślne monit, aby zastosować zachowanie deepagent-code do twojego własnego pracy.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/pt-br/github.mdx b/packages/web/src/content/docs/pt-br/github.mdx
index fb853ed9..6a452ac4 100644
--- a/packages/web/src/content/docs/pt-br/github.mdx
+++ b/packages/web/src/content/docs/pt-br/github.mdx
@@ -64,7 +64,7 @@ Ou você pode configurá-lo manualmente.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
        - name: Run DeepAgent Code
-         uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+         uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
          env:
            ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-       - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+       - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
          env:
            ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-       - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+       - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
          if: steps.check.outputs.result == 'true'
          env:
            ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ Para eventos de `issues`, a entrada `prompt` é **obrigatória** uma vez que nã
 Substitua o prompt padrão para personalizar o comportamento do deepagent-code para seu fluxo de trabalho.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/ru/github.mdx b/packages/web/src/content/docs/ru/github.mdx
index 9938d4be..7b9b961a 100644
--- a/packages/web/src/content/docs/ru/github.mdx
+++ b/packages/web/src/content/docs/ru/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 Переопределите приглашение по умолчанию, чтобы настроить поведение deepagent-code для вашего рабочего процесса.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/th/github.mdx b/packages/web/src/content/docs/th/github.mdx
index 0bb7f707..99c1db68 100644
--- a/packages/web/src/content/docs/th/github.mdx
+++ b/packages/web/src/content/docs/th/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 แทนที่ข้อความแจ้งเริ่มต้นเพื่อปรับแต่งการทำงานของ DeepAgent Code สำหรับเวิร์กโฟลว์ของคุณ
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/tr/github.mdx b/packages/web/src/content/docs/tr/github.mdx
index b147c292..3cb18357 100644
--- a/packages/web/src/content/docs/tr/github.mdx
+++ b/packages/web/src/content/docs/tr/github.mdx
@@ -64,7 +64,7 @@ Veya manuel olarak ayarlayabilirsiniz.
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 deepagent-code'un davranışını iş akışınız için özelleştirmek için varsayılan istemi geçersiz kılın.
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/zh-cn/github.mdx b/packages/web/src/content/docs/zh-cn/github.mdx
index 088de788..3b71e0d8 100644
--- a/packages/web/src/content/docs/zh-cn/github.mdx
+++ b/packages/web/src/content/docs/zh-cn/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 覆盖默认提示词，以便为你的工作流自定义 DeepAgent Code 的行为。
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/packages/web/src/content/docs/zh-tw/github.mdx b/packages/web/src/content/docs/zh-tw/github.mdx
index e860c106..d21cd300 100644
--- a/packages/web/src/content/docs/zh-tw/github.mdx
+++ b/packages/web/src/content/docs/zh-tw/github.mdx
@@ -64,7 +64,7 @@ deepagent-code github install
               persist-credentials: false
 
           - name: Run DeepAgent Code
-            uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+            uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
             env:
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
             with:
@@ -140,7 +140,7 @@ jobs:
           persist-credentials: false
 
       - name: Run DeepAgent Code
-        uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+        uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:
@@ -177,7 +177,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -233,7 +233,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+      - uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
         if: steps.check.outputs.result == 'true'
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -255,7 +255,7 @@ jobs:
 覆寫預設提示詞，以便為您的工作流程自訂 DeepAgent Code 的行為。
 
 ```yaml title=".github/workflows/deepagent-code.yml"
-- uses: deepagent-ltd/deepagent-code/github@github-v1.4.5
+- uses: deepagent-ltd/deepagent-code/github@github-v1.4.7
   with:
     model: anthropic/claude-sonnet-4-5
     prompt: |
diff --git a/release-evidence/README.md b/release-evidence/README.md
new file mode 100644
index 00000000..8ec6d4f3
--- /dev/null
+++ b/release-evidence/README.md
@@ -0,0 +1,77 @@
+# Release Evidence — V4.1 发布证据归档
+
+本目录存放 V4.1 发布门禁（BUG-407-005）的可追溯证据。每个 gate 产出一份**不可变**的
+`manifest.json`，记录 gate 结论、证据条目（类型/文件/SHA-256/结论）与签字占位。
+
+规格来源：[`docs/bug-407-005.md`](../docs/bug-407-005.md) §1 Evidence Manifest 与 §7 Gate State Rules。
+
+## 目录结构
+
+```text
+release-evidence/
+├── README.md                  # 本文件：结构与不可变语义说明
+├── manifest.schema.json       # manifest JSON Schema（draft-07）
+└── v4.1/
+    └── <commit-sha>/          # 证据绑定的完整 git commit SHA
+        └── <gate-id>/
+            ├── manifest.json  # 不可变 gate manifest（由 script/release-evidence.ts 生成）
+            ├── logs/          # 可选：原始测试/命令日志
+            ├── db/            # 可选：数据库快照、migration ledger
+            ├── requests/      # 可选：provider request 哈希与脱敏 payload
+            └── ui/            # 可选：UI capture
+```
+
+- `<commit-sha>`：完整 40 位 git SHA。证据必须绑定到产出它的那个 commit；
+  source/bundle/migration/flags/provider 任一变化都会使相关证据失效（见 §7），
+  新 commit 必须重新跑 gate，不得引用旧 artifact 充数。
+- `<gate-id>`：gate 标识，如 `release-gate-20260819`、`R1-C`、`R2-S3`、`R3-EVT-1000`。
+- 原始日志/产物不在仓库时，manifest 的 evidence 条目可以只有文本结论
+  （`path: null`、`sha256: null`），但结论必须写明事实与来源。
+
+## Manifest 字段（详见 manifest.schema.json）
+
+| 字段 | 说明 |
+|---|---|
+| `schema_version` | 固定 `deepagent.release_evidence.v1` |
+| `version` | 发布线，如 `v4.1` |
+| `gate_id` | gate 名 |
+| `commit` | 证据绑定的完整 commit SHA |
+| `date` | gate 执行日期（YYYY-MM-DD） |
+| `generated_at` | manifest 生成时间（ISO-8601 UTC） |
+| `status` | `passed` / `failed` / `blocked` / `not_run` |
+| `summary` | gate 总体结论 |
+| `evidence[]` | 证据条目：`kind`（类型）、`label`、`path`（文件，可空）、`sha256`（可空）、`conclusion`（结论） |
+| `signatures[]` | 签字占位：`role` / `actor` / `at`；签字链要求 domain owner 与 release owner 各自签字 |
+
+证据条目 `kind` 分类对应 BUG-407-005 的证据层级：
+`test-summary`（R1 确定性测试）、`migration`（M1-M4）、`smoke` / `live`（R2 live）、
+`capacity`（R3 容量）、`log` / `db` / `request` / `ui` / `receipt` / `metric`（原始 artifact）。
+
+## 不可变语义
+
+1. **manifest 一旦生成不得修改**。`script/release-evidence.ts` 不提供覆盖写：
+   目标 `manifest.json` 已存在时重复生成直接报错退出。
+2. 修订、重试或结论变化 → 使用新的 gate attempt（新的 `<gate-id>`，
+   如 `release-gate-20260819-attempt2`）生成新 manifest，不覆盖旧证据。
+3. `--check` 校验 manifest 中记录的文件 SHA-256 未被篡改；任何哈希不一致即为篡改，判为失败。
+4. secret、完整敏感 prompt 与 provider credential 不进入 manifest；
+   request artifact 使用 canonical hash + 脱敏结构化 payload。
+
+## 工具用法
+
+```bash
+# 生成 gate manifest（重复生成会报错，不覆盖）
+bun script/release-evidence.ts archive \
+  --gate release-gate-20260819 \
+  --date 2026-08-19 \
+  --status passed \
+  --summary "总体结论" \
+  --evidence "test-summary:full-suite" \
+  --conclusion "full-suite=4967 pass / 0 fail" \
+  --evidence "log:run-log:packages/core/run.log" \
+  --sign "domain-owner=<name>" --sign "release-owner=<name>"
+
+# 校验已有 manifest 的文件哈希未被篡改
+bun script/release-evidence.ts check --gate release-gate-20260819
+bun script/release-evidence.ts check release-evidence/v4.1/<commit>/<gate>/manifest.json
+```
diff --git a/release-evidence/manifest.schema.json b/release-evidence/manifest.schema.json
new file mode 100644
index 00000000..4d773269
--- /dev/null
+++ b/release-evidence/manifest.schema.json
@@ -0,0 +1,115 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "deepagent.release_evidence.v1",
+  "title": "Release Evidence Gate Manifest",
+  "description": "Immutable release-gate evidence manifest (BUG-407-005). Generated by script/release-evidence.ts; never overwrite an existing manifest — create a new gate attempt instead.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "version", "gate_id", "commit", "date", "generated_at", "status", "evidence", "signatures"],
+  "properties": {
+    "schema_version": {
+      "const": "deepagent.release_evidence.v1"
+    },
+    "version": {
+      "type": "string",
+      "description": "Release line, e.g. v4.1",
+      "pattern": "^v[0-9]+\\.[0-9]+$"
+    },
+    "gate_id": {
+      "type": "string",
+      "description": "Gate identifier, e.g. release-gate-20260819, R1-C, R2-S3",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]*$"
+    },
+    "commit": {
+      "type": "string",
+      "description": "Full 40-char git SHA the evidence is bound to",
+      "pattern": "^[0-9a-f]{40}$"
+    },
+    "date": {
+      "type": "string",
+      "description": "Gate execution date (UTC)",
+      "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$"
+    },
+    "generated_at": {
+      "type": "string",
+      "description": "Manifest generation timestamp, ISO-8601 UTC"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["passed", "failed", "blocked", "not_run"]
+    },
+    "summary": {
+      "type": "string",
+      "description": "Overall gate conclusion"
+    },
+    "evidence": {
+      "type": "array",
+      "description": "Evidence entries; order is part of the immutable record",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["kind", "label", "conclusion"],
+        "properties": {
+          "kind": {
+            "type": "string",
+            "description": "Evidence category aligned with BUG-407-005 R1/R2/R3/M1-M4 classification",
+            "enum": [
+              "test-summary",
+              "migration",
+              "smoke",
+              "live",
+              "capacity",
+              "log",
+              "db",
+              "request",
+              "ui",
+              "receipt",
+              "metric"
+            ]
+          },
+          "label": {
+            "type": "string",
+            "description": "Unique identifier of this entry within the gate",
+            "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]*$"
+          },
+          "path": {
+            "type": ["string", "null"],
+            "description": "Repo-relative path of the evidence file; null when the original artifact is not kept in the repo"
+          },
+          "sha256": {
+            "type": ["string", "null"],
+            "description": "SHA-256 hex digest of the file at path; null together with path",
+            "pattern": "^[0-9a-f]{64}$"
+          },
+          "conclusion": {
+            "type": "string",
+            "description": "Recorded conclusion, facts and source for this entry"
+          }
+        }
+      }
+    },
+    "signatures": {
+      "type": "array",
+      "description": "Sign-off chain placeholders: each domain owner plus the release owner must sign before the gate closes",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["role", "actor", "at"],
+        "properties": {
+          "role": {
+            "type": "string",
+            "description": "e.g. domain-owner, release-owner"
+          },
+          "actor": {
+            "type": "string",
+            "description": "Signer identity; empty string until signed"
+          },
+          "at": {
+            "type": "string",
+            "description": "Signing timestamp, ISO-8601 UTC; empty string until signed"
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/release-evidence/v4.1/6fa05579a27d7db372da502d112efaab23353d15/release-gate-20260819/manifest.json b/release-evidence/v4.1/6fa05579a27d7db372da502d112efaab23353d15/release-gate-20260819/manifest.json
new file mode 100644
index 00000000..8a16c974
--- /dev/null
+++ b/release-evidence/v4.1/6fa05579a27d7db372da502d112efaab23353d15/release-gate-20260819/manifest.json
@@ -0,0 +1,52 @@
+{
+  "schema_version": "deepagent.release_evidence.v1",
+  "version": "v4.1",
+  "gate_id": "release-gate-20260819",
+  "commit": "6fa05579a27d7db372da502d112efaab23353d15",
+  "date": "2026-08-19",
+  "generated_at": "2026-08-19T17:25:23Z",
+  "status": "passed",
+  "summary": "2026-08-19 发布门禁回填归档:全量确定性测试、migration 双路径、DeepSeek live 冒烟全部通过。原始日志未入仓库,本 manifest 以文本记录事实与来源;commit 绑定为归档时分支 HEAD,正式发布前须按 BUG-407-005 重新绑定发布 commit。",
+  "evidence": [
+    {
+      "kind": "test-summary",
+      "label": "full-suite-deterministic",
+      "path": null,
+      "sha256": null,
+      "conclusion": "全量确定性测试:4967 pass / 0 fail / 5006 tests。来源:2026-08-19 发布门禁执行摘要(原始日志未入仓库)。"
+    },
+    {
+      "kind": "migration",
+      "label": "dual-path-prod-replica",
+      "path": null,
+      "sha256": null,
+      "conclusion": "migration 双路径验证:在生产库副本上成功回放 143 个 migrations,新库/旧库两条路径均通过。来源:2026-08-19 发布门禁 migration 执行记录(原始日志未入仓库)。"
+    },
+    {
+      "kind": "smoke",
+      "label": "deepseek-live-cli-headless",
+      "path": null,
+      "sha256": null,
+      "conclusion": "DeepSeek live 冒烟:cli-headless 路径通过。来源:2026-08-19 发布门禁 live 冒烟记录(原始日志未入仓库)。"
+    },
+    {
+      "kind": "smoke",
+      "label": "deepseek-live-structured-legacy",
+      "path": null,
+      "sha256": null,
+      "conclusion": "DeepSeek live 冒烟:structured-legacy 路径通过。来源:2026-08-19 发布门禁 live 冒烟记录(原始日志未入仓库)。"
+    }
+  ],
+  "signatures": [
+    {
+      "role": "domain-owner",
+      "actor": "",
+      "at": ""
+    },
+    {
+      "role": "release-owner",
+      "actor": "",
+      "at": ""
+    }
+  ]
+}
diff --git a/release-evidence/v4.1/9bad421e500b20cf6948e3b250203722afafbdb0/release-gate-20260820/manifest.json b/release-evidence/v4.1/9bad421e500b20cf6948e3b250203722afafbdb0/release-gate-20260820/manifest.json
new file mode 100644
index 00000000..213cd143
--- /dev/null
+++ b/release-evidence/v4.1/9bad421e500b20cf6948e3b250203722afafbdb0/release-gate-20260820/manifest.json
@@ -0,0 +1,51 @@
+{
+  "schema_version": "deepagent.release_evidence.v1",
+  "version": "v4.1",
+  "gate_id": "release-gate-20260820",
+  "commit": "9bad421e500b20cf6948e3b250203722afafbdb0",
+  "date": "2026-08-20",
+  "generated_at": "2026-08-20T01:01:09Z",
+  "status": "passed",
+  "evidence": [
+    {
+      "kind": "test-summary",
+      "label": "full-suite-deterministic",
+      "path": null,
+      "sha256": null,
+      "conclusion": "5001 pass / 38 skip / 1 todo / 0 fail (5040 tests / 468 files, durable 默认模式;含 BUG-407-012 A/B/C、UPD-005 Gap1/2、RISK-003 代码项、release-evidence 基建全部批次)"
+    },
+    {
+      "kind": "migration",
+      "label": "dual-path-prod-replica",
+      "path": null,
+      "sha256": null,
+      "conclusion": "生产库副本回放 143+2 migrations(20260820 两个新 migration 含),新/旧库双路径通过;schema --check 无 drift"
+    },
+    {
+      "kind": "smoke",
+      "label": "deepseek-live-cli-headless",
+      "path": null,
+      "sha256": null,
+      "conclusion": "通过(9 JSON events)"
+    },
+    {
+      "kind": "smoke",
+      "label": "deepseek-live-structured-legacy",
+      "path": null,
+      "sha256": null,
+      "conclusion": "通过(16733 tokens)"
+    }
+  ],
+  "signatures": [
+    {
+      "role": "domain-owner",
+      "actor": "",
+      "at": ""
+    },
+    {
+      "role": "release-owner",
+      "actor": "",
+      "at": ""
+    }
+  ]
+}
diff --git a/script/check-test-fixtures.ts b/script/check-test-fixtures.ts
new file mode 100644
index 00000000..6d0aa86b
--- /dev/null
+++ b/script/check-test-fixtures.ts
@@ -0,0 +1,167 @@
+#!/usr/bin/env bun
+/**
+ * QUAL-003 gate: forbid test fixtures from bypassing the durable session state machine.
+ *
+ * Tests must drive authority tables through the lifecycle helpers
+ * (admission -> preparing -> prepared -> dispatching -> terminal). Direct
+ * `db.insert(...)` calls against the authority tables below bypass the state
+ * machine and cascade-break fixtures whenever the schema tightens.
+ *
+ * oxlint has no call-combination rule for this, so this grep-style CI gate
+ * scans test sources under every package (`packages/<pkg>/test`, ts and tsx)
+ * and fails on every direct insert.
+ *
+ * Exemptions: a line ending with `// fixture-exempt: <reason>` is skipped.
+ * Only legacy crash-recovery fixtures that intentionally seed abnormal states
+ * may carry an exemption; new tests must use lifecycle helpers instead.
+ *
+ * Usage:
+ *   bun script/check-test-fixtures.ts              # fail on any non-exempt hit
+ *   bun script/check-test-fixtures.ts --baseline N # pass while hits <= N (ratchet mode)
+ */
+
+import * as fs from "node:fs"
+import * as path from "node:path"
+
+const AUTHORITY_TABLES = [
+  "SessionActivityTable",
+  "SessionProviderAttemptTable",
+  "SessionToolRequestReceiptTable",
+  "SessionActivityAdmissionTable",
+] as const
+
+/**
+ * Ratchet baseline for legacy bypassing fixtures. The current legacy inventory
+ * is fully annotated with `// fixture-exempt:` comments, so the strict mode
+ * baseline is zero. If the inventory ever grows unmanageably large, bump this
+ * and run with --baseline to switch to report-only-for-new-violations mode.
+ */
+const DEFAULT_BASELINE = 0
+
+const EXEMPTION_PATTERN = /\/\/\s*fixture-exempt:\s*\S/
+const INSERT_PATTERN = new RegExp(String.raw`\.insert\s*\(\s*(${AUTHORITY_TABLES.join("|")})\b`, "g")
+
+interface Violation {
+  readonly file: string
+  readonly line: number
+  readonly table: string
+}
+
+function* walkTestFiles(root: string): Generator<string> {
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    const full = path.join(root, entry.name)
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".artifacts") continue
+      yield* walkTestFiles(full)
+    } else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name)) {
+      yield full
+    }
+  }
+}
+
+function lineOfIndex(content: string, index: number): number {
+  let line = 1
+  for (let i = 0; i < index && i < content.length; i += 1) {
+    if (content.charCodeAt(i) === 10) line += 1
+  }
+  return line
+}
+
+function lineText(content: string, line: number): string {
+  return content.split("\n")[line - 1] ?? ""
+}
+
+function scan(root: string): Violation[] {
+  const violations: Violation[] = []
+  const packagesDir = path.join(root, "packages")
+  let packages: string[] = []
+  try {
+    packages = fs
+      .readdirSync(packagesDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => path.join(packagesDir, entry.name, "test"))
+  } catch {
+    packages = []
+  }
+  for (const testDir of packages) {
+    for (const file of walkTestFiles(testDir)) {
+      const content = fs.readFileSync(file, "utf8")
+      for (const match of content.matchAll(INSERT_PATTERN)) {
+        const line = lineOfIndex(content, match.index ?? 0)
+        const table = match[1] ?? "unknown"
+        if (EXEMPTION_PATTERN.test(lineText(content, line))) continue
+        violations.push({
+          file: path.relative(root, file),
+          line,
+          table,
+        })
+      }
+    }
+  }
+  return violations.sort((a, b) => (a.file === b.file ? a.line - b.line : a.file.localeCompare(b.file)))
+}
+
+function main(): void {
+  const repoRoot = path.resolve(import.meta.dir, "..")
+  const args = process.argv.slice(2)
+  let baseline: number | null = null
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--baseline") {
+      const raw = args[i + 1]
+      const parsed = raw === undefined ? Number.NaN : Number.parseInt(raw, 10)
+      if (Number.isNaN(parsed) || parsed < 0) {
+        console.error(`check-test-fixtures: invalid --baseline value: ${raw ?? "<missing>"}`)
+        process.exit(2)
+      }
+      baseline = parsed
+      i += 1
+    } else {
+      console.error(`check-test-fixtures: unknown argument: ${args[i]}`)
+      process.exit(2)
+    }
+  }
+  const effectiveBaseline = baseline ?? DEFAULT_BASELINE
+
+  const violations = scan(repoRoot)
+  console.log(
+    `check-test-fixtures: scanned packages/*/test/**/*.{ts,tsx} for direct inserts into ${AUTHORITY_TABLES.join(", ")}`,
+  )
+
+  if (violations.length === 0) {
+    console.log("check-test-fixtures: no non-exempt fixture bypasses found")
+    return
+  }
+
+  for (const violation of violations) {
+    console.log(
+      `${violation.file}:${violation.line}: direct .insert(${violation.table}) bypasses the durable state machine`,
+    )
+  }
+
+  if (baseline !== null && violations.length <= effectiveBaseline) {
+    console.log(
+      `check-test-fixtures: ${violations.length} hit(s) within baseline ${effectiveBaseline}; ratchet down over time`,
+    )
+    return
+  }
+
+  console.error(
+    [
+      "",
+      `check-test-fixtures: ${violations.length} violation(s). Test fixtures must not insert`,
+      "authority rows directly; drive them through the durable lifecycle helpers",
+      "(admission -> preparing -> prepared -> dispatching -> terminal).",
+      "Legacy crash-recovery fixtures may be annotated with a trailing",
+      "`// fixture-exempt: <reason>` comment on the matched line.",
+    ].join("\n"),
+  )
+  process.exit(1)
+}
+
+main()
diff --git a/script/live-llm-key-from-auth.ts b/script/live-llm-key-from-auth.ts
new file mode 100644
index 00000000..497a7aa5
--- /dev/null
+++ b/script/live-llm-key-from-auth.ts
@@ -0,0 +1,33 @@
+#!/usr/bin/env bun
+// REL gate helper: extract a provider API key from the local deepagent-code auth.json into a
+// permission-restricted key file consumable by the live-LLM harness
+// (DEEPAGENT_CODE_LIVE_LLM_API_KEY_FILE). NEVER prints key material — only paths and byte counts.
+//
+// Usage: bun script/live-llm-key-from-auth.ts [provider]   (default: deepseek)
+import { chmod, mkdir } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+const provider = process.argv[2] ?? "deepseek"
+const authPath = path.join(os.homedir(), ".deepagent", "code", "auth.json")
+
+const auth = (await Bun.file(authPath)
+  .json()
+  .catch(() => undefined)) as Record<string, { key?: string }> | undefined
+if (!auth) {
+  console.error(`unable to read ${authPath}`)
+  process.exit(1)
+}
+const entry = auth[provider]
+if (!entry?.key || typeof entry.key !== "string" || entry.key.length === 0) {
+  console.error(`no key for provider "${provider}" in ${authPath} (available: ${Object.keys(auth).join(", ")})`)
+  process.exit(1)
+}
+
+const outDir = path.join(os.homedir(), ".deepagent", "code", "tmp")
+await mkdir(outDir, { recursive: true })
+const outFile = path.join(outDir, `live-llm-${provider}.key`)
+await Bun.write(outFile, `${entry.key.trim()}\n`)
+await chmod(outFile, 0o600)
+console.log(`wrote ${outFile} (bytes=${entry.key.trim().length}, mode=600)`)
+console.log(`export DEEPAGENT_CODE_LIVE_LLM_API_KEY_FILE="${outFile}"`)
diff --git a/script/release-evidence.ts b/script/release-evidence.ts
new file mode 100644
index 00000000..92082510
--- /dev/null
+++ b/script/release-evidence.ts
@@ -0,0 +1,534 @@
+#!/usr/bin/env bun
+/**
+ * BUG-407-005 release-evidence tooling: archive immutable gate manifests and
+ * verify them against tampering.
+ *
+ * Layout (see release-evidence/README.md):
+ *   release-evidence/<version>/<commit>/<gate-id>/manifest.json
+ *
+ * Manifests are immutable. This tool never overwrites an existing manifest:
+ * re-running archive for the same version/commit/gate fails. Corrections or
+ * retries must create a new gate attempt (a new gate id) instead.
+ *
+ * Usage:
+ *   # Generate a gate manifest (fails if it already exists)
+ *   bun script/release-evidence.ts archive \
+ *     --gate release-gate-20260819 \
+ *     [--commit <sha>]            # default: git rev-parse HEAD
+ *     [--version v4.1]            # release line, default v4.1
+ *     [--date YYYY-MM-DD]         # gate date, default today (UTC)
+ *     [--status passed]           # passed|failed|blocked|not_run
+ *     [--summary "<text>"] \
+ *     [--evidence <kind>:<label>[:<path>]]...   # repeatable
+ *     [--conclusion <label>=<text>]...          # repeatable
+ *     [--sign <role>=<actor>]...                # repeatable
+ *     [--root <dir>]              # repo root, default: this script's parent
+ *
+ *   # Verify an existing manifest: file hashes match, nothing tampered
+ *   bun script/release-evidence.ts check --gate <gate-id> [--commit <sha>] [--version v4.1] [--root <dir>]
+ *   bun script/release-evidence.ts check <path/to/manifest.json>
+ */
+
+import { createHash } from "node:crypto"
+import * as fs from "node:fs"
+import * as path from "node:path"
+
+export const RELEASE_EVIDENCE_SCHEMA_VERSION = "deepagent.release_evidence.v1"
+export const EVIDENCE_DIRNAME = "release-evidence"
+export const MANIFEST_FILENAME = "manifest.json"
+
+export const EVIDENCE_KINDS = [
+  "test-summary",
+  "migration",
+  "smoke",
+  "live",
+  "capacity",
+  "log",
+  "db",
+  "request",
+  "ui",
+  "receipt",
+  "metric",
+] as const
+export type EvidenceKind = (typeof EVIDENCE_KINDS)[number]
+
+export const GATE_STATUSES = ["passed", "failed", "blocked", "not_run"] as const
+export type GateStatus = (typeof GATE_STATUSES)[number]
+
+export interface EvidenceEntry {
+  readonly kind: EvidenceKind
+  readonly label: string
+  readonly path: string | null
+  readonly sha256: string | null
+  readonly conclusion: string
+}
+
+export interface SignatureEntry {
+  readonly role: string
+  readonly actor: string
+  readonly at: string
+}
+
+export interface ReleaseEvidenceManifest {
+  readonly schema_version: typeof RELEASE_EVIDENCE_SCHEMA_VERSION
+  readonly version: string
+  readonly gate_id: string
+  readonly commit: string
+  readonly date: string
+  readonly generated_at: string
+  readonly status: GateStatus
+  readonly summary?: string
+  readonly evidence: readonly EvidenceEntry[]
+  readonly signatures: readonly SignatureEntry[]
+}
+
+export interface ArchiveOptions {
+  readonly root: string
+  readonly version: string
+  readonly gateID: string
+  readonly commit: string
+  readonly date: string
+  readonly generatedAt: string
+  readonly status: GateStatus
+  readonly summary?: string
+  readonly evidence: readonly EvidenceEntry[]
+  readonly signatures: readonly SignatureEntry[]
+}
+
+export interface CheckResult {
+  readonly ok: boolean
+  readonly manifestPath: string
+  readonly failures: readonly string[]
+}
+
+const GATE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/
+const LABEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/
+const COMMIT_PATTERN = /^[0-9a-f]{40}$/
+const VERSION_PATTERN = /^v[0-9]+\.[0-9]+$/
+const DATE_PATTERN = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/
+const SHA256_PATTERN = /^[0-9a-f]{64}$/
+
+export class ReleaseEvidenceError extends Error {}
+
+export function sha256Hex(buffer: Uint8Array | string): string {
+  return createHash("sha256").update(buffer).digest("hex")
+}
+
+export function sha256OfFile(filePath: string): string {
+  return sha256Hex(fs.readFileSync(filePath))
+}
+
+export function manifestPathFor(root: string, version: string, commit: string, gateID: string): string {
+  return path.join(root, EVIDENCE_DIRNAME, version, commit, gateID, MANIFEST_FILENAME)
+}
+
+/** Deterministic serialization: fixed key order, 2-space indent, trailing newline. */
+export function serializeManifest(manifest: ReleaseEvidenceManifest): string {
+  const body: Record<string, unknown> = {
+    schema_version: manifest.schema_version,
+    version: manifest.version,
+    gate_id: manifest.gate_id,
+    commit: manifest.commit,
+    date: manifest.date,
+    generated_at: manifest.generated_at,
+    status: manifest.status,
+  }
+  if (manifest.summary !== undefined) body.summary = manifest.summary
+  body.evidence = manifest.evidence.map((entry) => ({
+    kind: entry.kind,
+    label: entry.label,
+    path: entry.path,
+    sha256: entry.sha256,
+    conclusion: entry.conclusion,
+  }))
+  body.signatures = manifest.signatures.map((signature) => ({
+    role: signature.role,
+    actor: signature.actor,
+    at: signature.at,
+  }))
+  return `${JSON.stringify(body, null, 2)}\n`
+}
+
+export function buildManifest(options: ArchiveOptions): ReleaseEvidenceManifest {
+  return {
+    schema_version: RELEASE_EVIDENCE_SCHEMA_VERSION,
+    version: options.version,
+    gate_id: options.gateID,
+    commit: options.commit,
+    date: options.date,
+    generated_at: options.generatedAt,
+    status: options.status,
+    summary: options.summary,
+    evidence: options.evidence,
+    signatures: options.signatures,
+  }
+}
+
+/**
+ * Write the gate manifest. Fails when the target already exists — manifests
+ * are immutable and the tool offers no overwrite path.
+ */
+export function archiveGate(options: ArchiveOptions): string {
+  validateArchiveOptions(options)
+  const target = manifestPathFor(options.root, options.version, options.commit, options.gateID)
+  if (fs.existsSync(target)) {
+    throw new ReleaseEvidenceError(
+      [
+        `manifest already exists at ${path.relative(options.root, target)}`,
+        "release-evidence manifests are immutable: no overwrite is offered.",
+        "Record corrections or retries as a new gate attempt (new gate id).",
+      ].join("\n"),
+    )
+  }
+  const manifest = buildManifest(options)
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  fs.writeFileSync(target, serializeManifest(manifest), { flag: "wx" })
+  return target
+}
+
+/** Verify every file-backed evidence entry still matches its recorded SHA-256. */
+export function checkManifest(manifestPath: string): CheckResult {
+  const failures: string[] = []
+  if (!fs.existsSync(manifestPath)) {
+    return { ok: false, manifestPath, failures: [`manifest not found: ${manifestPath}`] }
+  }
+  const root = resolveEvidenceRoot(path.dirname(manifestPath))
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"))
+  } catch (error) {
+    return { ok: false, manifestPath, failures: [`manifest is not valid JSON: ${String(error)}`] }
+  }
+  if (!isRecord(parsed)) return { ok: false, manifestPath, failures: ["manifest root must be a JSON object"] }
+
+  if (parsed.schema_version !== RELEASE_EVIDENCE_SCHEMA_VERSION) {
+    failures.push(`unexpected schema_version: ${String(parsed.schema_version)}`)
+  }
+  for (const field of ["gate_id", "commit", "date", "status"] as const) {
+    if (typeof parsed[field] !== "string" || parsed[field] === "") failures.push(`missing or empty field: ${field}`)
+  }
+  if (!Array.isArray(parsed.evidence)) {
+    failures.push("missing evidence array")
+    return { ok: false, manifestPath, failures }
+  }
+
+  const seenLabels = new Set<string>()
+  for (const [index, raw] of parsed.evidence.entries()) {
+    const where = `evidence[${index}]`
+    if (!isRecord(raw)) {
+      failures.push(`${where}: entry must be an object`)
+      continue
+    }
+    const label = typeof raw.label === "string" ? raw.label : ""
+    if (label === "") failures.push(`${where}: missing label`)
+    else if (seenLabels.has(label)) failures.push(`${where}: duplicate label ${label}`)
+    seenLabels.add(label)
+    if (typeof raw.conclusion !== "string" || raw.conclusion === "") failures.push(`${where}: missing conclusion`)
+
+    const entryPath = raw.path ?? null
+    const recorded = raw.sha256 ?? null
+    if ((entryPath === null) !== (recorded === null)) {
+      failures.push(`${where}: path and sha256 must both be present or both be null`)
+      continue
+    }
+    if (entryPath === null) continue
+    if (typeof entryPath !== "string" || typeof recorded !== "string" || !SHA256_PATTERN.test(recorded)) {
+      failures.push(`${where}: malformed path or sha256`)
+      continue
+    }
+    const absolute = path.isAbsolute(entryPath) ? entryPath : path.join(root, entryPath)
+    if (!fs.existsSync(absolute)) {
+      failures.push(`${where} (${label || "?"}): file missing: ${entryPath}`)
+      continue
+    }
+    const actual = sha256OfFile(absolute)
+    if (actual !== recorded) {
+      failures.push(`${where} (${label || "?"}): sha256 mismatch for ${entryPath}: recorded ${recorded}, actual ${actual}`)
+    }
+  }
+
+  return { ok: failures.length === 0, manifestPath, failures }
+}
+
+/**
+ * Locate gate manifests for a gate id. With a commit, the path is exact;
+ * without one, every commit directory under the version line is searched.
+ */
+export function findManifestPaths(root: string, version: string, gateID: string, commit?: string): string[] {
+  if (commit !== undefined) {
+    const candidate = manifestPathFor(root, version, commit, gateID)
+    return fs.existsSync(candidate) ? [candidate] : []
+  }
+  const versionDir = path.join(root, EVIDENCE_DIRNAME, version)
+  let commits: string[] = []
+  try {
+    commits = fs
+      .readdirSync(versionDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+  } catch {
+    return []
+  }
+  const found: string[] = []
+  for (const commitDir of commits.sort()) {
+    const candidate = path.join(versionDir, commitDir, gateID, MANIFEST_FILENAME)
+    if (fs.existsSync(candidate)) found.push(candidate)
+  }
+  return found
+}
+
+export function resolveEvidenceRoot(startDir: string): string {
+  let dir = path.resolve(startDir)
+  for (;;) {
+    if (fs.existsSync(path.join(dir, EVIDENCE_DIRNAME))) return dir
+    const parent = path.dirname(dir)
+    if (parent === dir) return path.resolve(startDir)
+    dir = parent
+  }
+}
+
+function validateArchiveOptions(options: ArchiveOptions): void {
+  if (!VERSION_PATTERN.test(options.version)) throw new ReleaseEvidenceError(`invalid --version: ${options.version}`)
+  if (!GATE_ID_PATTERN.test(options.gateID)) throw new ReleaseEvidenceError(`invalid --gate: ${options.gateID}`)
+  if (!COMMIT_PATTERN.test(options.commit)) {
+    throw new ReleaseEvidenceError(`invalid --commit (need full 40-char lowercase sha): ${options.commit}`)
+  }
+  if (!DATE_PATTERN.test(options.date)) throw new ReleaseEvidenceError(`invalid --date: ${options.date}`)
+  if (!GATE_STATUSES.includes(options.status)) throw new ReleaseEvidenceError(`invalid --status: ${options.status}`)
+  const labels = new Set<string>()
+  for (const entry of options.evidence) {
+    if (!EVIDENCE_KINDS.includes(entry.kind)) throw new ReleaseEvidenceError(`invalid evidence kind: ${entry.kind}`)
+    if (!LABEL_PATTERN.test(entry.label)) throw new ReleaseEvidenceError(`invalid evidence label: ${entry.label}`)
+    if (labels.has(entry.label)) throw new ReleaseEvidenceError(`duplicate evidence label: ${entry.label}`)
+    labels.add(entry.label)
+    if (entry.conclusion === "") throw new ReleaseEvidenceError(`evidence ${entry.label}: conclusion is required`)
+    if ((entry.path === null) !== (entry.sha256 === null)) {
+      throw new ReleaseEvidenceError(`evidence ${entry.label}: path and sha256 must both be present or both be null`)
+    }
+  }
+}
+
+interface CliOptions {
+  root: string
+  version: string
+  gateID?: string
+  commit?: string
+  date?: string
+  status: GateStatus
+  summary?: string
+  generatedAtForTest?: string
+  evidenceSpecs: string[]
+  conclusions: Map<string, string>
+  signs: SignatureEntry[]
+}
+
+function parseCliArgs(argv: string[]): { command: "archive" | "check"; positional: string[]; options: CliOptions } {
+  const [command, ...rest] = argv
+  if (command !== "archive" && command !== "check") {
+    throw new ReleaseEvidenceError(`unknown command: ${command ?? "<missing>"} (expected archive or check)`)
+  }
+  const options: CliOptions = {
+    root: path.resolve(import.meta.dir, ".."),
+    version: "v4.1",
+    status: "passed",
+    evidenceSpecs: [],
+    conclusions: new Map(),
+    signs: [],
+  }
+  const positional: string[] = []
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i]!
+    const value = () => {
+      const next = rest[i + 1]
+      if (next === undefined) throw new ReleaseEvidenceError(`missing value for ${arg}`)
+      i += 1
+      return next
+    }
+    switch (arg) {
+      case "--root":
+        options.root = path.resolve(value())
+        break
+      case "--version":
+        options.version = value()
+        break
+      case "--gate":
+        options.gateID = value()
+        break
+      case "--commit":
+        options.commit = value()
+        break
+      case "--date":
+        options.date = value()
+        break
+      case "--status": {
+        const raw = value()
+        if (!GATE_STATUSES.includes(raw as GateStatus)) throw new ReleaseEvidenceError(`invalid --status: ${raw}`)
+        options.status = raw as GateStatus
+        break
+      }
+      case "--summary":
+        options.summary = value()
+        break
+      case "--generated-at":
+        options.generatedAtForTest = value()
+        break
+      case "--evidence":
+        options.evidenceSpecs.push(value())
+        break
+      case "--conclusion": {
+        const raw = value()
+        const separator = raw.indexOf("=")
+        if (separator <= 0) throw new ReleaseEvidenceError(`--conclusion expects <label>=<text>: ${raw}`)
+        options.conclusions.set(raw.slice(0, separator), raw.slice(separator + 1))
+        break
+      }
+      case "--sign": {
+        const raw = value()
+        const separator = raw.indexOf("=")
+        if (separator <= 0) throw new ReleaseEvidenceError(`--sign expects <role>=<actor>: ${raw}`)
+        options.signs.push({ role: raw.slice(0, separator), actor: raw.slice(separator + 1), at: "" })
+        break
+      }
+      default:
+        if (arg.startsWith("-")) throw new ReleaseEvidenceError(`unknown argument: ${arg}`)
+        positional.push(arg)
+    }
+  }
+  return { command, positional, options }
+}
+
+/** Parse `<kind>:<label>[:<path>]` into an evidence entry, hashing the file when present. */
+export function parseEvidenceSpec(spec: string, root: string, conclusion: string): EvidenceEntry {
+  const first = spec.indexOf(":")
+  if (first <= 0) throw new ReleaseEvidenceError(`--evidence expects <kind>:<label>[:<path>]: ${spec}`)
+  const kind = spec.slice(0, first)
+  const remainder = spec.slice(first + 1)
+  const second = remainder.indexOf(":")
+  const label = second === -1 ? remainder : remainder.slice(0, second)
+  const filePath = second === -1 ? undefined : remainder.slice(second + 1)
+  if (!EVIDENCE_KINDS.includes(kind as EvidenceKind)) {
+    throw new ReleaseEvidenceError(`unknown evidence kind: ${kind} (expected one of ${EVIDENCE_KINDS.join(", ")})`)
+  }
+  if (!LABEL_PATTERN.test(label)) throw new ReleaseEvidenceError(`invalid evidence label: ${label}`)
+  if (filePath === undefined || filePath === "") {
+    return { kind: kind as EvidenceKind, label, path: null, sha256: null, conclusion }
+  }
+  const absolute = path.resolve(root, filePath)
+  if (!fs.existsSync(absolute)) throw new ReleaseEvidenceError(`evidence file not found: ${filePath}`)
+  const display = absolute.startsWith(`${root}${path.sep}`) ? path.relative(root, absolute) : absolute
+  return { kind: kind as EvidenceKind, label, path: display, sha256: sha256OfFile(absolute), conclusion }
+}
+
+function gitHead(root: string): string {
+  const result = Bun.spawnSync(["git", "rev-parse", "HEAD"], { cwd: root })
+  if (result.exitCode !== 0) {
+    throw new ReleaseEvidenceError(
+      `cannot resolve git HEAD in ${root}; pass --commit explicitly\n${result.stderr.toString().trim()}`,
+    )
+  }
+  return result.stdout.toString().trim()
+}
+
+function requireGateID(options: CliOptions): string {
+  if (options.gateID === undefined) throw new ReleaseEvidenceError("--gate is required")
+  return options.gateID
+}
+
+async function runArchive(options: CliOptions): Promise<void> {
+  const gateID = requireGateID(options)
+  const commit = options.commit ?? gitHead(options.root)
+  const now = new Date()
+  const evidence = options.evidenceSpecs.map((spec) => {
+    const entry = parseEvidenceSpec(spec, options.root, "")
+    const conclusion = options.conclusions.get(entry.label)
+    if (conclusion === undefined) {
+      throw new ReleaseEvidenceError(`evidence ${entry.label}: missing --conclusion ${entry.label}=<text>`)
+    }
+    return { ...entry, conclusion }
+  })
+  for (const label of options.conclusions.keys()) {
+    if (!evidence.some((entry) => entry.label === label)) {
+      throw new ReleaseEvidenceError(`--conclusion ${label}: no matching --evidence entry`)
+    }
+  }
+  const target = archiveGate({
+    root: options.root,
+    version: options.version,
+    gateID,
+    commit,
+    date: options.date ?? now.toISOString().slice(0, 10),
+    generatedAt: options.generatedAtForTest ?? now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    status: options.status,
+    summary: options.summary,
+    evidence,
+    signatures: options.signs,
+  })
+  console.log(`release-evidence: archived gate ${gateID} at ${path.relative(options.root, target)}`)
+}
+
+function runCheck(options: CliOptions, positional: string[]): void {
+  let targets: string[]
+  if (positional.length > 0) {
+    targets = positional.map((entry) => path.resolve(entry))
+  } else {
+    const gateID = requireGateID(options)
+    targets = findManifestPaths(options.root, options.version, gateID, options.commit)
+    if (targets.length === 0) {
+      const where = options.commit
+        ? manifestPathFor(options.root, options.version, options.commit, gateID)
+        : path.join(options.root, EVIDENCE_DIRNAME, options.version, "<commit>", gateID, MANIFEST_FILENAME)
+      throw new ReleaseEvidenceError(`no manifest found for gate ${gateID} (expected ${where})`)
+    }
+  }
+  let failed = 0
+  for (const target of targets) {
+    const result = checkManifest(target)
+    if (result.ok) {
+      console.log(`release-evidence: OK ${path.relative(options.root, target) || target}`)
+      continue
+    }
+    failed += 1
+    console.error(`release-evidence: TAMPERED/INVALID ${path.relative(options.root, target) || target}`)
+    for (const failure of result.failures) console.error(`  - ${failure}`)
+  }
+  if (failed > 0) process.exit(1)
+}
+
+const USAGE = [
+  "usage:",
+  "  bun script/release-evidence.ts archive --gate <gate-id> [options]",
+  "  bun script/release-evidence.ts check --gate <gate-id> [--commit <sha>] [--version v4.1] [--root <dir>]",
+  "  bun script/release-evidence.ts check <path/to/manifest.json>",
+  "",
+  "options:",
+  "  --gate <id>                    gate id, e.g. release-gate-20260819",
+  "  --commit <sha>                 full commit sha (default: git rev-parse HEAD)",
+  "  --version <release>            release line (default v4.1)",
+  "  --date <YYYY-MM-DD>            gate date (default: today UTC)",
+  "  --status <s>                   passed|failed|blocked|not_run (default passed)",
+  "  --summary <text>               overall gate conclusion",
+  "  --evidence <kind>:<label>[:<path>]  evidence entry, repeatable",
+  "  --conclusion <label>=<text>    conclusion for an evidence entry, repeatable",
+  "  --sign <role>=<actor>          signature placeholder, repeatable",
+  "  --root <dir>                   repo root (default: script parent dir)",
+].join("\n")
+
+async function main(): Promise<void> {
+  try {
+    const { command, positional, options } = parseCliArgs(process.argv.slice(2))
+    if (command === "archive") await runArchive(options)
+    else runCheck(options, positional)
+  } catch (error) {
+    if (error instanceof ReleaseEvidenceError) {
+      console.error(`release-evidence: ${error.message}\n\n${USAGE}`)
+      process.exit(2)
+    }
+    throw error
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+if (import.meta.main) await main()
diff --git a/script/run-live-llm-all.ts b/script/run-live-llm-all.ts
index d6b3b7c4..17db6c01 100644
--- a/script/run-live-llm-all.ts
+++ b/script/run-live-llm-all.ts
@@ -5,6 +5,12 @@ import os from "node:os"
 import path from "node:path"
 import { parseArgs } from "node:util"
 import { validateLiveLLMKeyFile } from "../packages/llm/script/live-llm/config"
+import {
+  matchRegisteredLiveLLMProvider,
+  recommendedLiveLLMKeyFile,
+  resolveLiveLLMProvider,
+  type ResolvedLiveLLMProvider,
+} from "../packages/deepagent-code/script/live-llm/providers"
 
 export type RunnerConfig = {
   baseURL: string
@@ -509,23 +515,31 @@ export function runnerEnvironment(
 export function validateRunnerConfig(input: unknown, baseDirectory = repository): RunnerConfig {
   if (!isRecord(input)) throw new Error("Live LLM config must be a JSON object")
   if ("apiKey" in input) {
+    const recommendedProviderID =
+      (typeof input.baseURL === "string" ? matchRegisteredLiveLLMProvider(input.baseURL)?.id : undefined) ??
+      "deepseek"
     throw new Error(
       "Legacy live LLM JSON field apiKey is not accepted; move the key to a chmod 600 one-line file and " +
-        "set apiKeyFile (recommended: ~/.deepagent/code/tmp/live-llm-deepseek.key)",
+        `set apiKeyFile (recommended: ${recommendedLiveLLMKeyFile(recommendedProviderID)})`,
     )
   }
   const baseURL = requiredString(input.baseURL, "baseURL")
-  if (!URL.canParse(baseURL)) throw new Error("baseURL must be a valid URL")
-  const endpoint = new URL(baseURL)
-  if (endpoint.protocol !== "https:" || endpoint.hostname !== "api.deepseek.com") {
-    throw new Error(
-      `Real LLM suites currently require the official https://api.deepseek.com endpoint, received ${baseURL}`,
-    )
+  const provider = resolveLiveLLMProvider(baseURL)
+  const explicitProviderID = optionalProviderID(input.providerID)
+  if (explicitProviderID && explicitProviderID !== provider.id) {
+    if (provider.registered) {
+      throw new Error(
+        `providerID "${explicitProviderID}" does not match the official ${provider.label} endpoint ` +
+          `${provider.baseURL} (providerID: ${provider.id})`,
+      )
+    }
+    provider.id = explicitProviderID
+    provider.label = explicitProviderID
   }
   const apiKeyFile = resolveKeyFile(requiredString(input.apiKeyFile, "apiKeyFile"), baseDirectory)
   const modelRevision = optionalString(input.modelRevision)
   return {
-    baseURL: baseURL.replace(/\/$/, ""),
+    baseURL: provider.baseURL,
     apiKeyFile,
     model: requiredString(input.model, "model"),
     ...(modelRevision ? { modelRevision } : {}),
@@ -536,6 +550,15 @@ export function validateRunnerConfig(input: unknown, baseDirectory = repository)
   }
 }
 
+/**
+ * Resolves the provider fingerprint from a validated runner config. The identifier is
+ * derived from the endpoint registry (never hardcoded), so evidence reports record the
+ * actual provider that served the suites.
+ */
+export function runnerProvider(config: Pick<RunnerConfig, "baseURL">): ResolvedLiveLLMProvider {
+  return resolveLiveLLMProvider(config.baseURL)
+}
+
 export async function validateSuiteManifest() {
   const inventory = await loadRealLLMSuiteInventory()
   const registered = suites
@@ -580,6 +603,37 @@ export async function loadRealLLMSuiteInventory() {
   ).flat()
 }
 
+// QUAL-004: validateSuiteManifest only covers real-LLM suites; this closes
+// the remaining drift surface by checking EVERY registry entry that runs a
+// package script (`bun run <script>` or an explicit packageScript) against
+// the owning package.json. Suites invoking files directly (node ./scripts/…)
+// own their path and are skipped. Called before dry-run listing so stale
+// registry entries fail fast instead of dying mid-run.
+export async function validateRegistryScripts() {
+  const scripts = new Map<string, Set<string>>()
+  for (const packageName of ["llm", "core", "deepagent-code", "desktop"] as const) {
+    const payload: unknown = await Bun.file(path.join(repository, "packages", packageName, "package.json")).json()
+    if (!isRecord(payload) || !isRecord(payload.scripts)) {
+      throw new Error(`packages/${packageName}/package.json does not contain a scripts object`)
+    }
+    scripts.set(packageName, new Set(Object.keys(payload.scripts)))
+  }
+  const drift: string[] = []
+  for (const suite of suites) {
+    if (suite.package === "root") continue
+    const scriptName =
+      suite.packageScript ??
+      (suite.command[0] === "bun" && suite.command[1] === "run" ? suite.command[2] : undefined)
+    if (!scriptName) continue
+    if (!scripts.get(suite.package)?.has(scriptName)) {
+      drift.push(`${suite.id} → ${suite.package}:${scriptName}`)
+    }
+  }
+  if (drift.length) {
+    throw new Error(`Suite registry references package scripts that do not exist: ${drift.join(", ")}`)
+  }
+}
+
 async function main() {
   const options = parseArgs({
     args: Bun.argv.slice(2),
@@ -601,7 +655,9 @@ async function main() {
     )
   }
   const config = validateRunnerConfig(await Bun.file(configFile).json(), path.dirname(configFile))
+  const provider = runnerProvider(config)
   await validateSuiteManifest()
+  await validateRegistryScripts()
   if (!options["dry-run"]) await validateLiveLLMKeyFile(config.apiKeyFile)
   const selected = selectSuites({
     headless: options.headless,
@@ -612,7 +668,7 @@ async function main() {
   const realCount = selected.filter((suite) => suite.realLLM).length
   console.log(
     `Real LLM all-tests: ${selected.length} commands (${realCount} model suites), ` +
-      `model=${config.model}, endpoint=${config.baseURL}`,
+      `provider=${provider.id}, model=${config.model}, endpoint=${config.baseURL}`,
   )
   if (options["dry-run"]) {
     selected.forEach((suite, index) => console.log(`${index + 1}. ${suite.id}: ${suite.command.join(" ")}`))
@@ -713,7 +769,7 @@ async function main() {
             ? "passed"
             : "failed",
         fingerprint: {
-          providerID: "deepseek",
+          providerID: provider.id,
           baseURL: config.baseURL,
           modelID: config.model,
           modelRevision: config.modelRevision,
@@ -823,6 +879,16 @@ function optionalString(value: unknown) {
   return value.trim() || undefined
 }
 
+function optionalProviderID(value: unknown) {
+  if (value === undefined || value === null || value === "") return undefined
+  if (typeof value !== "string") throw new Error("providerID must be a string")
+  const trimmed = value.trim()
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(trimmed)) {
+    throw new Error("providerID must match /^[a-z0-9][a-z0-9_-]*$/")
+  }
+  return trimmed
+}
+
 function integer(value: unknown, name: string, minimum: number, maximum: number) {
   if (!Number.isSafeInteger(value) || (value as number) < minimum || (value as number) > maximum) {
     throw new Error(`${name} must be an integer between ${minimum} and ${maximum}`)