Merge remote-tracking branch 'origin/master' into codex/provider-retry-policy

# Conflicts: # docs/architecture.i18n.yaml # docs/event-producer-consumer.md # docs/module-graph.md # packages/examples/acp-demo/README.md # packages/llm/llm-deepseek/README.md # packages/ui/acp/src/index.ts # packages/ui/acp/tests/stream-update.spec.ts
2026-07-25 13:38:09 +08:00
parent 015ba14bae 26351332e9
commit da54a61639
637 changed files with 13106 additions and 24144 deletions
--- a/packages/examples/README.md
+++ b/packages/examples/README.md
@@ -7,12 +7,12 @@ Pre-composed plugin bundles a thin leaf `cordis.yml` loads instead of assembling
 | `agent-spine-demo/` | `@deepseek-ai/dsh-agent-spine-demo` | The executor-less/UI-less agent spine as one bundle plugin, with fallback session titles and an opt-in persisted-goal stack |
 | `tui-demo/` | `@deepseek-ai/dsh-tui-demo` | Full-screen terminal app: the spine + persisted goals + `/goal` command + JSONL persistence + `dsh-tui` + a pre-created `main` agent, with a boot `bin` |
 | `cli-demo/` | `@deepseek-ai/dsh-cli-demo` | Headless one-shot app: the spine + JSONL persistence + a pre-created `main` agent, with text and DSH-native JSON output |
-| `acp-demo/` | `@deepseek-ai/dsh-acp-demo` | ACP server app: the spine + persisted goals + `/goal` command + JSONL persistence + the [`acp`](../ui/acp/README.md) bridge (no stdout logger), with a boot `bin` |
+| `acp-demo/` | `@deepseek-ai/dsh-acp-demo` | ACP automation server app: the spine + persisted goals + JSONL persistence + the [`acp`](../acp/acp/README.md) bridge (no stdout logger), with a boot `bin` |
 | `jsonrpc-demo/` | `@deepseek-ai/dsh-jsonrpc-demo` | Bin-only runtime that boots an external `cordis.yml` for the stdio JSON-RPC SDK client |

-`agent-spine-demo` is the shared bundle; `tui-demo`, `cli-demo`, and `acp-demo` compose it with full-screen terminal, headless one-shot, and ACP front doors and own their boot bins. `jsonrpc-demo` mounts no composition of its own — it boots whatever tree the deployment's `cordis.yml` names, and is what the Python SDK runtime launches.
+`agent-spine-demo` is the shared bundle; `tui-demo`, `cli-demo`, and `acp-demo` compose it with full-screen terminal, headless one-shot, and ACP automation front doors and own their boot bins. `jsonrpc-demo` mounts no composition of its own — it boots whatever tree the deployment's `cordis.yml` names, and is what the Python SDK runtime launches.

-These are **not** product API. The spine pieces they bundle live in [`core/`](../core/README.md), the bridges/channels/boot-glue in [`ui/`](../ui/README.md), and the swappable backends (LLM adapter, bash executor) in their capability groups; a demo bundle just picks one concrete composition of them. Swap or fork one freely.
+These are **not** product API. The spine pieces they bundle live in [`core/`](../core/README.md), human/SDK channels and boot glue in [`ui/`](../ui/README.md), the automation transport in [`acp/`](../acp/README.md), and swappable backends in their capability groups; a demo bundle just picks one concrete composition of them. Swap or fork one freely.

 Do not confuse this group with the repo-root [`examples/`](../../examples/AGENTS.md): that directory holds the runnable `cordis.yml` **leaves**; this group holds the **bundles** those leaves load.

--- a/packages/examples/acp-demo/README.md
+++ b/packages/examples/acp-demo/README.md
@@ -1,76 +1,56 @@
 # @deepseek-ai/dsh-acp-demo

-The **ACP server app**: a Cordis app plugin that composes the default agent spine ([`@deepseek-ai/dsh-agent-spine-demo`](../agent-spine-demo/README.md)) with the front-door cluster an [Agent Client Protocol](../../ui/acp/README.md) server needs, and a `bin` that boots a leaf `cordis.yml` speaking ACP JSON-RPC on stdio.
+ACP automation server app: the default agent spine, client-created agents through [`@deepseek-ai/dsh-acp`](../../acp/acp/README.md), JSONL persistence, and semantic checkpointing behind one JSON-RPC stdio bin. Programmatic clients create fresh sessions; this package mounts no human UI.

-It is the structured counterpart to [`@deepseek-ai/dsh-tui-demo`](../tui-demo/README.md): both consume the same spine, but ACP creates sessions from its client and reserves stdout for its wire protocol.
+## Composition

-## What it bakes in — and what it deliberately omits
-
-stdout is the ACP JSON-RPC channel, so the cluster is defined as much by what it LEAVES OUT as what it includes:
-
-| Plugin | Why |
+| Plugin | Role |
 |---|---|
-| `@deepseek-ai/dsh-agent-spine-demo` | the spine, pre-creating **no** agents (ACP `session/new` creates them on demand) |
-| `@deepseek-ai/dsh-commands` | the human-command registry used for ACP discovery and direct slash dispatch |
-| `@deepseek-ai/dsh-command-goal` | the discoverable direct `/goal` producer; the app enables the spine's persisted-goal stack with it |
-| `@deepseek-ai/dsh-user-interaction` | the human question/answer seam used by clients that can complete ACP elicitation requests |
-| `@deepseek-ai/dsh-session-persistence-jsonl` | durable JSONL session log (the bridge advertises `loadSession`) |
-| `@deepseek-ai/dsh-session-query-sqlite` + `@deepseek-ai/dsh-session-reference` | combined exact/FTS session queries and bounded `dsh-session:` snapshots |
-| `@deepseek-ai/dsh-session-checkpoint-policy` | semantic durability barriers before model requests and top-level tool effects, plus completed-step checkpoints |
-| `@deepseek-ai/dsh-acp` | the bridge that owns stdout for JSON-RPC and provides ACP-backed user answers when a leaf explicitly exposes a user-question tool |
-| ~~`@deepseek-ai/dsh-tool-ask-user`~~ | **omitted by default** — ACP elicitation support is still client-dependent, so leaves must opt in deliberately |
-| ~~`@deepseek-ai/dsh-user-approval`~~ | **omitted by default** — permission policy is deployment-specific; sandbox/approval leaves opt in and the ACP bridge then supplies the answerer |
-| ~~console logger~~ | **omitted** — it writes to stdout and would corrupt the protocol frames ([the stdout-purity footgun](../../ui/acp/README.md)) |
-| ~~`hmr`~~ | **omitted** — the editor owns the subprocess |
+| `@deepseek-ai/dsh-agent-spine-demo` | Providerless agent spine with no pre-created agents; `session/new` creates each agent. |
+| `@deepseek-ai/dsh-session-persistence-jsonl` | Durable session logs used by checkpointing, observability, and snapshot replay. |
+| `@deepseek-ai/dsh-session-checkpoint-policy` | Durability barriers before model calls and top-level tool effects, plus completed-step checkpoints. |
+| `@deepseek-ai/dsh-acp` | Automation-only ACP transport over stdin/stdout. |

-The app owns this cluster through one ordered Cordis effect. Teardown drains the ACP bridge before removing the checkpoint policy or persistence backend, so a graceful disconnect persists the real closing `step/end` and `turn/end` events rather than leaving crash recovery to synthesize them. Because the package wires no logger entry, an ACP leaf has **nothing to get wrong by default**: it only picks backends. A leaf author can still add `@cordisjs/plugin-logger-console` as a sibling entry, so the rule remains: never add a stdout logger to an ACP leaf; use a stderr exporter instead.
+The app does not install commands, user interaction, session navigation, configuration pickers, or a stdout logger. It owns the four plugins through one ordered effect so ACP sessions quiesce before checkpointing and persistence detach. Leaf configurations supply LLM, executor, sandbox, approval, filesystem, and model-facing tool plugins.

 ## Config

 | Key | Default | Routed to |
 |---|---|---|
-| `provider` | (required) | the initial provider route for each per-session agent the bridge creates; ACP model selection may replace it per session |
-| `model` | (required) | the initial model for each per-session agent; ACP clients may switch among adapter-advertised models |
-| `maxParallelToolCalls` | agent-loop default | positive-integer concurrent tool-call cap shared by the bundled loop's agents; `1` is serial |
-| `persona` | — | the deployment persona template (may reference `{{provider}}`/`{{model}}`/`{{cwd}}`), routed to `dsh-system-prompt` |
-| `toolOrder` | — | explicit model-facing tool order (a name list with one `'<unlisted-tools>'` rest entry; absent — lexicographic; an unregistered name fails each turn at prompt assembly), routed to `dsh-system-prompt` |
-| `dshHome` | `$DSH_HOME` or `~/.dsh` | Harness home exposed to model bash and used by local skill discovery |
-| `sessionTitle` | spine example limits | fallback title word/byte limits routed through `dsh-agent-spine-demo` |
-| `tools` | `{ mode: 'native' }` | tool-registry presentation config (`native` / `code` / `both`), routed through `dsh-agent-spine-demo` |
-| `workspaceContext` | (required) | workspace-instruction byte budget/config, or `false`; routed to the providerless-safe `dsh-workspace-context` plugin |
-| `skills` | owner defaults | registry-cache, local-provider, and model-facing skill-tool config, routed through `dsh-agent-spine-demo` |
-| `toolBash` | owner defaults | model-facing bash config routed through `dsh-agent-spine-demo`, including bash's producer-local `enableRunInBackground` |
-| `toolTasks` | owner defaults | generic `task_output` wait bounds routed through `dsh-agent-spine-demo` |
-| `goals` | owner defaults | persisted goal-domain and model-tool config; `false` removes the goal stack and `/goal` producer |
-| `persistenceRoot` | `./.sessions` | the JSONL backend's root directory and the parent of the derived `session-query.db` index |
-| `packChunks` | `false` | write delta-chunk runs as packed storage rows (the JSONL backend's `packChunks`) |
-| `persistenceCompression` | `'zstd'` | JSONL artifact encoding (`'zstd'` or raw `'none'`) |
-| `sessionReferences` | service defaults | cross-session candidate and snapshot limits routed to `dsh-session-reference` |
+| `provider` | required | Provider route for each ACP-created agent. |
+| `model` | required | Model for each ACP-created agent. |
+| `maxParallelToolCalls` | agent-loop default | Positive-integer tool-call concurrency cap; `1` is serial. |
+| `persona` | — | Deployment persona template for `dsh-system-prompt`. |
+| `toolOrder` | lexicographic | Explicit model-facing tool order for `dsh-system-prompt`. |
+| `tools` | `{ mode: 'native' }` | Native, Code Mode, or combined model tool transport. |
+| `dshHome` | `$DSH_HOME` or `~/.dsh` | Harness home shared by bash and local skill discovery. |
+| `sessionTitle` | spine example limits | Durable fallback-title limits; titles remain off the ACP wire. |
+| `persistenceRoot` | `./.sessions` | JSONL backend root. |
+| `packChunks` | `false` | Pack consecutive delta-chunk events in storage. |
+| `persistenceCompression` | `zstd` | Checksummed Zstandard frames or raw `none`. |
+| `workspaceContext` | required | Workspace-instruction byte budget/config, or `false`. |
+| `skills` | owner defaults | Skill registry, local provider, and model-facing skill tool. |
+| `toolBash` | owner defaults | Model-facing bash tool config. |
+| `toolTasks` | owner defaults | Generic background-task control config, or `false`. |
+| `goals` | owner defaults | Persisted same-session goal domain and model tools, or `false`. |
+| `llmRetry` | owner defaults | Provider-owned normal or unbounded model-request retry policy. |

-The leaf supplies the swappable backends: an LLM adapter (`llm-deepseek` for the real model, `llm-replay` for keyless snapshot replay), a bash executor, and optionally a `ctx.fs` provider. Workspace context becomes a no-op without `ctx.fs`; the shipped [`examples/acp-agent/cordis.yml`](../../../examples/acp-agent/cordis.yml) selects `dsh-sandbox-policy`, `dsh-fs-sandbox`, `dsh-fs-policy`, and `dsh-tool-fs` so baseline instructions and model-facing `read`/`write`/`edit` share one provider, sandbox mode, workspace root, and observed-version policy.
+The shipped [`examples/acp-agent/cordis.yml`](../../../examples/acp-agent/cordis.yml) adds the DeepSeek adapter, sandboxed bash and filesystem providers, one-shot approval policy, compaction, subagents, workflows, hooks, and model-facing tools. Snapshot overlays replace only nondeterministic providers or policy values.

-## The bin
+## Bin

-`dsh-acp-demo [--config path-to-cordis.yml]` (short form `-c`; default `./cordis.yml`):
-
- loads a gitignored `.env` from the cwd — **skipped** in snapshot REPLAY so a stray key can never trigger a live call;
- honors `DSH_SNAPSHOT=replay` by booting the sibling `cordis.snapshot.yml` (the keyless replay tree, `llm-replay` in place of `llm-deepseek`);
- in a snapshot run, disposes the context on stdin EOF so the session log is fully flushed before exit.
-
-The repository installs Loader's optional `node-addon-require-builtin` peer, so the built bin resolves bare plugin specifiers through the internal module loader under plain Node. (`demo:acp` runs under tsx, whose tsconfig `paths` map resolves them instead.)
-
-All diagnostics go to **stderr** — stdout is the protocol.
+`dsh-acp-demo [--config path-to-cordis.yml]` (short form `-c`; default `./cordis.yml`) loads the gitignored `.env`, except in replay mode; `DSH_SNAPSHOT=replay` selects the sibling `cordis.snapshot.yml`; stdin EOF disposes the context and flushes sessions before exit. Loader's installed optional `node-addon-require-builtin` peer resolves bare plugin specifiers for the built bin under plain Node. Diagnostics use stderr because stdout is the ACP wire.

 ## Model Experience

-Indirectly, through `dsh-agent-spine-demo` and `dsh-acp`, which compose each ACP agent's prompt, goal tools, and message history. Direct `/goal` input and output remain outside the model, while accepted mutations append domain-owned model-visible snapshots.
+Indirectly, through `dsh-agent-spine-demo` and the leaf's model-facing plugins. ACP prompt text becomes the ordinary logged user message; protocol metadata and permission choices do not enter the model request.

 #### KV Cache effect

-No direct invalidation; the named consumer owns any request-prefix changes.
+Append-only per session; the app adds no request-prefix content itself.

 ## Known Limitations and Deferred Work

- **JSONL persistence is baked in** — config chooses its root but cannot select a different backend; that requires a sibling entry or differently composed app package.
- **User-question and approval mechanisms are omitted by default** — the bridge can answer both when their services/tools are composed, but this front door does not enable those deployment policies itself.
- **A leaf can still corrupt stdout** — the app mounts no console logger, but it cannot prevent a sibling leaf entry from writing non-protocol bytes to the ACP channel.
+- **JSONL persistence is fixed** — a different backend requires another composition.
+- **Sibling plugins can corrupt stdout** — the app cannot prevent another entry from writing non-protocol bytes.
+- **Fresh automation sessions only** — resume and human interaction belong to other front doors.
--- a/packages/examples/acp-demo/package.json
+++ b/packages/examples/acp-demo/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@deepseek-ai/dsh-acp-demo",
-  "description": "ACP server app: agent spine + human commands + JSONL persistence + ACP bridge (no stdout logger, hmr, or pre-created agents), with a JSON-RPC stdio bin",
+  "description": "ACP automation server app: agent spine + JSONL persistence + ACP transport, with a JSON-RPC stdio bin",
  "version": "0.0.1",
  "private": true,
  "type": "module",
@@ -38,18 +38,12 @@
    "@cordisjs/plugin-include": "^1.0.4",
    "@cordisjs/plugin-loader": "^1.0.0-rc.5",
    "@deepseek-ai/dsh-acp": "^0.0.1",
-    "@deepseek-ai/dsh-commands": "^0.0.1",
-    "@deepseek-ai/dsh-command-goal": "^0.0.1",
    "@deepseek-ai/dsh-agent-spine-demo": "^0.0.1",
    "@deepseek-ai/dsh-app-boot": "^0.0.1",
    "@deepseek-ai/dsh-invariants": "^0.0.1",
    "@deepseek-ai/dsh-session-checkpoint-policy": "^0.0.1",
    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.0.1",
-    "@deepseek-ai/dsh-session-query": "^0.0.1",
-    "@deepseek-ai/dsh-session-query-sqlite": "^0.0.1",
-    "@deepseek-ai/dsh-session-reference": "^0.0.1",
    "@deepseek-ai/dsh-tools": "^0.0.1",
-    "@deepseek-ai/dsh-user-interaction": "^0.0.1",
    "@deepseek-ai/dsh-workspace-context": "^0.0.1",
    "cordis": "^4.0.0-rc.7",
    "schemastery": "^3.17.0"
@@ -58,20 +52,14 @@
    "@cordisjs/plugin-include": "workspace:^",
    "@cordisjs/plugin-loader": "workspace:^",
    "@deepseek-ai/dsh-acp": "workspace:^",
-    "@deepseek-ai/dsh-commands": "workspace:^",
-    "@deepseek-ai/dsh-command-goal": "workspace:^",
    "@deepseek-ai/dsh-agent": "workspace:^",
    "@deepseek-ai/dsh-agent-spine-demo": "workspace:^",
    "@deepseek-ai/dsh-app-boot": "workspace:^",
    "@deepseek-ai/dsh-invariants": "workspace:^",
    "@deepseek-ai/dsh-session-checkpoint-policy": "workspace:^",
    "@deepseek-ai/dsh-session-persistence-jsonl": "workspace:^",
-    "@deepseek-ai/dsh-session-query": "workspace:^",
-    "@deepseek-ai/dsh-session-query-sqlite": "workspace:^",
-    "@deepseek-ai/dsh-session-reference": "workspace:^",
    "@deepseek-ai/dsh-system-prompt": "workspace:^",
    "@deepseek-ai/dsh-tools": "workspace:^",
-    "@deepseek-ai/dsh-user-interaction": "workspace:^",
    "@deepseek-ai/dsh-workspace-context": "workspace:^",
    "cordis": "^4.0.0-rc.7",
    "schemastery": "^3.17.0"
--- a/packages/examples/acp-demo/src/bin.ts
+++ b/packages/examples/acp-demo/src/bin.ts
@@ -5,7 +5,7 @@
 * loading, Loader guards, snapshot config selection, and settled-tree boot live
 * in dsh-app-boot. Replay skips `.env` and selects sibling
 * `cordis.snapshot.yml` so a stray key cannot trigger a model call. EOF disposes
- * and flushes snapshot runs; editors normally own process lifetime. Stdout is
+ * and flushes snapshot runs; the calling automation owns process lifetime. Stdout is
 * reserved for JSON-RPC, so diagnostics go only to stderr.
 * @module @deepseek-ai/dsh-acp-demo/bin
 */
--- a/packages/examples/acp-demo/src/index.ts
+++ b/packages/examples/acp-demo/src/index.ts
@@ -1,7 +1,7 @@
 /**
- * The ACP server app: the default agent spine ({@link @deepseek-ai/dsh-agent-spine-demo}),
- * human-command registry, JSONL session persistence, and the
- * {@link @deepseek-ai/dsh-acp} bridge. The app owns those plugins through one
+ * The ACP automation server app: the default agent spine
+ * ({@link @deepseek-ai/dsh-agent-spine-demo}), JSONL session persistence, and
+ * the {@link @deepseek-ai/dsh-acp} bridge. The app owns those plugins through one
 * ordered lifecycle so ACP sessions quiesce before persistence detaches. It
 * writes nothing to stdout.
 * It pre-creates no agents and leaves adapters, executors, and optional tools to
@@ -12,11 +12,8 @@
 */

 import type { Context } from 'cordis'
-import { join } from 'node:path'
 import z from 'schemastery'
 import * as acp from '@deepseek-ai/dsh-acp'
-import CommandService from '@deepseek-ai/dsh-commands'
-import * as commandGoal from '@deepseek-ai/dsh-command-goal'
 import * as agentCore from '@deepseek-ai/dsh-agent-spine-demo'
 import * as workspaceContext from '@deepseek-ai/dsh-workspace-context'
 import ToolRegistry, { type Config as ToolsConfig } from '@deepseek-ai/dsh-tools'
@@ -25,17 +22,13 @@ import SessionPersistenceJsonl, {
  type JsonlCompression,
 } from '@deepseek-ai/dsh-session-persistence-jsonl'
 import * as sessionCheckpointPolicy from '@deepseek-ai/dsh-session-checkpoint-policy'
-import UserInteractionService from '@deepseek-ai/dsh-user-interaction'
-import SessionQuerySqlite from '@deepseek-ai/dsh-session-query-sqlite'
-import SessionReferenceService, { type Config as SessionReferenceConfig } from '@deepseek-ai/dsh-session-reference'

 export const name = 'acp-demo'
 const DEFAULT_PERSISTENCE_ROOT = './.sessions'

 /**
- * App config: the swappable per-deployment values. `provider` and `model` configure the
- * agent template the ACP bridge creates each session's agent from (NOT a
- * pre-created agent — ACP creates agents at `session/new`); `persona` is the
+ * App config: the swappable per-deployment values. `provider` and `model` configure
+ * each agent the ACP bridge creates at `session/new`; `persona` is the
 * deployment persona (forwarded to the system-prompt plugin); `toolOrder` is
 * the explicit model-facing tool order (forwarded to the system-prompt plugin);
 * `tools` is the tool registry's config (its presentation `mode`, forwarded
@@ -58,14 +51,12 @@ export interface Config {
  dshHome?: string
  /** Fallback session-title limits forwarded through agent-spine-demo. */
  sessionTitle?: NonNullable<agentCore.Config['sessionTitle']>
-  /** Directory for JSONL sessions and the derived query index. Defaults to `./.sessions`. */
+  /** Directory for JSONL sessions. Defaults to `./.sessions`. */
  persistenceRoot?: string
  /** Write delta-chunk runs as packed storage rows (the JSONL backend's `packChunks`). Defaults to `false`. */
  packChunks?: boolean
  /** JSONL artifact encoding; defaults to checksummed Zstandard frames. */
  persistenceCompression?: JsonlCompression
-  /** Cross-session reference discovery and snapshot byte budgets. */
-  sessionReferences?: SessionReferenceConfig
  /** Controls automatic AGENTS.md/CLAUDE.md loading; configure a byte budget or set `false`. */
  workspaceContext: agentCore.Config['workspaceContext']
  /** Skill registry, local-provider, and model-facing consumer config forwarded to agent-spine-demo. */
@@ -74,7 +65,7 @@ export interface Config {
  toolBash?: NonNullable<agentCore.Config['toolBash']>
  /** Generic background-task controls forwarded through agent-core; set false to omit their tool surface. */
  toolTasks?: NonNullable<agentCore.Config['toolTasks']>
-  /** Persisted same-session goals; owner defaults enable them, or false disables the stack and command. */
+  /** Persisted same-session goals; owner defaults enable them, or false disables the stack and tools. */
  goals?: agentCore.GoalConfig | false
 }

@@ -96,7 +87,6 @@ export const Config: z<Config> = z.object({
  persistenceRoot: z.string().default(DEFAULT_PERSISTENCE_ROOT),
  packChunks: z.boolean().default(false),
  persistenceCompression: JsonlCompressionSchema,
-  sessionReferences: SessionReferenceService.Config,
  workspaceContext: z.union([z.const(false), workspaceContext.Config]).required(),
  skills: agentCore.SkillConfigSchema,
  toolBash: agentCore.ToolBashConfigSchema,
@@ -106,9 +96,9 @@ export const Config: z<Config> = z.object({
 /* jscpd:ignore-end */

 /**
- * Compose the spine with the ACP front door. The agent-spine-demo bundle pre-creates
+ * Compose the spine with the ACP automation transport. The agent-spine-demo bundle pre-creates
 * NO agents (its `agents` list defaults to `[]`) and carries the deployment
- * `persona`; the JSONL backend and derived query index persist under
+ * `persona`; the JSONL backend persists under
 * `persistenceRoot`; the ACP bridge owns stdout for JSON-RPC and creates one
 * agent per `session/new` from the provider/model pair. The composite effect
 * unloads in reverse order, keeping checkpoint and persistence listeners
@@ -119,10 +109,7 @@ export function apply(ctx: Context, config: Config): void {
  const goals = config.goals ?? {}
  const persistenceRoot = config.persistenceRoot ?? DEFAULT_PERSISTENCE_ROOT
  ctx.effect(function* () {
-    yield ctx.plugin(CommandService).dispose
-    if (goals !== false) yield ctx.plugin(commandGoal).dispose
    yield ctx.plugin(agentCore, { ...agentCore.pickSpineConfig(config), goals }).dispose
-    yield ctx.plugin(UserInteractionService).dispose
    // Same rationale as the Config schema above: each front door forwards its own
    // persistence passthroughs rather than sharing a facade with stdio-demo.
    /* jscpd:ignore-start */
@@ -133,8 +120,6 @@ export function apply(ctx: Context, config: Config): void {
    }).dispose
    /* jscpd:ignore-end */
    yield ctx.plugin(sessionCheckpointPolicy).dispose
-    yield ctx.plugin(SessionQuerySqlite, { path: join(persistenceRoot, 'session-query.db') }).dispose
-    yield ctx.plugin(SessionReferenceService, config.sessionReferences ?? {}).dispose
    yield ctx.plugin(acp, { provider: config.provider, model: config.model }).dispose
  }, 'acp-demo.composition')
 }
--- a/packages/examples/acp-demo/tests/acp-agent.spec.ts
+++ b/packages/examples/acp-demo/tests/acp-agent.spec.ts
@@ -5,7 +5,6 @@ import { tmpdir } from 'node:os'
 import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
 import { agentEvents, type Agent } from '@deepseek-ai/dsh-agent'
-import { SessionId } from '@deepseek-ai/dsh-session'
 import { TOOL_ORDER_REST } from '@deepseek-ai/dsh-system-prompt'
 import type { Message } from '@deepseek-ai/dsh-llm'
 import * as acpAgent from '../src/index.ts'
@@ -84,32 +83,27 @@ describe('dsh-acp-demo composition', () => {
      persona: 'hi',
      persistenceRoot: '/tmp/dsh-acp-demo-test',
      persistenceCompression: 'none',
-      sessionReferences: { candidateLimit: 1 },
      skills: await isolatedSkillsConfig(),
      workspaceContext: false,
    })
    expect(ctx.get('agents')).toBeDefined()
    expect(ctx.get('sessions')).toBeDefined()
    expect(ctx.get('sessionPersistence')).toBeDefined()
-    expect(ctx.get('sessionQuery')).toBeDefined()
-    expect(ctx.get('sessionReferences')).toBeDefined()
+    expect(ctx.get('sessionQuery')).toBeUndefined()
+    expect(ctx.get('sessionReferences')).toBeUndefined()
    expect((ctx.get('sessionPersistence') as unknown as { config: { compression?: string } }).config.compression).toBe('none')
    expect(ctx.get('agentLoop')).toBeDefined()
-    expect(ctx.get('userInteraction')).toBeDefined()
+    expect(ctx.get('userInteraction')).toBeUndefined()
+    expect(ctx.get('commands')).toBeUndefined()
    expect(ctx.get('tools')?.get('ask_user_question')).toBeUndefined()
    expect(ctx.get('goals')).toBeDefined()
    expect(ctx.get('tools')?.get('get_goal')).toBeDefined()
-    const target = ctx.sessions.create(SessionId('candidate-target'))
-    ctx.sessions.create(SessionId('candidate-one'))
-    ctx.sessions.create(SessionId('candidate-two'))
-    await expect(ctx.sessionReferences.listCandidates({ id: target.id, session: target } as Agent))
-      .resolves.toHaveLength(1)
    // No pre-created agents — ACP session/new creates them on demand.
    expect(ctx.get('agents')!.list()).toHaveLength(0)
    await ctx.fiber.dispose()
  })

-  it('can explicitly omit the persisted-goal stack and its command', async () => {
+  it('can explicitly omit the persisted-goal stack', async () => {
    const ctx = await mount({
      provider: 'mock',
      model: 'mock',
@@ -117,12 +111,7 @@ describe('dsh-acp-demo composition', () => {
      workspaceContext: false,
    })
    expect(ctx.get('goals')).toBeUndefined()
-    const handle = await ctx.agents.create({
-      sessionId: 'disabled-goals' as import('@deepseek-ai/dsh-session').SessionId,
-      agentOptions: { provider: 'mock', model: 'mock' },
-    })
-    expect(ctx.commands.find(handle.agent, 'goal')).toBeUndefined()
-    await handle.dispose()
+    expect(ctx.get('tools')?.get('get_goal')).toBeUndefined()
    await ctx.fiber.dispose()
  })

--- a/packages/examples/acp-demo/tests/built-bin.e2e.ts
+++ b/packages/examples/acp-demo/tests/built-bin.e2e.ts
@@ -18,7 +18,6 @@ import { Readable, Writable } from 'node:stream'
 import { promisify } from 'node:util'
 import { zstdDecompress } from 'node:zlib'
 import { afterEach, describe, expect, it } from 'vitest'
-import { ACP_SESSION_REFERENCE_META_KEY } from '@deepseek-ai/dsh-acp'

 /**
 * Published-entry smoke: run `lib/bin.js` under plain Node in a symlinked external consumer and
@@ -36,8 +35,7 @@ const dshPackages = [
  'bash/bash-local', 'bash/tool-bash', 'context/workspace-context', 'support/invariants', 'ui/app-boot',
  'session-persistence/session-persistence',
  'session-persistence/session-checkpoint-policy', 'session-persistence/session-persistence-jsonl',
-  'session-query/session-query', 'session-query/session-query-sqlite',
-  'context/session-reference', 'ui/acp', 'examples/acp-demo', 'util/paths',
+  'acp/acp', 'examples/acp-demo', 'util/paths',
 ]
 const vendorPackages = [
  'cordis', 'loader', 'include', 'timer', 'hmr', 'logger-console',
@@ -45,8 +43,8 @@ const vendorPackages = [
 ]
 // Resolve ACP's declared third-party dependencies from that package, not this test: pnpm's strict
 // layout need not hoist them. Symlink those exact paths into the plain-Node consumer.
-const npmDeps = ['@agentclientprotocol/sdk', 'zod']
-const acpPkgDir = join(repoRoot, 'packages/ui/acp')
+const npmDeps = ['@agentclientprotocol/sdk']
+const acpPkgDir = join(repoRoot, 'packages/acp/acp')

 async function pkgName(absDir: string): Promise<string> {
  const json = JSON.parse(await readFile(join(absDir, 'package.json'), 'utf8')) as { name: string }
@@ -72,7 +70,7 @@ async function makeConsumer(): Promise<string> {
    await link(abs, await pkgName(abs), nm)
  }
  for (const dep of npmDeps) {
-    // Resolve from `ui/acp`'s package.json URL (the package that declares the
+    // Resolve from ACP's package.json URL (the package that declares the
    // dep), not this test file's location — `acp-agent` does not depend on these.
    const fromAcp = pathToFileURL(join(acpPkgDir, 'package.json')).href
    const resolved = fileURLToPath(import.meta.resolve(`${dep}/package.json`, fromAcp))
@@ -154,8 +152,12 @@ describe.skipIf(!existsSync(acpBin))('dsh-acp-demo BUILT bin (node lib/bin.js, n
      Writable.toWeb(child.stdin!) as WritableStream<Uint8Array>,
      Readable.toWeb(passthrough) as ReadableStream<Uint8Array>,
    )
+    const updates: SessionNotification['update'][] = []
    const makeClient = (_a: AcpAgent): Client => ({
-      sessionUpdate(_p: SessionNotification): Promise<void> { return Promise.resolve() },
+      sessionUpdate(params: SessionNotification): Promise<void> {
+        updates.push(params.update)
+        return Promise.resolve()
+      },
      requestPermission(_p: RequestPermissionRequest): Promise<RequestPermissionResponse> {
        return Promise.resolve({ outcome: { outcome: 'cancelled' } })
      },
@@ -163,33 +165,17 @@ describe.skipIf(!existsSync(acpBin))('dsh-acp-demo BUILT bin (node lib/bin.js, n
    const client = new ClientSideConnection(makeClient, stream)

    const init = await client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
-    // A response at all proves the built bin booted the bridge (the settle-race
-    // regression would exit before answering); loadSession proves the real app
-    // mounted, not a collapsed export shape.
-    expect(init.agentCapabilities?.loadSession).toBe(true)
-    expect(init.agentCapabilities?.sessionCapabilities?.list).toEqual({})
+    expect(init.agentCapabilities).toEqual({
+      promptCapabilities: { image: false, audio: false, embeddedContext: false },
+    })
    const sessionCwd = consumer
    const { sessionId } = await client.newSession({ cwd: sessionCwd, mcpServers: [] })
    const result = await client.prompt({ sessionId, prompt: [{ type: 'text', text: 'reply' }] })
    expect(result.stopReason).toBe('end_turn')
-    await expect.poll(async () => {
-      return (await client.listSessions({ cwd: sessionCwd })).sessions.find(candidate => candidate.sessionId === sessionId)
-    }).toMatchObject({
-      sessionId,
-      cwd: sessionCwd,
-      title: 'reply',
-    })
-    const listed = await client.listSessions({ cwd: sessionCwd })
-    const reference = listed.sessions.find(candidate => candidate.sessionId === sessionId)
-      ?._meta?.[ACP_SESSION_REFERENCE_META_KEY]
-    expect(reference).toBeTypeOf('object')
-    expect(reference).not.toBeNull()
-    expect(reference).toHaveProperty('uri')
-    if (typeof reference !== 'object' || reference === null || !('uri' in reference)) {
-      throw new Error('expected session reference metadata')
-    }
-    expect(reference.uri).toBeTypeOf('string')
-    expect(reference.uri).toMatch(/^dsh-session:[A-Za-z0-9_-]+$/u)
+    await expect.poll(() => updates).toEqual([{
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: 'ACP BUILT OK' },
+    }])
    const sessionsRoot = join(sessionCwd, '.sessions')
    let log: string | undefined
    await expect.poll(async () => {
--- a/packages/examples/acp-demo/tests/load-path.e2e.ts
+++ b/packages/examples/acp-demo/tests/load-path.e2e.ts
@@ -17,11 +17,10 @@ import {
 } from '@agentclientprotocol/sdk'

 /**
- * Source-path Loader smoke through the package's own bin, covering initialize, session/new, and
- * session/load across the `unwrapExports` path implicated by postmortem 0001. Session creation and
- * unknown-id loading reach factories but not the model, so a dummy key is sufficient. The temp cwd
- * is also the session workspace, and an explicit root tsconfig keeps unbuilt path aliases resolvable
- * when the child starts outside the repository.
+ * Source-path Loader smoke through the package's own bin, covering the
+ * automation server's initialize and fresh-session path across the
+ * `unwrapExports` shape implicated by postmortem 0001. Session creation reaches
+ * the factory but not the model, so a dummy key is sufficient.
 */

 const binScript = fileURLToPath(new URL('../src/bin.ts', import.meta.url))
@@ -107,7 +106,7 @@ async function boot(): Promise<Spawned & { cwd: string }> {
 }

 describe('dsh-acp-demo real-load-path smoke (bin + Loader, keyless)', () => {
-  it('boots via its bin and answers initialize → session/new → session/load', async () => {
+  it('boots via its bin and exposes only fresh text sessions', async () => {
    const { client, cwd, stderr } = await boot()
    // initialize: a broken export shape (collapsed bridge plugin, dropped inject)
    // crashes the tree on the first service read here — see postmortem 0001.
@@ -115,22 +114,14 @@ describe('dsh-acp-demo real-load-path smoke (bin + Loader, keyless)', () => {
      protocolVersion: PROTOCOL_VERSION,
      clientCapabilities: {},
    })
-    expect(init.agentCapabilities?.loadSession).toBe(true)
+    expect(init.agentCapabilities).toEqual({
+      promptCapabilities: { image: false, audio: false, embeddedContext: false },
+    })

    // session/new reaches the agent FACTORY (create) without the model.
    const { sessionId } = await client.newSession({ cwd, mcpServers: [] })
    expect(sessionId).toBeTruthy()

-    // session/load reaches the resume FACTORY + persistence without the model: load an UNKNOWN
-    // id (loading the live `sessionId` would correctly reject as "already loaded"). Persistence
-    // and resume run from the JSON-RPC loop outside bridge injection; a healthy tree reaches
-    // not-found, while a collapsed export would fail earlier with missing injection.
-    const unknownId = '00000000-0000-4000-8000-000000000000'
-    await client.loadSession({ sessionId: unknownId, cwd, mcpServers: [] }).then(
-      () => { throw new Error('expected session/load of an unknown id to reject') },
-      (error: unknown) => { expect(String(error)).not.toContain('without inject') },
-    )
-
    expect(stderr.join('')).not.toContain('without inject')
  }, 30_000)
 })
--- a/packages/examples/acp-demo/tsconfig.json
+++ b/packages/examples/acp-demo/tsconfig.json
@@ -21,22 +21,7 @@
      "path": "../../ui/app-boot"
    },
    {
-      "path": "../../ui/acp"
-    },
-    {
-      "path": "../../session-query/session-query"
-    },
-    {
-      "path": "../../session-query/session-query-sqlite"
-    },
-    {
-      "path": "../../context/session-reference"
-    },
-    {
-      "path": "../../ui/commands"
-    },
-    {
-      "path": "../../goal/command-goal"
+      "path": "../../acp/acp"
    },
    {
      "path": "../../core/agent"
@@ -47,12 +32,6 @@
    {
      "path": "../../context/workspace-context"
    },
-    {
-      "path": "../../ui/user-interaction"
-    },
-    {
-      "path": "../../ui/tool-ask-user"
-    },
    {
      "path": "../../session-persistence/session-checkpoint-policy"
    },
--- a/packages/examples/agent-spine-demo/README.md
+++ b/packages/examples/agent-spine-demo/README.md
@@ -45,7 +45,7 @@ The spine is everything COMMON to every front door. The swappable and front-door
 - **model-backed session-title providers** — the bundle mounts the fallback service with overridable example limits (5 words, 40 fallback bytes, 80 accepted-title bytes); a leaf may opt into exactly one first-message or all-messages LLM provider.
 - **the bash executor** — the bundle ships `tool-bash` (the consumer schema); the leaf provides `ctx.bash` (`bash-local` or a sandboxed impl).
 - **non-local skill providers** — the bundle ships the skill registry, the local filesystem provider, and the `skill` tool; deployments can add other providers such as embedded or remote catalogs as siblings.
- **presentation + per-app infra** — the terminal TUI or ACP front door and `hmr`. These form the coupled front-door cluster that the app packages ([`dsh-tui-demo`](../tui-demo/README.md), [`dsh-acp-demo`](../acp-demo/README.md)) bake in. `timer` is in the spine because it is common and stdout-silent; front doors own stdout and remain outside.
+- **front-door + per-app infra** — the terminal TUI or ACP automation transport and `hmr`. App packages ([`dsh-tui-demo`](../tui-demo/README.md), [`dsh-acp-demo`](../acp-demo/README.md)) own those choices. `timer` is in the spine because it is common and stdout-silent; front doors own stdout and remain outside.

 This is the [interface/implementation/consumer seam](../../../.agents/notes/implemented/architecture/2026-06-13-capability-seams.md) raised to the composition level: the bundle owns the shared spine, the leaf owns the backends, the app package owns the front door.

@@ -63,7 +63,7 @@ For example, `{ invariants: { enabled: true, package_allowlist: ['^@deepseek-ai/

 ## Why a code bundle, not a shared YAML include

-A YAML include can deduplicate config but cannot own a bin or provide front-door defaults. App packages make stdout-safe ACP wiring the default, though a leaf can still add an unsafe logger. Bundle children register services in the root isolate-keyed store, so injected leaf siblings see them without load-order coupling.
+A YAML include can deduplicate config but cannot own a bin or provide front-door defaults. The ACP app package makes protocol-pure stdout wiring the default, though a leaf can still add an unsafe logger. Bundle children register services in the root isolate-keyed store, so injected leaf siblings see them without load-order coupling.

 The retry policy may repeat a failed request in a new numbered step. Retry status, provider errors, and failed partial chunks stay outside model history; each provider attempt can still incur billing, always mode has no attempt limit, front doors derive usage across every logged step, and the reconstructed request preserves the prior prefix for provider cache reuse.