@4fu/dsh-arbor-prompt 0.0.0-stage → 2026.1110.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4fuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,250 @@
-# Temporary Holding Version
+# dsh-arbor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Run [arbor](https://github.com/4fuu/arbor) as the agent driver inside
+[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (DSH).
+
+DSH gives a user a session, a transcript, approvals, plugins, skills and a model
+picker. arbor gives an agent disposable context windows over one shared journal,
+note store and workspace, instead of one long conversation. dsh-arbor connects
+them: one arbor host runs inside the DSH process, each DSH session that selects
+**Arbor** is served by that host, and the window's reply is written back to the
+DSH session as an ordinary assistant message. A DSH session that does not select
+Arbor keeps running on DSH's own embedded AgentLoop, in the same process.
+
+> **Status.** This is a research-grade integration, not a DSH release. It is
+> pinned to one DSH version and relies on DSH internals. Read
+> [Versions and compatibility](docs/versions.md) before installing it on
+> anything you care about. The packages are published under `@4fu` at
+> `2026.1110.1`; the bundle and the font plugin install independently from npm.
+
+## What an arbor session changes
+
+Choosing **Arbor** in a DSH composer creates the session under the `arbor` agent
+preset. That session then runs on arbor, and the following are true for it:
+
+- **One window per turn, one chain per session.** A DSH session is one arbor
+  conversation: its first turn opens a window, a window that ends hands off to a
+  continuation, and the next turn drives the chain. The journal and note store
+  live under `$DSH_HOME/arbor/` and survive a restart.
+- **arbor's workspace, not DSH's sandbox.** A window works in arbor's shared
+  folder (`$DSH_HOME/arbor/shared`). When the `ovnfs` binary is available a
+  window opens a copy-on-write checkout and merges back with `apply`; otherwise
+  arbor uses a plain directory. **There is no DSH sandbox for an arbor session:**
+  arbor's file tools and commands run on the host, and arbor's own secret scrub
+  is the only protection on what reaches the model.
+- **arbor's projects.** The shared folder's project folders are the DSH project
+  list for arbor composers. A directory the user adds outside the shared folder
+  is recorded as an external pointer for that session and used in place.
+- **arbor's prompt and tools.** DSH's official prompt sections are decided one by
+  one; the ones arbor replaces are absent, third-party sections go into a
+  `<dsh>` data block, and a trusted `<harness>` section says what remains true of
+  DSH. DSH tools are offered to the model as arbor external tools, and arbor's
+  own tools replace DSH tools with the same capability.
+- **The Arbor page.** A permanent **Arbor** entry in DSH's left navigation opens
+  the whole-host overview and one tab per arbor session: windows, chains,
+  handoffs, projects, the board, notes, `/env`, schedules and arbor's search.
+  An arbor composer hides DSH's sandbox access-mode switch, because that switch
+  does not apply to it.
+
+## What stays untouched in ordinary DSH sessions
+
+A session that does not select Arbor is an ordinary DSH session. It keeps:
+
+- DSH's embedded AgentLoop, session format, turn boundaries and streaming path;
+- DSH's sandbox policy and its `ctx.fs` / `ctx.shell` file and command tools;
+- DSH's project management, working directory and prompt assembly;
+- its composer, sandbox access-mode switch, header and sidebar behavior.
+
+It gets **no Arbor tab** and no arbor windows. The only shared surface is the
+permanent Arbor entry in the left navigation, which simply does not list that
+session. The routing registry replaces DSH's base `agent` row so it can send
+`agentPreset: 'arbor'` sessions to arbor; every other session goes to the
+official loop. Approvals still use DSH's approval path for both kinds of
+session, and arbor's windows are registered so DSH's sidebar leaves them out.
+
+## Screenshots
+
+| Overview, light | Overview, dark |
+| --- | --- |
+| ![Arbor overview in light mode](docs/screenshots/overview-light.png) | ![Arbor overview in dark mode](docs/screenshots/overview-dark.png) |
+| **Session tab, light** | **Session tab, dark** |
+| ![An arbor session tab in light mode](docs/screenshots/session-light.png) | ![An arbor session tab in dark mode](docs/screenshots/session-dark.png) |
+
+These are the web profile at 1440 px wide with the optional
+[font plugin](https://github.com/4fuu/dsh-arbor-fonts) installed: ChillDIN
+Gothic for labels and ChillDIN for numerals, while body text and code keep
+DSH's fonts. The same overview without the plugin is
+[here](docs/screenshots/overview-without-fonts.png).
+
+## Install
+
+Requirements: Node.js 24.9 or newer and DeepSeek Harness `dsh-v0.2.2-rc.1`.
+The bundle is published with all packages it depends on; nothing has to be
+built or linked.
+
+```bash
+npm install -g @deepseek-ai/dsh@0.2.2-rc.1
+dsh plugin --profile web add @4fu/dsh-arbor-bundle@2026.1110.1
+dsh web
+```
+
+`dsh plugin` adds the bundle to the profile's `dsh.profile.bundles` and installs
+its packages into the profile. The packages declare DSH's runtime packages as
+peer dependencies, so the profile keeps DSH's own copies rather than installing
+a second set. Pick **Arbor** in a composer and send a message.
+The optional [font plugin](https://github.com/4fuu/dsh-arbor-fonts) installs the
+same way, but it is a Host row rather than a bundle. Add the row to the
+profile's `cordis.patch.yml` after installing it:
+
+```bash
+dsh plugin --profile web add @4fu/dsh-arbor-fonts@2026.1110.0
+```
+
+```yaml
+- insert:
+    - id: arbor-fonts
+      name: '@4fu/dsh-arbor-fonts'
+```
+
+Replace the default `[]` in that file with the entry, then restart the profile.
+
+### From a checkout
+
+The proofs and development use the TypeScript sources directly; that checkout is
+what the scripts and the pin check run against.
+
+```bash
+git clone https://github.com/4fuu/dsh-arbor
+cd dsh-arbor
+pnpm install --frozen-lockfile
+pnpm check                 # tsc --noEmit over every package and proof
+pnpm proofs                # 29 proofs against the scripted model
+```
+
+The first install may ask pnpm to approve dependency build scripts. Do not
+approve them by hand: the repository's `pnpm-workspace.yaml` already denies the
+six scripts it pulls in, each with the reason, and `pnpm install` finishes
+cleanly with that policy.
+
+### Hand the install to a model
+
+[docs/install-for-agents.md](docs/install-for-agents.md) is a step-by-step guide
+written for an AI agent: install from npm or a checkout, run the proofs, drive a
+live turn with a restart, boot the web profile, and inspect what ran. Give a
+model this prompt, editing the bracketed parts or dropping them:
+
+```text copy Copy Install Prompt
+Install dsh-arbor (https://github.com/4fuu/dsh-arbor) in this environment [in a
+scratch DSH home under /tmp] and show me that it works: follow
+docs/install-for-agents.md, install @4fu/dsh-arbor-bundle@2026.1110.1 into a DSH
+web profile, pick Arbor for one session, and [also run the proof suite from a
+checkout with pnpm install --frozen-lockfile, pnpm check and pnpm proofs]. Report
+which checks passed, what the live session answered, and anything that did not
+work. Fix only what is yours to fix and tell me what you changed.
+```
+
+## Use it in DSH
+
+The npm install above adds the bundle to a DSH web profile. Pick **Arbor** in a
+composer and send a message: the session is created under the preset, its window
+and chain appear under the **Arbor** entry, and an ordinary session started
+beside it keeps DSH's own composer and sandbox behavior. A checkout can also be
+wired by hand; [section 7 of the install guide](docs/install-for-agents.md#7-wiring-the-bundle-into-a-real-dsh-installation)
+shows the profile layout.
+
+The one-shot `dsh <task>` runner cannot drive an arbor-preset session: DSH's
+runner refuses to adopt a session that runs under a preset. Use the web client,
+the SDK path the proofs use, or a remote `agent-preset/select` on a blank.
+
+## Pinned DSH version
+
+DSH is pinned to **`dsh-v0.2.2-rc.1`** (npm
+`@deepseek-ai/dsh@0.2.2-rc.1`, commit `66491b05e3` of
+`deepseek-ai/deepseek-harness`). Every `@deepseek-ai/dsh*` dependency is an
+exact version, every package under `packages/` declares
+`engines.dsh: 0.2.2-rc.1`, and `pnpm check:pin` checks both plus the prompt
+bridge's `DSH_PINNED_VERSION`. DSH's runtime packages are peer dependencies, and
+`pnpm check:profile` installs the packed packages into a fresh DSH web profile to
+prove the profile keeps one copy and can create both kinds of session.
+
+A different DSH version is unsupported. The bundle depends on DSH's row names,
+its one-`AgentFactory` rule, its prompt-section registry, its client slot
+registration and its exact Fetch registry; a move in any of them can fail the
+boot, leave an official prompt section undecided, or stop the Arbor page from
+registering. `proofs/12-official-sections.ts` and `proofs/18-picker-pin.ts`
+are the behavioral checks. The canonical pin and the upgrade procedure are in
+[Versions and compatibility](docs/versions.md).
+
+## Optional: the font plugin
+
+[dsh-arbor-fonts](https://github.com/4fuu/dsh-arbor-fonts) is a separate DSH
+client plugin that changes only the typography of the Arbor page. It sets
+ChillDIN Gothic for display labels and ChillDIN for numerals, leaves body text
+and code on DSH's fonts, and does nothing on ordinary pages. It is optional and
+installs into the same DSH profile:
+
+```bash
+dsh plugin --profile web add @4fu/dsh-arbor-fonts@2026.1110.0
+```
+
+The fonts are licensed under the SIL Open Font License 1.1; the plugin ships the
+license text, per-file hashes and attribution. The plugin is a Host row rather
+than a bundle: after installing it, add the `arbor-fonts` entry described under
+[Install](#install) to `cordis.patch.yml` and restart the profile.
+
+## Limits worth knowing
+
+- The judge is off: a model-based judge cannot run through the DSH backend yet.
+- The 12 bundle packages are published together at one version; install and
+  upgrade the bundle as a unit, because its packages name each other exactly.
+- `ovnfs` is optional. Without it arbor uses the plain-directory workspace, and a
+  window no longer gets a copy-on-write checkout.
+- The web page's numbers and layout are read from arbor's journal and API; it is
+  not a generic DSH dashboard, and it deliberately shows only arbor sessions.
+- The prompt bridge, the UI and the picker filter are pinned to DSH's internals,
+  not to a stable public API. See [Versions and compatibility](docs/versions.md).
+
+## Documentation
+
+- [Installing and inspecting dsh-arbor](docs/install-for-agents.md) — the
+  agent-facing install, proof, live-turn, web-profile and wiring guide.
+- [Versions and compatibility](docs/versions.md) — the DSH and arbor pins, and
+  what breaks on another DSH version.
+- [B0 findings](docs/b0-findings.md), [B3 findings](docs/b3-findings.md) and
+  [B3b projects and sandbox](docs/b3b-projects-and-sandbox.md) — historical
+  records of the integration's decisions, with the DSH source locations each
+  one rests on. They describe earlier stages; the install guide is the current
+  status.
+- [Layout and proofs](#layout) below for a quick map of the packages.
+
+## Layout
+
+```text
+packages/
+  arbor-host/       one Arbor host per process: SQLite journal and notes,
+                    settings, window lifecycle, workspace and environment
+  arbor-driver/     the routing AgentRegistry, AgentFactory, session agent,
+                    inbox and stream mirrors, and the journal relay
+  arbor-llm/        the arbor AgentBackend over DSH's ctx.llm and ctx.tools
+  arbor-prompt/     <harness>, the <dsh> data block, and the section table
+  arbor-tools/      DSH tools as arbor external tools, same-name replacement
+  arbor-workspace/  arbor's workspace over the shared folder (ovnfs or dir)
+  arbor-env/        /env, with DSH's skills and MCP servers mounted read-only
+  arbor-bundle/     the installable patch that mounts the rows and UI
+  arbor-facts/      the read face behind the Arbor page and its Fetch routes
+  arbor-ui/         the Arbor page, session tabs, copy and composer gate
+  arbor-ui-workspace/
+                    the per-preset hero project picker
+  arbor-preset/     the agent-preset row that puts Arbor in the roster
+  arbor-testkit/    the boot harness, memory journal and scripted model
+patches/            overlay layers a proof applies above the shipped profile
+proofs/             one runnable proof per integration point
+docs/               install, versions, screenshots and historical findings
+scripts/            the pin and profile checks, the release build and packing
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE). The optional font plugin vendors fonts under the
+SIL Open Font License 1.1; its repository carries the license text and
+attribution.

package/blocks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `<dsh>` block kind: one data field, no tag of its own, so arbor's
+ * renderer wraps the third-party content in `<data>` and marks it as data
+ * rather than instructions.
+ */
+import type { BlockKindSpec } from '@4fu/arbor-interfaces';
+/** The `<dsh>` block kind the section renders: one data field, no tag of its own. */
+export declare const DSH_DATA_BLOCK: BlockKindSpec;

package/blocks.js

@@ -0,0 +1,10 @@
+/**
+ * The `<dsh>` block kind: one data field, no tag of its own, so arbor's
+ * renderer wraps the third-party content in `<data>` and marks it as data
+ * rather than instructions.
+ */
+/** The `<dsh>` block kind the section renders: one data field, no tag of its own. */
+export const DSH_DATA_BLOCK = {
+    kind: 'data',
+    fields: [{ name: 'content', type: 'string', required: true }],
+};

package/harness.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The `<harness>` section: what dsh-arbor itself writes about running inside
+ * DeepSeek Harness.
+ *
+ * Arbor's own sections (`<identity>`, `<agent>`, `<tools>`, `<modules>`,
+ * `<env>`, `<workspace>`) carry the framework's logic. This section carries
+ * DSH's: that the window runs inside DeepSeek Harness and the user only sees
+ * what `send` writes, the approval policy, how to write
+ * image and file links into `send` so DSH renders them, how `@path`
+ * references arrive, plan mode's guidance while it is active, and the usage
+ * text of the DSH tools that are actually exposed to arbor windows.
+ *
+ * It is not marked `outside`: it is framework prompt, written by this bridge,
+ * not third-party data. Only the third-party material in `<dsh>` is data.
+ *
+ * Every fixed line is named by its key in {@link dshTextTable} rather than
+ * written into the block, because arbor's renderer escapes a block's field
+ * values and the `send` link syntax needs its angle brackets to survive. The
+ * two kinds that carry text — a DSH tool's usage and the deployment's plan
+ * guidance — are escaped, which is right: they are material from outside this
+ * bridge.
+ *
+ * The section's `revision` covers every input the content depends on, so a
+ * change to any of them reaches a running window as a `prompt_delta` carrying
+ * only the changed lines, rather than a rebuilt prefix.
+ */
+import type { Block, BlockKindSpec } from '@4fu/arbor-interfaces';
+import type { PromptAssembly } from '@deepseek-ai/dsh-system-prompt';
+import { type SectionDecision } from './sections.js';
+/**
+ * One fixed line of the `<harness>` section, named by its text-table key.
+ *
+ * The key is a field so one kind serves every line; the line itself comes from
+ * the table, which the renderer writes verbatim rather than escaped.
+ */
+export declare const HARNESS_LINE_BLOCK: BlockKindSpec;
+/** One DSH tool's usage text, carried through verbatim. */
+export declare const HARNESS_TOOL_BLOCK: BlockKindSpec;
+/** One block of text configured from outside this bridge: plan mode's guidance. */
+export declare const HARNESS_TEXT_BLOCK: BlockKindSpec;
+/** Every block kind the `<harness>` section renders. */
+export declare const HARNESS_BLOCKS: readonly BlockKindSpec[];
+/** The dynamic inputs the `<harness>` section renders, and its revision covers. */
+export interface HarnessState {
+    /** The approval policy in effect, or `undefined` when DSH reports none. */
+    readonly approval: 'ask' | 'never' | undefined;
+    /** Whether plan mode is active for the session whose turn is rendering. */
+    readonly planActive: boolean;
+    /** The DSH tool names actually exposed to arbor windows, sorted. */
+    readonly exposedTools: readonly string[];
+}
+/** One rendered `<harness>` section, with what it decided. */
+export interface HarnessRender {
+    /** The section's blocks. */
+    readonly blocks: readonly Block[];
+    /** The official tool sections this render carried through, by name. */
+    readonly carried: readonly string[];
+}
+/**
+ * Render the `<harness>` section's blocks from DSH's own assembly.
+ *
+ * A DSH section the table drops contributes nothing. A section the table
+ * keeps is either rewritten in this bridge's words (the approval policy, the
+ * `send` link wording, the `@path` wording) or carried through
+ * verbatim (a DSH tool's usage text, and the deployment's plan-mode guidance).
+ */
+export declare function renderHarness(assembly: PromptAssembly, state: HarnessState): HarnessRender;
+/**
+ * Detect a DSH section declared `complete: true`.
+ *
+ * A complete section replaces every other section in DSH's own assembly, so
+ * the only observable is the collapse: `SystemPrompt`'s constructor always
+ * registers `harness:identity` and the two persona sections, so an assembly
+ * that holds a persona section and no `harness:identity` is one a complete
+ * section took over. For an arbor session that must not be honoured — it would
+ * replace arbor's whole prompt — so the bridge records a warning and carries
+ * on with the persona as ordinary text.
+ */
+export declare function detectCompleteSection(assembly: PromptAssembly): string | undefined;
+/** The decision each consumed official section was rendered under, for diagnostics. */
+export declare function consumedDecisions(names: readonly string[]): readonly {
+    name: string;
+    decision: SectionDecision;
+}[];

package/harness.js

@@ -0,0 +1,169 @@
+/**
+ * The `<harness>` section: what dsh-arbor itself writes about running inside
+ * DeepSeek Harness.
+ *
+ * Arbor's own sections (`<identity>`, `<agent>`, `<tools>`, `<modules>`,
+ * `<env>`, `<workspace>`) carry the framework's logic. This section carries
+ * DSH's: that the window runs inside DeepSeek Harness and the user only sees
+ * what `send` writes, the approval policy, how to write
+ * image and file links into `send` so DSH renders them, how `@path`
+ * references arrive, plan mode's guidance while it is active, and the usage
+ * text of the DSH tools that are actually exposed to arbor windows.
+ *
+ * It is not marked `outside`: it is framework prompt, written by this bridge,
+ * not third-party data. Only the third-party material in `<dsh>` is data.
+ *
+ * Every fixed line is named by its key in {@link dshTextTable} rather than
+ * written into the block, because arbor's renderer escapes a block's field
+ * values and the `send` link syntax needs its angle brackets to survive. The
+ * two kinds that carry text — a DSH tool's usage and the deployment's plan
+ * guidance — are escaped, which is right: they are material from outside this
+ * bridge.
+ *
+ * The section's `revision` covers every input the content depends on, so a
+ * change to any of them reaches a running window as a `prompt_delta` carrying
+ * only the changed lines, rather than a rebuilt prefix.
+ */
+import { decideSection } from "./sections.js";
+import { dshTextTable } from "./text.js";
+/**
+ * One fixed line of the `<harness>` section, named by its text-table key.
+ *
+ * The key is a field so one kind serves every line; the line itself comes from
+ * the table, which the renderer writes verbatim rather than escaped.
+ */
+export const HARNESS_LINE_BLOCK = {
+    kind: 'harness_line',
+    fields: [{ name: 'key', type: 'string', required: true }],
+    lines: ['{key}'],
+};
+/** One DSH tool's usage text, carried through verbatim. */
+export const HARNESS_TOOL_BLOCK = {
+    kind: 'harness_tool',
+    fields: [
+        { name: 'name', type: 'string', required: true },
+        { name: 'text', type: 'string', required: true },
+    ],
+    lines: ['dsh.harness.tool'],
+};
+/** One block of text configured from outside this bridge: plan mode's guidance. */
+export const HARNESS_TEXT_BLOCK = {
+    kind: 'harness_text',
+    fields: [{ name: 'text', type: 'string', required: true }],
+};
+/** Every block kind the `<harness>` section renders. */
+export const HARNESS_BLOCKS = [
+    HARNESS_LINE_BLOCK,
+    HARNESS_TOOL_BLOCK,
+    HARNESS_TEXT_BLOCK,
+];
+/** One fixed line, named by its text-table key. */
+function line(key) {
+    return { kind: 'harness_line', fields: { key } };
+}
+/** The section texts of one assembly, by name. */
+function textsOf(assembly) {
+    const texts = new Map();
+    for (const section of assembly.sections)
+        texts.set(section.name, section.text);
+    for (const context of assembly.contexts)
+        texts.set(context.name, context.text);
+    return texts;
+}
+/**
+ * Whether one kept tool section governs at least one exposed tool.
+ *
+ * `tool:<x>` governs the tool named `<x>`. `tool:pty` is DSH's terminal
+ * family, whose tools are named `terminal_*`. A prefixed section
+ * (`browser-use:`, `computer-use:`, `terminal:`) governs the tools that share
+ * its prefix.
+ */
+function governs(sectionName, exposed) {
+    if (sectionName === 'tool:pty')
+        return exposed.some(name => name.startsWith('terminal_') || name === 'pty');
+    if (sectionName.endsWith(':'))
+        return exposed.some(name => name.startsWith(sectionName));
+    return exposed.includes(sectionName.slice('tool:'.length));
+}
+/**
+ * Render the `<harness>` section's blocks from DSH's own assembly.
+ *
+ * A DSH section the table drops contributes nothing. A section the table
+ * keeps is either rewritten in this bridge's words (the approval policy, the
+ * `send` link wording, the `@path` wording) or carried through
+ * verbatim (a DSH tool's usage text, and the deployment's plan-mode guidance).
+ */
+export function renderHarness(assembly, state) {
+    const texts = textsOf(assembly);
+    const blocks = [line('dsh.harness.lead')];
+    const carried = [];
+    // Approval policy: dsh-arbor's own wording for DSH's two policies. The
+    // policy itself is read from the state, so a mid-window switch moves the
+    // section's revision and reaches the window as a delta.
+    if (state.approval === 'never') {
+        blocks.push(line('dsh.harness.approval.never'));
+    }
+    else if (state.approval === 'ask') {
+        blocks.push(line('dsh.harness.approval.ask'));
+    }
+    // How to write links into `send`, so DSH renders them. DSH's own section
+    // speaks of the final response; only `send` reaches the user here. The
+    // target line comes first, because a send to a target nobody owns is an
+    // effect that never reaches anybody.
+    blocks.push(line('dsh.harness.send.target'));
+    blocks.push(line('dsh.harness.send.image'));
+    blocks.push(line('dsh.harness.send.file'));
+    if (state.exposedTools.includes('present'))
+        blocks.push(line('dsh.harness.send.present'));
+    blocks.push(line('dsh.harness.reference'));
+    // Plan mode: the deployment's own guidance, verbatim, behind a lead line of
+    // this bridge's, and only while plan mode is active.
+    const plan = state.planActive ? texts.get('plan:policy') ?? '' : '';
+    if (plan !== '') {
+        blocks.push(line('dsh.harness.plan.lead'));
+        blocks.push({ kind: 'harness_text', fields: { text: plan } });
+    }
+    // The DSH tools that are actually exposed: their usage text, verbatim, in
+    // DSH's own English. A tool that is not exposed writes nothing.
+    const exposed = [...state.exposedTools].sort();
+    for (const [name, text] of texts) {
+        if (text === '')
+            continue;
+        if (decideSection(name) !== 'harness')
+            continue;
+        if (!name.startsWith('tool:') && !name.endsWith(':'))
+            continue;
+        if (!governs(name, exposed))
+            continue;
+        carried.push(name);
+        blocks.push({
+            kind: 'harness_tool',
+            fields: { name: name.slice('tool:'.length), text },
+        });
+    }
+    return { blocks, carried };
+}
+/**
+ * Detect a DSH section declared `complete: true`.
+ *
+ * A complete section replaces every other section in DSH's own assembly, so
+ * the only observable is the collapse: `SystemPrompt`'s constructor always
+ * registers `harness:identity` and the two persona sections, so an assembly
+ * that holds a persona section and no `harness:identity` is one a complete
+ * section took over. For an arbor session that must not be honoured — it would
+ * replace arbor's whole prompt — so the bridge records a warning and carries
+ * on with the persona as ordinary text.
+ */
+export function detectCompleteSection(assembly) {
+    const names = assembly.sections.map(section => section.name);
+    if (names.length !== 1)
+        return undefined;
+    const [only] = names;
+    if (only === undefined || !only.startsWith('deployment:persona-'))
+        return undefined;
+    return only;
+}
+/** The decision each consumed official section was rendered under, for diagnostics. */
+export function consumedDecisions(names) {
+    return names.map(name => ({ name, decision: decideSection(name) }));
+}