diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d885ce4..9cdaa08 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -30,5 +30,5 @@ jobs:
         run: node scripts/check-release.mjs
       - run: npm ci
       - run: npm run verify
-      - name: Publish core and Pi package with npm trusted publishing
+      - name: Publish core and integration packages with npm trusted publishing
         run: node scripts/publish.mjs
diff --git a/.gitignore b/.gitignore
index dda4009..982a173 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@ coverage/
 integrations/pi/LICENSE
 .env.*
 !.env.example
+integrations/dsh/LICENSE
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 36a2e7c..90f8566 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+### Features
+
+- Add the `@chrok/dsh-braid` DeepSeek Harness plugin with background graphs,
+  isolated workers, revision-checked updates, pause/resume, cancellation, and
+  completion reminders through DSH's native model, tool, and job services.
+- Add a native DSH Web panel with live graphs, execution history, paged outputs,
+  usage, and controls. Braid tool cards preserve recorded operation summaries
+  and open the corresponding job, node, or execution in the live panel.
+
 ### Documentation
 
 - Introduce Braid with a parallel code-review example and clear installation
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0149f3a..887feb0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -15,23 +15,28 @@ npm ci
 npm run verify
 ```
 
-The root npm workspace lockfile covers both packages. A development-only
+The root npm workspace lockfile covers all packages. A development-only
 `@chrok/braid: file:.` dependency links the core checkout into `node_modules`;
-Pi's manifest still declares the exact release version. This lets CI test a
+Each integration manifest still declares the exact release version. This lets CI test a
 new core before it is published. `check:pi`, `test:pi`, and `build:pi` rebuild
 core so package imports resolve current JavaScript and declarations. Consumers
-installing either published package do not install this development dependency.
+installing published packages do not install this development dependency.
 Use `npm install --workspace @chrok/pi-braid <dependency>` for Pi dependency
-updates; do not create a separate lockfile in `integrations/pi`.
-
-The core has no runtime dependencies. Pi's dependencies belong in its workspace
-manifest. Update and commit the root lockfile when changing a dependency. Do not commit generated `dist` directories,
+updates, or `npm install --workspace @chrok/dsh-braid <dependency>` for DSH.
+Do not create separate lockfiles in integration directories. DSH uses
+`check:dsh`, `test:dsh`, and `build:dsh` with the same core rebuild convention.
+DSH Host and React Client use separate TypeScript programs to keep Cordis service
+augmentations isolated. `build-client.mjs` emits the shared-React DSH loader factory;
+`test:dsh` rebuilds it before testing the native Remote/slot lifecycle.
+
+The core has no runtime dependencies. Integration dependencies belong in their workspace
+manifests. Update and commit the root lockfile when changing a dependency. Do not commit generated `dist` directories,
 tarballs, credentials, or provider output containing private data.
 
-`verify` type-checks both packages, runs deterministic tests and offline examples,
+`verify` type-checks core and both integrations, runs deterministic tests and offline examples,
 then builds tarballs and installs them into a temporary consumer outside the
-checkout. That last check needs registry access for Pi dependencies but never
-calls a model. `npm test` is the fast core-only loop; `npm run test:pi` tests Pi.
+checkout. That last check needs registry access for integration dependencies but never
+calls a model. `npm test` is the fast core-only loop; `npm run test:pi` tests Pi; `npm run test:dsh` tests DeepSeek Harness.
 `npm run bench` measures the scheduler without a provider.
 
 Run `npm run audit:dependencies` after `npm ci` to scan the complete dependency
diff --git a/README.md b/README.md
index a62a9b2..1834542 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ Braid coordinates multiple LLM agents as a graph. Define each agent's task and
 which results it needs; Braid runs independent tasks in parallel and passes
 their outputs to the next step.
 
-Use it as a TypeScript/JavaScript library or as an extension for the Pi coding agent.
+Use it as a TypeScript/JavaScript library or as a plugin for Pi or DeepSeek Harness.
 
 [![CI](https://github.com/Epsirom/braid/actions/workflows/ci.yml/badge.svg)](https://github.com/Epsirom/braid/actions/workflows/ci.yml)
 [![npm core](https://img.shields.io/npm/v/%40chrok%2Fbraid?label=%40chrok%2Fbraid)](https://www.npmjs.com/package/@chrok/braid)
@@ -37,6 +37,7 @@ and [execution control](docs/execution-control.md) when you need those features.
 | --- | --- |
 | In your own application | [Install `@chrok/braid`](#install-in-your-application) and supply a model runner |
 | In Pi | [Install `@chrok/pi-braid`](#install-in-pi) to run agents in the background and inspect them in a live panel |
+| In DeepSeek Harness | [Install `@chrok/dsh-braid` from source](integrations/dsh/README.md#install) for background agents and a native Web graph panel |
 
 ## Install in your application
 
@@ -548,6 +549,7 @@ is needed for the test suite; its HTTP requests are intercepted in tests.
 - [`src/workspaces.ts`](src/workspaces.ts): Git snapshots, checkpoint refs, merge
   serialization, local Git tools, and worktree cleanup.
 - [`src/adapters/openai.ts`](src/adapters/openai.ts): optional provider translation.
+- [`integrations/dsh/`](integrations/dsh/): native DeepSeek Harness model/tool adapter, agent-scoped jobs, reminders, and a native Web graph panel.
 - [`integrations/pi/`](integrations/pi/): thin Pi model-registry/tool adapter, Mermaid graph renderer, and live execution renderer (`display.ts`).
 - [`test/`](test/): deterministic scheduling, execution-event, and intercepted HTTP/tool tests.
 
diff --git a/docs/releasing.md b/docs/releasing.md
index b62d75b..f90e0bf 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -1,15 +1,17 @@
 # Releasing
 
-Core and Pi are separate public npm packages built from one commit. Both use the
-same version. The core has no runtime dependencies. Pi declares an exact
-`@chrok/braid` dependency and includes only its own compiled integration code.
+Core, Pi, and DSH are separate public npm packages built from one commit. All use
+the same version. The core has no runtime dependencies. Each integration declares
+an exact `@chrok/braid` dependency and includes its own compiled integration code.
 
 ## Registry and source association
 
 The public packages are [@chrok/braid](https://www.npmjs.com/package/@chrok/braid)
 and [@chrok/pi-braid](https://www.npmjs.com/package/@chrok/pi-braid) on npmjs.
-Keep `publishConfig.registry` set to `https://registry.npmjs.org`. Both manifests
-link to `Epsirom/braid`; Pi's `repository.directory` is `integrations/pi`.
+`@chrok/dsh-braid` is a new package awaiting its first publication.
+Keep `publishConfig.registry` set to `https://registry.npmjs.org`. All manifests
+link to `Epsirom/braid`; integration `repository.directory` values are
+`integrations/pi` and `integrations/dsh`.
 The repository About website and README badges provide the reverse links.
 GitHub Packages is a separate registry and is not a mirror in this release flow.
 
@@ -23,9 +25,10 @@ To inspect the public release without npm account credentials:
 ```sh
 npm view @chrok/braid dist-tags description repository homepage gitHead dist.attestations --json
 npm view @chrok/pi-braid dist-tags description repository homepage gitHead dist.attestations --json
+npm view @chrok/dsh-braid dist-tags description repository homepage gitHead dist.attestations --json
 ```
 
-For a release, query the exact `@X.Y.Z` versions too. Confirm both `gitHead`
+For a release, query the exact `@X.Y.Z` versions too. Confirm all `gitHead`
 values match the release commit, the source links point to this repository, and
 provenance identifies this repository's release workflow. The successful
 [Publish runs](https://github.com/Epsirom/braid/actions/workflows/release.yml)
@@ -38,23 +41,23 @@ Version tags (`v*`) cannot be moved or deleted. New GitHub releases are immutabl
 prepare a draft and attach any assets before publishing. Published tag/asset
 corrections require a new version. See [repository settings](repository-settings.md).
 
-1. Update both `package.json` versions, Pi's exact `@chrok/braid` dependency,
+1. Update all `package.json` versions, both integrations' exact `@chrok/braid` dependencies,
    and the root workspace lockfile (`npm install --package-lock-only`). Use a minor version
    for breaking 0.x changes, and describe migrations in the changelog.
 2. Run `npm ci` and `npm run verify` from the repository root.
    The package check verifies clean builds, public ESM imports, declarations,
-   licenses, and Pi registration in a temporary consumer outside the checkout.
+   licenses, Pi/DSH background jobs, and the DSH browser entry in temporary consumers outside the checkout.
    A temporary local registry serves the unpublished core tarball; installing
-   only the Pi tarball must fetch core transitively through its version dependency.
+   either integration tarball must fetch core transitively through its version dependency.
 3. Update the changelog, migration guidance, package descriptions/keywords, and
-   supported Pi version. Reconcile README/Pi development notices and ROADMAP
+   supported Pi/DSH versions. Reconcile README/integration development notices and ROADMAP
    status with the release being prepared; mark publication complete only after
-   both packages are available. Commit and review the changes;
+   all packages are available. Commit and review the changes;
    require the CI matrix to pass before tagging that commit `vX.Y.Z`.
-4. Inspect `npm pack --dry-run` and `npm pack --dry-run` from `integrations/pi`.
+4. Inspect `npm pack --dry-run` from the root, `integrations/pi`, and `integrations/dsh`.
    `prepack` rebuilds each package. Never publish stale prebuilt output.
 5. Prepare the GitHub release draft using the release-note policy below. After
-   publishing, verify both registry versions, `latest` tags, provenance, and a
+   publishing, verify all registry versions, `latest` tags, provenance, and a
    clean install before reporting the release complete.
 
 ## Release notes and contributor credit
@@ -97,7 +100,7 @@ recovery codes private.
 
 Log in locally with `npm login --registry=https://registry.npmjs.org`; confirm the
 account with `npm whoami`. Publish the core with `npm publish --access public`,
-then run `npm publish --access public` from `integrations/pi`. Complete npm's
+then run `npm publish --access public` from each integration directory. Complete npm's
 interactive account/2FA checks if requested. Never put credentials in source,
 issues, shell history, or CI logs. An npm registration alone does not guarantee
 ownership of a previously used package name.
@@ -108,7 +111,7 @@ Allow time for the exact versions to become available through `npm view`; do not
 republish or bump versions just to work around this delay.
 
 After availability is confirmed, install the registry versions in a fresh project and verify
-both exported core entry points and the Pi extension. Add the actual publication
+both exported core entry points and the Pi/DSH integrations. Add the actual publication
 date to the changelog and create the corresponding GitHub release.
 
 ## Subsequent releases with trusted publishing
@@ -126,21 +129,23 @@ With npm 11.20 or later, the equivalent CLI setup is:
 ```sh
 npm trust github @chrok/braid --file release.yml --repo Epsirom/braid --allow-publish
 npm trust github @chrok/pi-braid --file release.yml --repo Epsirom/braid --allow-publish
+npm trust github @chrok/dsh-braid --file release.yml --repo Epsirom/braid --allow-publish
 npm trust list @chrok/braid
 npm trust list @chrok/pi-braid
+npm trust list @chrok/dsh-braid
 ```
 
 Publishing a non-prerelease GitHub release triggers `.github/workflows/release.yml`.
 It validates the tag/version relationship, repeats all checks, and publishes
-core then Pi using short-lived OIDC credentials. After each publish (or retry
+core then Pi and DSH using short-lived OIDC credentials. After each publish (or retry
 of an existing version), it waits for matching version/commit metadata and a
-successful tarball download. Pi is not published until core is available. npm
+successful tarball download. Integrations are not published until core is available. npm
 processing is polled every 15 seconds for up to 10 minutes; a timeout fails the
 workflow with retry instructions. It does not require `NPM_TOKEN`.
 The workflow installs npm 11 and uses Node 24. See
 [npm's trusted publishing documentation](https://docs.npmjs.com/trusted-publishers/).
 
-If the second publish fails, rerun the same workflow after resolving the error.
+If a later publish fails, rerun the same workflow after resolving the error.
 The script skips an existing version only when npm records the exact current
 Git commit as its `gitHead`. A collision from another commit fails explicitly;
 never unpublish/reuse a version to repair it. Publish a new patch instead.
diff --git a/integrations/dsh/README.md b/integrations/dsh/README.md
new file mode 100644
index 0000000..7fb4482
--- /dev/null
+++ b/integrations/dsh/README.md
@@ -0,0 +1,263 @@
+# Braid for DeepSeek Harness (`@chrok/dsh-braid`)
+
+A native DeepSeek Harness plugin for background Braid graphs, bounded loops,
+isolated Git worktrees, live updates, pause/resume, and completion reminders.
+It uses DSH's provider routing and credentials through `ctx.llm`; it has no Pi
+runtime dependency. Tested against **DSH 0.2.0-rc.2** and Node.js **22.19+**.
+DSH is in developer preview, so host peer versions are pinned to this baseline.
+
+## Install
+
+From this repository:
+
+```sh
+npm ci
+npm run build:dsh
+dsh plugin --profile web add ./integrations/dsh
+```
+
+Restart the DSH profile after installation or rebuilding. The package includes
+`dsh.bundle` metadata and `cordis.patch.yml`, so installation activates the plugin.
+It requires the `tools`, `llm`, `commands`, `systemPrompt`, and `jobs` services,
+which the standard DSH composition provides. Custom profiles must provide them.
+
+Once published, the planned npm installation command is:
+
+```sh
+dsh plugin --profile web add @chrok/dsh-braid
+```
+
+Use your own profile name in place of `web`. Core `@chrok/braid` is installed
+automatically at the matching version. No API keys belong in plugin configuration;
+configure models through DSH. A node's `model` is an exact `provider/model-id`,
+including any additional slashes in the model ID; omitted overrides use the parent
+agent's model captured at submission.
+
+## Tools and live control
+
+| Capability | DSH interface |
+| --- | --- |
+| Submit a graph | `braid({ goal, nodes, edges, promptTemplates?, loops?, options? })` |
+| List this agent's jobs | `braid_status({})` |
+| Read a job | `braid_status({ jobId })` |
+| Read a specific invocation | `braid_status({ jobId, executionId })` |
+| Read a node's latest invocation | `braid_status({ jobId, nodeId })` |
+| Atomically edit/resume | `braid_update({ jobId, expectedRevision, ...patch })` |
+| Resume without edits | `braid_resume({ jobId, expectedRevision, executionIds })` |
+| Cancel | `braid_cancel({ jobId })` or `/braid cancel <jobId>` |
+| Human progress snapshot | `/braid [jobId]`, `/braid list` |
+| Graph, execution details and controls | **Braid** in the session header or right-sidebar guide |
+| Generic job progress and cancellation | DSH's native **Jobs** panel |
+
+Submission immediately returns a short `job-1` handle, a canonical UUID, and
+`nativeJobId` (for DSH's generic job tools/panel). Braid tools accept the short
+handle or UUID, exactly. Handles are scoped to the live agent; another agent or
+session cannot retrieve them. Native job IDs belong to DSH's separate registry.
+Receipts echo accepted node types, policies, overrides, and edges without prompts.
+
+## Braid Web panel
+
+Click **Braid** in a session's header, or choose **Braid** from the right-sidebar
+guide. Braid's five tool calls also render as clickable transcript cards:
+
+| Tool card | Recorded summary and navigation |
+| --- | --- |
+| `braid` | Submission receipt and node count; opens the submitted graph once the receipt arrives |
+| `braid_status` | Recorded status, revision and execution progress; focuses a requested node/execution; list results provide a link for each job |
+| `braid_update` | Before/after revision, upserted/removed nodes, edge counts and resumed executions; rejected updates are marked as not applied |
+| `braid_resume` | Requested execution IDs and remaining pauses; a single execution links directly to its history |
+| `braid_cancel` | Cancellation requested or job already finished; opens the original job |
+
+The main card opens the right-sidebar Braid tab in the call's owning session.
+Cards retain the result recorded at the time of the call; the sidebar shows the
+**current** graph and status. Raw arguments, results and errors remain accessible
+under **Show tool details**, along with DSH's inspector when available. Failed
+submissions and calls still preparing a new graph do not link to an unrelated
+latest job. Short handles in older receipts are fenced by the call timestamp;
+a job missing after a Host restart is reported as unavailable.
+
+The panel is a native DSH tab: the sidebar provides docking, splitting,
+floating and fullscreen. It follows the session that owns the tab.
+
+- Select a Braid job and inspect its live graph. Nodes show their type and state;
+  edge labels show decisions, and dashed back-edges show bounded loops. Zoom and
+  scrolling accommodate larger graphs.
+- Click a node to select an exact execution, including earlier loop iterations.
+  Inspect output, decisions, errors, context usage, tool counts, latency, workspace
+  details and recovery refs. Output is paged in 32,768-character chunks.
+- View the latest 80 lifecycle events and input/output/cache token totals.
+- Cancel the job, resume one paused execution, or resume all paused executions.
+  Resume submits the revision currently displayed; stale revisions are rejected
+  and surfaced in the panel. Editing a graph remains a model-tool operation.
+
+The Host sends structured snapshots through DSH's authenticated Remote transport,
+coalesced to at most one update per 150 ms per observer. Prompts, provider messages
+and node outputs are excluded from that stream; selected outputs are read
+separately. Switching sessions or closing the tab stops observation, while jobs
+continue. Disconnected controls are disabled; the panel retries the stream, then
+offers manual reconnect if retries fail.
+
+The package declares `dsh.client` and exports `./client`, a DSH module-loader
+factory sharing the shell's React instance. The Web profile must provide
+`typert`, `remote`, the slot renderer, conversation header, tool views and right sidebar.
+Custom headless profiles can omit these services and retain the tools/commands.
+Unloading the plugin removes its tab type, slots, styles and Remote methods.
+
+The generic Jobs panel also streams a text flow diagram, node states, elapsed times, context
+token estimates/provider reports, context capacity when available, tool counts,
+and recent events. Its own stop action cancels the Braid run. Closing the panel
+leaves it running. `/braid` returns a snapshot in the command UI; it does not open
+Pi's terminal overlay or bind Pi's keyboard shortcuts. Headless profiles can use
+the tools and commands without a Web UI.
+
+The five graph tools expose the same execution controls as the Pi integration.
+DSH presentation uses a native Web graph panel, jobs and commands; it does not
+include Pi's Mermaid terminal renderer. Tool results are canonical JSON for both native and PTC mode.
+
+## Graphs and workspaces
+
+```json
+{
+  "goal": "Implement a fix, review it, and apply it",
+  "nodes": [
+    { "type": "execute", "id": "implement", "prompt": "Implement and test the fix." },
+    { "type": "execute", "id": "review", "prompt": "Review the implementation and report evidence.", "workspace": "read-only", "pauseAfter": true },
+    { "type": "integrate", "id": "apply", "requireSuccess": true }
+  ],
+  "edges": [
+    { "from": "implement", "to": "review" },
+    { "from": "review", "to": "apply" }
+  ]
+}
+```
+
+`execute` and `decision` require `prompt`; only decisions declare nonempty,
+distinct `choices` and call `decide`. `merge` and `integrate` allow an optional
+prompt and forbid `workspace`/`choices`. All four types accept `model`,
+`notifyOnCompletion`, `pauseAfter`, and `requireSuccess`. Core validates every
+submission and update before it takes effect.
+
+Inside Git, each execution gets a fresh snapshot of its predecessor checkpoints;
+roots include tracked and non-ignored untracked caller changes. Execute/decision
+nodes default to writable worktrees. `workspace: "read-only"` keeps snapshot
+isolation while removing write/edit/shell tools. Outside Git all workers are
+read-only. Independent changed snapshots need an explicit merge node before
+another ordinary worker can consume their combined code.
+
+`merge` combines snapshots in an isolated worktree. `integrate` applies selected
+changes to the invoking checkout, preserving user edits. Nothing automatically
+integrates at job completion. Both expose constrained Git operations and require
+`finish_merge` dispositions for every source execution ID. Checkpoints and
+integration backup refs remain recoverable after worktree cleanup. A failed
+integration can leave partial changes or conflicts; core never resets the caller.
+
+Workers receive a fresh DSH context containing the goal, rendered node prompt,
+direct predecessor outputs, execution identity, and workspace/merge metadata.
+They do not inherit the parent transcript, skills, extension/MCP tools, or Braid
+itself. Fixed local tools are:
+
+- `read` and `ls`; `grep` and `find` when `rg` is installed. Missing search
+  dependencies are not downloaded; use `ls`/`read` instead.
+- `write`, `edit`, and `bash` for writable Git workspaces; `powershell` on Windows.
+- `git` when core provides Git access; `finish_merge` for merge/integrate nodes.
+- `decide` only for decision nodes, with exactly one declared choice.
+
+Guarded writes reject paths outside the assigned workspace, Git metadata,
+submodules, symlinks, hard links, and special files. Shell commands use host
+permissions and can bypass file guards; worktrees are not an OS sandbox. Workers
+are instructed to keep writes local, preserve shared Git state, and avoid global
+or externally visible actions unless requested. Commands run in the foreground;
+completion, timeout, and cancellation terminate their process group. Ignored new
+dependencies, caches, and build outputs are not checkpointed and disappear during
+cleanup. Shared services and ports require execution-specific resources.
+
+## Pauses, updates, loops, and reminders
+
+`notifyOnCompletion: true` sends an intermediate success/failure reminder.
+`pauseAfter: true` additionally holds outgoing scheduling; independent branches
+continue. Reminders identify the exact invocation and loop iteration in the job
+data. Fetch `braid_status`, then use its **current** `execution.revision` and
+`execution.pausedExecutionIds`:
+
+```json
+{
+  "jobId": "job-1",
+  "expectedRevision": 0,
+  "executionIds": ["<paused-execution-id>"]
+}
+```
+
+Pass this to `braid_resume`. `braid_update` accepts complete `upsertNodes`,
+`removeNodeIds`, `addEdges`, `removeEdges`, `promptTemplates`, `loops`, and
+`resume`. Use historical `edge.executionId` pins only in updates. Include new
+nodes and their dependencies in the same update: a disconnected root can start
+immediately. Rejected revisions/patches change nothing. Upserts replace whole
+node definitions; supplied templates/loops replace their whole map/list.
+`removeEdges` matches every identity field exactly; omitted fields are not
+wildcards. Existing invocations retain their captured inputs and policies.
+Finalized jobs cannot be reopened.
+
+Bounded loops use a `loops` entry `{ id, entry, maxIterations }` and one feedback
+edge from a decision to that entry carrying `choice` and `feedback: "<loop-id>"`.
+`maxIterations` includes the first round. Loops cannot overlap or nest. Prompt
+templates use `{{name}}` placeholders and node prompts such as
+`{ "template": "review", "variables": { "target": "src/runtime.ts" } }`.
+Variable names must match exactly; values are inserted literally.
+See the [execution-control guide](https://github.com/Epsirom/braid/blob/main/docs/execution-control.md)
+for the shared graph semantics.
+
+Completion and pause messages use DSH `agent.steer`: a running agent consumes
+them at the next step, and an idle agent wakes. Acknowledged messages are removed;
+discarded messages retry when the agent returns to idle. DSH's generic job
+controller may also show its native job completion notice. Retrieve results after
+the reminder instead of polling. Stopping a foreground response does not cancel
+submitted jobs. Plugin or owning-agent disposal aborts workers, awaits cleanup,
+and suppresses Braid reminders. Switching the UI to another still-live agent does
+not dispose the original owner or redirect its reminders. Jobs are in memory;
+they do not survive a DSH restart.
+
+## Budgets and accounting
+
+`options` accepts `maxConcurrency` (default 4), `maxExecutions` (default 1000),
+`maxToolRounds`, `maxToolCalls`, `nodeTimeoutMs`, and `graphTimeoutMs`. Tool/time
+budgets are unlimited when omitted. Limits count rejected tool calls too. Workers
+receive remaining budget/deadline reminders before model requests. Graph deadlines
+continue during pauses and do not reset on resume or update.
+
+`braid_status.usage` aggregates DSH usage, including completed provider rounds
+from workers that later fail or time out. Input/cache fields are disjoint;
+`totalTokens` includes input, output, cache reads, and cache writes. Core runner
+usage combines input/cache into `inputTokens`. DSH does not offer Pi's external
+tool-cost accounting contract: repeated status reads return the same totals
+without adding charges to the foreground agent. No dollar cost is inferred.
+
+Results over 50 KB are saved as private JSON files in the host's temporary
+directory. The bounded response preserves status/control fields and includes
+`fullOutputPath`, including for running graphs and focused execution reads.
+Running status retains the latest 80 events; finalized `result.events` contains
+the complete core event log. Saved files remain available after job cleanup.
+
+## Development
+
+```sh
+npm run check:dsh
+npm run test:dsh
+npm run build:dsh
+npm run test:package
+```
+
+Tests use scripted providers without network model calls. They exercise real
+Cordis/DSH registration, native job ownership/control, canonical tool outputs,
+reminder delivery and cleanup, graph controls, loops, budgets, filesystem guards,
+and process cancellation. Web tests cover the native Gateway, the built browser
+factory and Remote mounting, slot registration/unload, session switching, safe
+text rendering, controls, revision checks, paging and disconnect cleanup. Package
+smoke tests install the packed package outside the checkout, load its browser
+factory and run a background worker. All dependencies share the root lockfile.
+Use `npm install --workspace @chrok/dsh-braid <dependency>` for dependency updates.
+
+Host contracts: [DSH plugin packaging](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.2.0-rc.2/docs/user/develop/basic/publish.md),
+[tool authoring](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.2.0-rc.2/docs/cookbook/adding-a-tool.md),
+[client modules](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.2.0-rc.2/docs/subsystems/client-modules.md),
+[right-sidebar extensions](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.2.0-rc.2/packages/client/ui-sidebar-right/README.md),
+and [native jobs](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.2.0-rc.2/packages/jobs/jobs/README.md).
diff --git a/integrations/dsh/build-client.mjs b/integrations/dsh/build-client.mjs
new file mode 100644
index 0000000..7c5856e
--- /dev/null
+++ b/integrations/dsh/build-client.mjs
@@ -0,0 +1,15 @@
+import { build } from "esbuild";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const directory = fileURLToPath(new URL(".", import.meta.url));
+const result = spawnSync(process.execPath, [fileURLToPath(new URL("../../node_modules/typescript/bin/tsc", import.meta.url)),
+  "-p", `${directory}tsconfig.client.json`, "--noEmit", "false", "--emitDeclarationOnly"], { stdio: "inherit" });
+if (result.error) throw result.error;
+if (result.status !== 0) process.exit(result.status ?? 1);
+// DSH loads a closure factory, with React supplied by its shared module table.
+await build({ entryPoints: [`${directory}client/index.tsx`], outfile: `${directory}dist/client.js`,
+  bundle: true, platform: "browser", format: "cjs", target: "es2022", jsx: "automatic", sourcemap: true,
+  external: ["react", "react/jsx-runtime"],
+  banner: { js: 'window.__ModuleLoader__.load({ id: "@chrok/dsh-braid", factory: (require) => { var module = { exports: {} }; var exports = module.exports;' },
+  footer: { js: "return module.exports; } });" },
+});
diff --git a/integrations/dsh/client/Panel.tsx b/integrations/dsh/client/Panel.tsx
new file mode 100644
index 0000000..61000d4
--- /dev/null
+++ b/integrations/dsh/client/Panel.tsx
@@ -0,0 +1,167 @@
+import * as React from "react";
+import { useEffect, useId, useMemo, useRef, useState } from "react";
+import type { PanelApi, PanelDetail, PanelExecution, PanelFrame, PanelJob } from "../panel-types.js";
+import { layoutGraph } from "./layout.js";
+import type { BraidNavigation } from "./navigation.js";
+
+const number = (n: number) => n.toLocaleString();
+const message = (error: unknown) => error instanceof Error ? error.message : String(error);
+export function Status({ status }: { status: string }) {
+  return <span className="br-status" data-status={status}>{status}</span>;
+}
+
+export function Graph({ job, selected, select }: { job: PanelJob; selected: string; select: (id: string) => void }) {
+  const layout = useMemo(() => layoutGraph(job.nodes, job.edges), [job.nodes, job.edges]);
+  const [zoom, setZoom] = useState(1);
+  const arrow = useId().replaceAll(":", "");
+  const selectedButton = useRef<HTMLButtonElement>(null);
+  useEffect(() => { selectedButton.current?.scrollIntoView?.({ block: "nearest", inline: "nearest" }); }, [selected]);
+  return <section className="br-section" aria-label="Execution graph">
+    <div className="br-section-head"><h3>Execution graph</h3><div className="br-toolbar">
+      <button aria-label="Zoom out" disabled={zoom <= .5} onClick={() => setZoom(v => Math.max(.5, v - .25))}>−</button>
+      <button aria-label="Reset zoom" onClick={() => setZoom(1)}>{Math.round(zoom * 100)}%</button>
+      <button aria-label="Zoom in" disabled={zoom >= 1.5} onClick={() => setZoom(v => Math.min(1.5, v + .25))}>+</button>
+    </div></div>
+    <div className="br-graph"><div style={{ width: layout.width * zoom, height: layout.height * zoom }}>
+      <div className="br-graph-canvas" style={{ width: layout.width, height: layout.height, transform: `scale(${zoom})`, transformOrigin: "top left" }}>
+        <svg width={layout.width} height={layout.height} aria-hidden="true"><defs><marker id={arrow} viewBox="0 0 10 10" refX="9" refY="5" markerWidth="5" markerHeight="5" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" style={{ fill: "var(--br-muted)" }}/></marker></defs>
+          {job.edges.map((edge, i) => {
+            const a = layout.positions.get(edge.from), b = layout.positions.get(edge.to);
+            if (!a || !b) return null;
+            const x = a.x + 77, y = a.y + 72, endX = b.x + 77, endY = b.y;
+            const d = edge.feedback ? `M ${a.x} ${a.y + 36} C 6 ${a.y + 36}, 6 ${b.y + 36}, ${b.x} ${b.y + 36}` : `M ${x} ${y} C ${x} ${y + 26}, ${endX} ${endY - 26}, ${endX} ${endY}`;
+            return <g key={i}><path d={d} strokeDasharray={edge.feedback ? "4 4" : undefined} markerEnd={`url(#${arrow})`}><title>{edge.from} → {edge.to}{edge.choice ? ` (${edge.choice})` : ""}{edge.feedback ? ` · loop ${edge.feedback}` : ""}{edge.executionId ? ` · ${edge.executionId}` : ""}</title></path>
+              {edge.choice && !edge.feedback && <text x={(x + endX) / 2 + 5} y={(y + endY) / 2 - 4}>{edge.choice.slice(0, 22)}</text>}</g>;
+          })}
+        </svg>
+        {job.nodes.map(node => { const p = layout.positions.get(node.id)!; return <button key={node.id} ref={selected === node.id ? selectedButton : undefined} className="br-node" style={{ left: p.x, top: p.y }} aria-pressed={selected === node.id} onClick={() => select(node.id)} title={`${node.id} · ${node.type} · ${node.status}`}>
+          <small>{node.type}</small><strong>{node.id}</strong><Status status={node.status}/>
+        </button>; })}
+      </div>
+    </div></div>
+    <div className="br-legend"><span>Solid · dependency</span><span>Dashed · loop feedback</span><span>Click a node to inspect</span></div>
+    {job.loops.map(loop => <p className="br-note" key={loop.id}>Loop {loop.id} · entry {loop.entry} · maximum {loop.maxIterations} iterations</p>)}
+  </section>;
+}
+
+function ExecutionDetail({ api, sessionId, job, execution }: { api: PanelApi; sessionId: string; job: PanelJob; execution: PanelExecution }) {
+  const [detail, setDetail] = useState<PanelDetail>();
+  const [error, setError] = useState("");
+  const [offset, setOffset] = useState(0);
+  const [retry, setRetry] = useState(0);
+  useEffect(() => {
+    let active = true;
+    setDetail(undefined); setError("");
+    void api.detail({ sessionId, jobId: job.jobId, executionId: execution.executionId, offset }).then(value => {
+      if (active) setDetail(value);
+    }, e => { if (active) setError(message(e)); });
+    return () => { active = false; };
+  }, [api, sessionId, job.jobId, job.status, execution.executionId, execution.status, offset, retry]);
+  const p = execution.progress;
+  return <>
+    <div className="br-detail-grid">
+      <div><span>Execution</span>{execution.executionId}</div><div><span>Revision / iteration</span>r{execution.revision} / {execution.iteration ?? "—"}</div>
+      <div><span>Elapsed</span>{execution.latencyMs === undefined ? "—" : `${(execution.latencyMs / 1000).toFixed(1)}s`}</div>
+      <div><span>Worker</span>{p?.phase ?? execution.status}</div>
+      <div><span>Context ({p?.contextSource ?? "unreported"})</span>{p ? `${number(p.contextTokens)}${p.contextWindow ? ` / ${number(p.contextWindow)}` : ""}` : "—"}</div>
+      <div><span>Tool calls / rounds</span>{p ? `${p.toolCalls} / ${p.toolRounds}` : "—"}</div>
+    </div>
+    {error && <div role="alert">{error} <button onClick={() => setRetry(v => v + 1)}>Retry output</button></div>}
+    {!detail && !error && <p className="br-muted" role="status">Loading output…</p>}
+    {detail && <>
+      {detail.error && <p role="alert">{detail.error}</p>}
+      {detail.decision && <p>Decision: <strong>{detail.decision}</strong></p>}
+      <pre className="br-output" aria-label="Execution output">{detail.output || (execution.status === "running" ? "Output will appear when this execution finishes." : "No output for this execution.")}</pre>
+      {detail.total > 32768 && <div className="br-toolbar"><button disabled={offset === 0} onClick={() => setOffset(Math.max(0, offset - 32768))}>Previous output</button><small className="br-muted">{number(detail.offset)}–{number(detail.next)} / {number(detail.total)} characters</small><button disabled={detail.next >= detail.total} onClick={() => setOffset(detail.next)}>Next output</button></div>}
+      {detail.workspace && <details><summary>Workspace and recovery refs</summary><pre className="br-output">{detail.workspace}</pre></details>}
+    </>}
+  </>;
+}
+
+function JobView({ job, api, sessionId, connected, act, busy, target }: { job: PanelJob; api: PanelApi; sessionId: string; connected: boolean; act: (action: "cancel" | "resume", ids: string[]) => void; busy: boolean; target: BraidNavigation | undefined }) {
+  const [selected, setSelected] = useState(() => job.executions.find(e => e.executionId === target?.executionId)?.id
+    ?? target?.nodeId ?? (target?.executionId ? "" : job.nodes[0]?.id ?? ""));
+  const [chosenExecution, setChosenExecution] = useState(target?.executionId ?? "");
+  const [tab, setTab] = useState("output");
+  const executions = job.executions.filter(e => e.id === selected);
+  const execution = chosenExecution ? executions.find(e => e.executionId === chosenExecution) : executions.at(-1);
+  const paused = execution && job.pausedExecutionIds.includes(execution.executionId);
+  return <>
+    <div className="br-stats"><div><strong>{job.executions.filter(e => e.status === "completed").length}/{job.executions.length}</strong><span>Executions complete</span></div><div><strong>{number(job.usage.inputTokens)}</strong><span>Input tokens</span></div><div><strong>{number(job.usage.outputTokens)}</strong><span>Output tokens</span></div><div><strong>{number(job.usage.cacheReadTokens + job.usage.cacheWriteTokens)}</strong><span>Cache tokens</span></div></div>
+    {job.error && <div className="br-notice" role="alert">{job.error}</div>}
+    {job.pausedExecutionIds.length > 0 && <div className="br-notice"><strong>{job.pausedExecutionIds.length} execution(s) paused</strong><p className="br-note">Inspect the output, then resume outgoing scheduling. Job deadlines continue while paused.</p><button className="br-primary" disabled={!connected || busy || job.status !== "running"} onClick={() => act("resume", job.pausedExecutionIds)}>Resume all paused</button></div>}
+    <Graph job={job} selected={selected} select={id => { setSelected(id); setChosenExecution(""); setTab("output"); }}/>
+    <section className="br-section" aria-label="Execution details"><div className="br-section-head"><h3>{selected || "Execution details"}</h3>{execution && <Status status={paused ? "waiting" : execution.status}/>}</div>
+      {chosenExecution && !execution && <p role="status">The requested execution ({chosenExecution}) is no longer available. Select a node to inspect its current history.</p>}
+      {executions.length > 0 ? <label><span className="br-muted">Execution history</span><select className="br-select" aria-label="Execution history" value={execution?.executionId ?? ""} onChange={e => setChosenExecution(e.target.value)}>{executions.map(e => <option key={e.executionId} value={e.executionId}>{e.executionId} · {e.status}{e.iteration === undefined ? "" : ` · iteration ${e.iteration}`}</option>)}</select></label> : <p className="br-muted">This node has not run yet.</p>}
+      {paused && <button className="br-primary" disabled={!connected || busy || job.status !== "running"} onClick={() => act("resume", [execution!.executionId])}>Resume this execution</button>}
+      <div className="br-tabs"><button aria-pressed={tab === "output"} onClick={() => setTab("output")}>Output & details</button><button aria-pressed={tab === "events"} onClick={() => setTab("events")}>Event log ({job.events.length})</button></div>
+      {tab === "output" && execution && <ExecutionDetail key={execution.executionId} api={api} sessionId={sessionId} job={job} execution={execution}/>}
+      {tab === "events" && <><p className="br-note">Latest 80 lifecycle events. Full results remain available through braid_status.</p><ol className="br-events">{[...job.events].reverse().map(event => <li key={event.sequence}><time>{new Date(event.timestamp).toLocaleTimeString([], { hour12: false })}</time><div><p>{event.message}</p><small>#{event.sequence}{event.nodeId ? ` · ${event.nodeId}` : ""}{event.executionId ? ` · ${event.executionId}` : ""}</small></div></li>)}</ol></>}
+      <p className="br-note">Cache read {number(job.usage.cacheReadTokens)} · cache write {number(job.usage.cacheWriteTokens)}. Usage is reported by DSH; monetary cost is not estimated.</p>
+    </section>
+  </>;
+}
+
+/** The session key deliberately resets every local selection and request generation. */
+export function BraidPanelView(props: { sessionId: string; api: PanelApi; target?: BraidNavigation }) {
+  return <SessionPanel key={props.sessionId} {...props}/>;
+}
+function SessionPanel({ sessionId, api, target }: { sessionId: string; api: PanelApi; target?: BraidNavigation }) {
+  const [jobId, setJobId] = useState<string | undefined>(target?.jobId);
+  const [createdBefore, setCreatedBefore] = useState<number | undefined>(target?.createdBefore);
+  const [frame, setFrame] = useState<PanelFrame>();
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState("");
+  const [actionError, setActionError] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [retry, setRetry] = useState(0);
+  useEffect(() => {
+    const controller = new AbortController();
+    setConnected(false); setFrame(undefined); setError(""); setActionError("");
+    void (async () => {
+      for (let attempt = 0; !controller.signal.aborted; attempt++) {
+        try {
+          for await (const value of api.watch({ sessionId, ...(jobId ? { jobId } : {}), ...(createdBefore === undefined ? {} : { createdBefore }) }, controller.signal)) {
+            if (controller.signal.aborted) return;
+            setFrame(value); setConnected(true); setError(""); attempt = 0;
+          }
+          if (!controller.signal.aborted) throw new Error("Braid connection closed");
+        } catch (e) {
+          if (controller.signal.aborted) return;
+          setConnected(false); setError(`${message(e)}${attempt < 2 ? " · reconnecting…" : ""}`);
+          if (attempt >= 2) return;
+          await new Promise<void>(resolve => {
+            const done = () => { clearTimeout(timer); controller.signal.removeEventListener("abort", done); resolve(); };
+            const timer = setTimeout(done, 1000 * 2 ** attempt);
+            controller.signal.addEventListener("abort", done, { once: true });
+          });
+        }
+      }
+    })();
+    return () => { controller.abort(); };
+  }, [api, sessionId, jobId, createdBefore, retry]);
+  const job = frame?.job;
+  // In-flight mutations only affect their mounted job view; stream frames remain authoritative.
+  const [actionOwner, setActionOwner] = useState("");
+  const act = async (action: "cancel" | "resume", executionIds: string[]) => {
+    if (!job || !connected || busy) return;
+    const owner = job.jobId;
+    setBusy(true); setActionOwner(owner); setActionError("");
+    try { await api.control({ sessionId, jobId: owner, action, executionIds, revision: job.revision }); }
+    catch (e) { setActionError(message(e)); }
+    finally { setBusy(false); }
+  };
+  return <div className="braid-panel">
+    <header className="br-header"><div className="br-eyebrow">Agent orchestration</div><div className="br-heading"><h2>Braid</h2><small role="status">{connected ? "● Live" : error ? "○ Disconnected" : "Connecting…"}</small></div>
+      {frame && frame.rows.length > 0 && <><select className="br-select" aria-label="Braid job" disabled={busy} value={job?.jobId ?? ""} onChange={e => { setJobId(e.target.value); setCreatedBefore(undefined); setActionError(""); }}>{frame.rows.map(row => <option key={row.jobId} value={row.jobId}>{row.handle} · {row.status} · {row.goal.slice(0, 70)}</option>)}</select>
+        {job && <><p className="br-goal">{job.goal}</p><div className="br-toolbar"><Status status={job.phase === "waiting" ? "waiting" : job.status}/><small className="br-muted">r{job.revision} · {job.nodes.length} nodes</small><button className="br-danger" style={{ marginLeft: "auto" }} disabled={!connected || busy || job.status !== "running"} onClick={() => void act("cancel", [])}>{busy ? "Working…" : "Cancel job"}</button></div></>}
+      </>}
+    </header>
+    {error && <div className="br-notice" role="alert">{error}<div className="br-toolbar"><button onClick={() => setRetry(v => v + 1)}>Reconnect</button><button onClick={() => { setJobId(undefined); setCreatedBefore(undefined); setRetry(v => v + 1); }}>Latest job</button></div></div>}
+    {actionError && actionOwner === job?.jobId && <div className="br-notice" role="alert">{actionError}</div>}
+    {connected && frame?.rows.length === 0 && <div className="br-empty"><h3>No Braid jobs in this session</h3><p>Ask the agent to use Braid for a parallel or multi-step task. Its graph, execution history and results will appear here.</p></div>}
+    {job && <JobView key={job.jobId} job={job} api={api} sessionId={sessionId} connected={connected} act={(action, ids) => void act(action, ids)} busy={busy}
+      target={target?.jobId && [job.jobId, job.handle].includes(target.jobId) ? target : undefined}/>}
+  </div>;
+}
diff --git a/integrations/dsh/client/ToolCall.tsx b/integrations/dsh/client/ToolCall.tsx
new file mode 100644
index 0000000..7ae2bd8
--- /dev/null
+++ b/integrations/dsh/client/ToolCall.tsx
@@ -0,0 +1,35 @@
+import * as React from "react";
+import type { ToolCallOwnerProps } from "@deepseek-ai/dsh-client-ui-tool/client";
+import { toolNavigation, toolPresentation, type BraidNavigation } from "./navigation.js";
+
+export type BraidToolCallProps = ToolCallOwnerProps & { openBraid: (target: BraidNavigation) => void };
+
+/** The main row opens the graph; a separate disclosure preserves the raw tool evidence. */
+export function BraidToolCall(props: BraidToolCallProps) {
+  const { toolName, phase, block, openBraid, useDisclosure, inspect } = props;
+  const { expanded, toggle } = useDisclosure();
+  const target = toolNavigation(toolName, props);
+  const model = toolPresentation(toolName, props);
+  const failed = phase === "result" && block.isError;
+  const state = failed ? "failed" : phase === "result" ? "completed" : phase === "preparing" ? "preparing" : "running";
+  const raw = phase === "result" ? block.call?.argsRaw : phase === "start" ? block.argsRaw : undefined;
+  const output = phase === "result" ? block.content.filter(c => c.type === "text").map(c => c.text).join("\n") : "";
+  return <div className="br-tool-call" data-state={state}>
+    <button type="button" className="br-tool-open" disabled={!target} onClick={() => { if (target) openBraid(target); }}
+      aria-label={`Open Braid view for ${toolName}`} title={target ? "Open Braid graph and execution details" : "Waiting for a Braid job receipt"}>
+      <span aria-hidden="true">⎇</span><span className="br-tool-main"><strong>{toolName}</strong>
+        <span className="br-tool-target">{model.label}{target?.executionId ? ` / ${target.executionId}` : target?.nodeId ? ` / ${target.nodeId}` : ""}</span>
+        <span className="br-tool-summary">{model.summary}</span></span><span aria-hidden="true">↗</span>
+    </button>
+    {model.changes.length > 0 && <div className="br-tool-changes" aria-label={failed ? "Changes not applied" : "Operation details"}>{model.changes.map((change, i) => <span key={i}>{change}</span>)}</div>}
+    {model.jobs.length > 0 && <ul className="br-tool-jobs">{model.jobs.map(job => <li key={job.target.jobId}><button type="button" onClick={() => openBraid(job.target)} aria-label={`View ${job.label}`}>{job.label} <span>{job.status}</span> ↗</button></li>)}</ul>}
+    {phase === "result" && target && <p className="br-tool-note">Recorded result · open the graph for live state</p>}
+    {failed && <p role="alert" className="br-tool-error">{block.error?.reason ?? block.error?.code ?? (output.slice(0, 600) || "Braid tool call failed. Expand the result for details.")}</p>}
+    <div className="br-tool-actions"><button type="button" aria-expanded={expanded} onClick={toggle}>{expanded ? "Hide" : "Show"} tool details</button>
+      {inspect && <button type="button" onClick={inspect}>Inspect call</button>}
+    </div>
+    {expanded && <div className="br-tool-details"><strong>Arguments</strong><pre>{raw ?? "Arguments are being prepared…"}</pre>
+      {phase === "result" && <><strong>Result</strong><pre>{output || "No text result."}</pre></>}
+    </div>}
+  </div>;
+}
diff --git a/integrations/dsh/client/index.tsx b/integrations/dsh/client/index.tsx
new file mode 100644
index 0000000..13cbb20
--- /dev/null
+++ b/integrations/dsh/client/index.tsx
@@ -0,0 +1,59 @@
+import * as React from "react";
+import type { Context } from "@deepseek-ai/cordis";
+import type {} from "@deepseek-ai/dsh-api-gateway/client";
+import type {} from "@deepseek-ai/dsh-client-ui-renderer/client";
+import type {} from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type {} from "@deepseek-ai/dsh-client-ui-sidebar-right/client";
+import type {} from "@deepseek-ai/dsh-client-ui-tool/client";
+import type { PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
+import type { SessionId } from "@deepseek-ai/dsh-session/types";
+import type { PanelApi } from "../panel-types.js";
+import { PANEL_PACKAGE, panelDescriptors } from "../panel-contract.js";
+import { BraidPanelView } from "./Panel.js";
+import { styles, toolStyles } from "./styles.js";
+import { BraidToolCall } from "./ToolCall.js";
+import { braidToolNames, readNavigation, type BraidNavigation } from "./navigation.js";
+
+declare module "@deepseek-ai/dsh-client-ui-sidebar-right/client" {
+  interface SidebarRightTabParamsMap { braid: BraidNavigation }
+}
+
+export const inject = ["remote", "slots", "sidebarRight", "sidebarRightTabs"];
+export async function apply(ctx: Context): Promise<void> {
+  await ctx.remote.$mount({ package: PANEL_PACKAGE, descriptors: panelDescriptors });
+  ctx.inject(["remote.braidPanel"], ctx => {
+    // Capture traced services inside their declared Cordis scope, not React event stacks.
+    const remote = ctx.remote.braidPanel;
+    const sidebar = ctx.sidebarRight;
+    const api: PanelApi = {
+      watch: (request, signal) => remote.watch(request, signal),
+      control: async request => { const result = await remote.control(request); if (!result.ok) throw result.error; return result.value; },
+      detail: async request => { const result = await remote.detail(request); if (!result.ok) throw result.error; return result.value; },
+    };
+    ctx.effect(() => {
+      const style = document.createElement("style"); style.dataset.plugin = PANEL_PACKAGE; style.textContent = styles + toolStyles;
+      document.head.append(style); return () => { style.remove(); };
+    });
+    ctx.effect(() => ctx.sidebarRightTabs.register({ id: PANEL_PACKAGE, kind: "braid", title: () => "Braid",
+      guide: [{ id: "braid", order: 50, title: () => "Braid", description: () => "Live agent graphs, execution details and controls" }],
+    }));
+    ctx.effect(() => ctx.slots.inject("sidebar.right.pane.tab", () => ctx.slots.register({
+      name: "sidebar.right.pane.tab", key: PANEL_PACKAGE, inject: sessionId => ({ api, sessionId }),
+    }, PanelSeat)));
+    ctx.effect(() => ctx.slots.inject("conversation.session.header.actions", () => ctx.slots.register({
+      name: "conversation.session.header.actions", id: "braid", order: 25,
+      inject: () => ({ open: () => { sidebar.openTab("braid"); } }),
+    }, HeaderAction)));
+    for (const key of braidToolNames) ctx.effect(() => ctx.slots.inject("tool.call.toolview", () => ctx.slots.register({
+      name: "tool.call.toolview", key,
+      inject: sessionId => ({ openBraid: (target: BraidNavigation) => { sidebar.openTabIn(sessionId as SessionId, "braid", { params: target }); } }),
+    }, BraidToolCall)));
+  });
+}
+function HeaderAction({ open }: { open: () => void }) {
+  return <button className="br-header-action" onClick={open} title="Open Braid graph and execution details" aria-label="Open Braid panel">⎇ Braid</button>;
+}
+function PanelSeat({ sessionId, api, useTabInfo }: PropsRuntime<"sidebar.right.pane.tab"> & { sessionId: string; api: PanelApi }) {
+  const { tab: { navigation } } = useTabInfo();
+  return <BraidPanelView key={navigation.revision} sessionId={sessionId} api={api} target={readNavigation(navigation.params)}/>;
+}
diff --git a/integrations/dsh/client/layout.ts b/integrations/dsh/client/layout.ts
new file mode 100644
index 0000000..b14ab82
--- /dev/null
+++ b/integrations/dsh/client/layout.ts
@@ -0,0 +1,27 @@
+import type { PanelJob } from "../panel-types.js";
+
+/** Longest-path ranks in the forward DAG. Feedback is drawn separately. */
+export function layoutGraph(nodes: PanelJob["nodes"], edges: PanelJob["edges"]) {
+  const rank = new Map(nodes.map(node => [node.id, 0]));
+  const incoming = new Map(nodes.map(node => [node.id, 0]));
+  const outgoing = new Map(nodes.map(node => [node.id, [] as string[]]));
+  for (const edge of edges) {
+    if (edge.feedback || !rank.has(edge.from) || !rank.has(edge.to)) continue;
+    incoming.set(edge.to, incoming.get(edge.to)! + 1);
+    outgoing.get(edge.from)!.push(edge.to);
+  }
+  const queue = nodes.filter(node => incoming.get(node.id) === 0).map(node => node.id);
+  for (let i = 0; i < queue.length; i++) for (const to of outgoing.get(queue[i]!)!) {
+    rank.set(to, Math.max(rank.get(to)!, rank.get(queue[i]!)! + 1));
+    incoming.set(to, incoming.get(to)! - 1);
+    if (incoming.get(to) === 0) queue.push(to);
+  }
+  const columns = new Map<number, number>();
+  const positions = new Map(nodes.map(node => {
+    const row = rank.get(node.id)!, column = columns.get(row) ?? 0;
+    columns.set(row, column + 1);
+    return [node.id, { x: 32 + column * 186, y: 28 + row * 124 }];
+  }));
+  return { positions, width: Math.max(280, ...[...columns.values()].map(count => count * 186 + 32)),
+    height: Math.max(160, ...[...rank.values()].map(row => (row + 1) * 124 + 28)) };
+}
diff --git a/integrations/dsh/client/navigation.ts b/integrations/dsh/client/navigation.ts
new file mode 100644
index 0000000..bb355d1
--- /dev/null
+++ b/integrations/dsh/client/navigation.ts
@@ -0,0 +1,113 @@
+import type { ToolCallPhaseProps } from "@deepseek-ai/dsh-client-ui-tool/client";
+
+export interface BraidNavigation { jobId?: string; nodeId?: string; executionId?: string; createdBefore?: number }
+export const braidToolNames = ["braid", "braid_status", "braid_update", "braid_resume", "braid_cancel"] as const;
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+function json(raw: string): Record<string, unknown> {
+  try { return record(JSON.parse(raw)); } catch { return {}; }
+}
+const id = (value: unknown): string | undefined => typeof value === "string" && value.trim() && value.length <= 1024 ? value : undefined;
+
+/** Sidebar navigation also survives layout restoration, so validate its loose JSON boundary. */
+export function readNavigation(value: unknown): BraidNavigation {
+  const source = record(value), target: BraidNavigation = {};
+  for (const key of ["jobId", "nodeId", "executionId"] as const) {
+    const text = id(source[key]); if (text !== undefined) target[key] = text;
+  }
+  if (typeof source.createdBefore === "number" && Number.isSafeInteger(source.createdBefore) && source.createdBefore >= 0)
+    target.createdBefore = source.createdBefore;
+  return target;
+}
+
+function toolData(props: ToolCallPhaseProps) {
+  const args = json(props.phase === "result" ? props.block.call?.argsRaw ?? "" : props.phase === "start" ? props.block.argsRaw : "");
+  let result: Record<string, unknown> = {};
+  if (props.phase === "result" && !props.block.isError) for (const content of props.block.content) {
+    if (content.type !== "text") continue;
+    const value = json(content.text);
+    if (Object.keys(value).length > 0) { result = value; break; }
+  }
+  return { args, result };
+}
+
+/** Read only envelope identifiers, never the result preview, prompts, or worker output. */
+export function toolNavigation(toolName: string, props: ToolCallPhaseProps): BraidNavigation | null {
+  if (!braidToolNames.some(name => name === toolName) || props.phase === "preparing") return null;
+  const { args, result } = toolData(props);
+  const jobId = id(result.canonicalJobId) ?? id(result.jobId) ?? id(args.jobId);
+  // A submission has no target until its receipt arrives. A list call opens the roster.
+  if (!jobId) return toolName === "braid_status" && !("jobId" in args || "nodeId" in args || "executionId" in args) ? {} : null;
+  const target: BraidNavigation = { jobId };
+  const node = record(result.node);
+  const executionId = id(args.executionId) ?? id(node.executionId)
+    ?? (toolName === "braid_resume" && Array.isArray(args.executionIds) && args.executionIds.length === 1 ? id(args.executionIds[0]) : undefined);
+  const nodeId = id(args.nodeId) ?? id(node.id);
+  if (executionId) target.executionId = executionId;
+  if (nodeId) target.nodeId = nodeId;
+  const time = props.block.time;
+  if (Number.isSafeInteger(time) && time >= 0) target.createdBefore = time;
+  return target;
+}
+
+export interface ToolPresentation {
+  label: string;
+  summary: string;
+  changes: string[];
+  jobs: { label: string; status: string; target: BraidNavigation }[];
+}
+const array = (value: unknown): unknown[] => Array.isArray(value) ? value : [];
+const revision = (value: unknown): string => typeof value === "number" && Number.isSafeInteger(value) ? `r${value}` : "";
+const names = (values: unknown[]): string => {
+  const ids = values.map(value => id(value) ?? id(record(value).id)).filter(Boolean);
+  return ids.slice(0, 8).join(", ") + (ids.length > 8 ? ` … (+${ids.length - 8})` : "");
+};
+
+/** Each tool card describes its recorded operation; the sidebar is explicitly live. */
+export function toolPresentation(toolName: string, props: ToolCallPhaseProps): ToolPresentation {
+  const { args, result } = toolData(props);
+  const label = id(result.handle) ?? id(args.jobId) ?? id(result.jobId) ?? "";
+  const model: ToolPresentation = { label, summary: "", changes: [], jobs: [] };
+  const failed = props.phase === "result" && props.block.isError;
+  const settled = props.phase === "result";
+  if (toolName === "braid_update") {
+    const revisions = [revision(args.expectedRevision), revision(result.revision)].filter(Boolean).join(" → ");
+    model.summary = `${failed ? "Update rejected · not applied" : settled ? "Graph updated" : "Updating graph"}${revisions ? ` · ${revisions}` : ""}`;
+    for (const [key, title] of [["upsertNodes", "Upsert nodes"], ["removeNodeIds", "Remove nodes"], ["resume", "Resume executions"]] as const) {
+      const values = array(args[key]); if (values.length) model.changes.push(`${title}: ${names(values)}`);
+    }
+    for (const [key, title] of [["addEdges", "Add edges"], ["removeEdges", "Remove edges"]] as const) {
+      const values = array(args[key]); if (values.length) model.changes.push(`${title}: ${values.length}`);
+    }
+    if ("loops" in args) model.changes.push(`Replace loops: ${array(args.loops).length}`);
+    if ("promptTemplates" in args) model.changes.push(`Prompt templates: ${Object.keys(record(args.promptTemplates)).length}`);
+  } else if (toolName === "braid_resume") {
+    model.summary = failed ? "Resume rejected" : `${settled ? "Resumed" : "Resuming"} ${array(args.executionIds).length} execution(s)`;
+    const ids = names(array(args.executionIds)); if (ids) model.changes.push(ids);
+    if (Array.isArray(result.pausedExecutionIds)) model.changes.push(`${result.pausedExecutionIds.length} still paused · ${revision(result.revision)}`);
+  } else if (toolName === "braid_cancel") {
+    model.summary = failed ? "Cancellation failed" : !settled ? "Requesting cancellation" : result.cancelled === false ? "Job already finished" : "Cancellation requested";
+  } else if (toolName === "braid_status" && Array.isArray(result.jobs)) {
+    model.summary = `${result.jobs.length} job(s) at this call`;
+    model.jobs = result.jobs.flatMap(value => {
+      const row = record(value), jobId = id(row.jobId);
+      return jobId ? [{ label: id(row.handle) ?? jobId, status: id(row.status) ?? "", target: { jobId, createdBefore: props.block.time } }] : [];
+    });
+  } else if (toolName === "braid_status") {
+    const execution = record(result.execution), node = record(result.node);
+    const executions = Object.values(record(execution.executions));
+    const details = id(node.status)
+      ? [`execution ${id(node.status)}`, id(execution.status) ? `graph ${id(execution.status)}` : undefined, revision(execution.revision)]
+      : [id(execution.status) ?? id(result.status), revision(execution.revision)];
+    if (executions.length) details.push(`${executions.filter(value => record(value).status === "completed").length}/${executions.length} executions complete`);
+    if (Array.isArray(execution.pausedExecutionIds) && execution.pausedExecutionIds.length) details.push(`${execution.pausedExecutionIds.length} paused`);
+    model.summary = failed ? "Status query failed" : details.filter(Boolean).join(" · ") || (settled ? "Recorded status" : "Reading status");
+  } else {
+    const graph = record(result.graph), nodes = array(graph.nodes).length || array(args.nodes).length;
+    model.summary = failed ? "Submission failed" : `${settled ? "Graph submitted" : "Starting graph"}${nodes ? ` · ${nodes} nodes` : ""}`;
+  }
+  if (result.truncated === true) model.changes.push("Large result saved to file; view fullOutputPath in tool details");
+  return model;
+}
diff --git a/integrations/dsh/client/styles.ts b/integrations/dsh/client/styles.ts
new file mode 100644
index 0000000..c318d5f
--- /dev/null
+++ b/integrations/dsh/client/styles.ts
@@ -0,0 +1,20 @@
+/** Scoped styles share the Host's fonts and honor both system and DSH dark themes. */
+export const styles = `
+.braid-panel{--br-bg:var(--dsw-alias-bg-base,#fff);--br-fg:var(--dsw-alias-label-primary,#222b38);--br-soft:var(--dsw-alias-bg-module-platform,#f4f6f8);--br-line:var(--dsw-alias-border-l2,#dce2e8);--br-muted:var(--dsw-alias-label-secondary,#667384);--br-accent:#336dbe;--br-green:var(--dsw-alias-state-success-primary,#18794e);--br-red:var(--dsw-alias-state-error-primary,#ba3340);color:var(--br-fg);background:var(--br-bg);font:inherit;font-size:13px;line-height:1.5;box-sizing:border-box;height:100%;overflow:auto;min-width:0;container-type:inline-size}
+.braid-panel *{box-sizing:border-box}.braid-panel button,.braid-panel select{font:inherit;color:inherit}.braid-panel button,.braid-panel select{border:1px solid var(--br-line);border-radius:7px;background:var(--br-bg);padding:6px 10px}.braid-panel button{cursor:pointer}.braid-panel button:hover:not(:disabled){border-color:var(--br-accent)}.braid-panel button:focus-visible,.braid-panel select:focus-visible{outline:2px solid var(--br-accent);outline-offset:2px}.braid-panel button:disabled{opacity:.45;cursor:default}.braid-panel .br-primary{background:var(--br-accent);color:white;border-color:transparent}.braid-panel .br-danger{color:var(--br-red)}
+.br-header{padding:20px 18px 12px;border-bottom:1px solid var(--br-line)}.br-heading{display:flex;align-items:center;gap:9px}.br-heading h2{font-size:18px;letter-spacing:-.4px;margin:0}.br-heading small{margin-left:auto;color:var(--br-muted)}.br-eyebrow{text-transform:uppercase;letter-spacing:1.4px;font-size:10px;color:var(--br-muted);margin-bottom:5px}.br-select{width:100%;margin:14px 0 8px}.br-goal{margin:8px 0;overflow-wrap:anywhere}.br-muted{color:var(--br-muted)}.br-toolbar{display:flex;gap:8px;align-items:center;flex-wrap:wrap}.br-status{display:inline-flex;align-items:center;gap:5px;font-size:11px;white-space:nowrap}.br-status:before{content:'';width:6px;height:6px;border-radius:50%;background:var(--br-muted)}.br-status[data-status=running]:before,.br-status[data-status=runnable]:before{background:var(--br-accent)}.br-status[data-status=completed]:before{background:var(--br-green)}.br-status[data-status=failed]:before,.br-status[data-status=cancelled]:before{background:var(--br-red)}.br-status[data-status=waiting]:before{background:#ba861a}
+.br-stats{display:grid;grid-template-columns:repeat(4,1fr);padding:14px 18px;gap:8px;border-bottom:1px solid var(--br-line)}.br-stats strong{display:block;font-size:16px;font-variant-numeric:tabular-nums}.br-stats span{font-size:10px;color:var(--br-muted)}.br-section{padding:14px 18px;border-bottom:1px solid var(--br-line)}.br-section h3{font-size:12px;margin:0 0 10px}.br-section-head{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-bottom:10px}.br-section-head h3{margin:0}.br-section-head button{padding:2px 8px}.br-graph{overflow:auto;background:var(--br-soft);border:1px solid var(--br-line);border-radius:9px;max-height:420px}.br-graph-canvas{position:relative}.br-graph svg{position:absolute;inset:0;overflow:visible}.br-graph path{fill:none;stroke:var(--br-muted);stroke-width:1.2}.br-graph text{font-size:10px;fill:var(--br-muted)}.br-node{position:absolute;display:flex;flex-direction:column;align-items:flex-start;justify-content:center;width:154px;height:72px;text-align:left;gap:2px;box-shadow:0 2px 5px #00000006}.br-node[aria-pressed=true]{outline:2px solid var(--br-accent);outline-offset:2px}.br-node strong{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.br-node small{font-size:10px;color:var(--br-muted)}.br-legend{display:flex;gap:12px;flex-wrap:wrap;font-size:10px;color:var(--br-muted);margin-top:8px}.br-note{font-size:11px;color:var(--br-muted);margin:8px 0 0;overflow-wrap:anywhere}
+.br-notice{margin:12px 18px;padding:10px 12px;border:1px solid var(--br-line);border-radius:8px;background:var(--br-soft);overflow-wrap:anywhere}.br-notice[role=alert]{color:var(--br-red)}.br-empty{padding:48px 24px;text-align:center}.br-empty h3{font-size:15px}.br-empty p{color:var(--br-muted);max-width:36em;margin:12px auto}.br-detail-grid{display:grid;grid-template-columns:1fr 1fr;gap:8px 16px;font-size:11px;margin:12px 0}.br-detail-grid span{color:var(--br-muted);display:block}.br-output{white-space:pre-wrap;overflow-wrap:anywhere;background:var(--br-soft);border:1px solid var(--br-line);padding:12px;border-radius:8px;max-height:340px;overflow:auto;font:11px/1.65 ui-monospace,SFMono-Regular,monospace;margin:8px 0}.br-tabs{display:flex;gap:5px;margin:14px 0 10px}.br-tabs button[aria-pressed=true]{border-color:var(--br-accent);color:var(--br-accent)}.br-events{list-style:none;padding:0;margin:0;max-height:320px;overflow:auto}.br-events li{padding:8px 0;display:grid;grid-template-columns:64px 1fr;gap:8px;border-bottom:1px solid var(--br-line);font-size:11px}.br-events time{color:var(--br-muted);font-variant-numeric:tabular-nums}.br-events p{margin:0;overflow-wrap:anywhere}.br-events small{color:var(--br-muted)}.br-header-action{font:inherit;border:0;border-radius:6px;padding:5px 9px;background:transparent;color:inherit;cursor:pointer}.br-header-action:hover{background:#8882}
+@container (max-width:330px){.br-stats{grid-template-columns:repeat(2,1fr)}.br-header,.br-section{padding-left:12px;padding-right:12px}}
+@media(prefers-color-scheme:dark){.braid-panel{--br-bg:var(--dsw-alias-bg-base,#171b22);--br-fg:var(--dsw-alias-label-primary,#e0e6ee);--br-soft:var(--dsw-alias-bg-module-platform,#202630);--br-line:var(--dsw-alias-border-l2,#354050);--br-muted:var(--dsw-alias-label-secondary,#a0adbe);--br-accent:#80b6ff;--br-green:var(--dsw-alias-state-success-primary,#69d6a0);--br-red:var(--dsw-alias-state-error-primary,#ff919a)}.braid-panel .br-primary{color:#162336}}
+[data-theme=dark] .braid-panel,.dark .braid-panel{--br-bg:var(--dsw-alias-bg-base,#171b22);--br-fg:var(--dsw-alias-label-primary,#e0e6ee);--br-soft:var(--dsw-alias-bg-module-platform,#202630);--br-line:var(--dsw-alias-border-l2,#354050);--br-muted:var(--dsw-alias-label-secondary,#a0adbe);--br-accent:#80b6ff;--br-green:var(--dsw-alias-state-success-primary,#69d6a0);--br-red:var(--dsw-alias-state-error-primary,#ff919a)}
+`;
+
+export const toolStyles = `
+.br-tool-call{font:inherit;font-size:12px;color:var(--dsw-alias-label-primary,inherit);border:1px solid var(--dsw-alias-border-l2,#8884);border-radius:9px;margin:8px 0;overflow:hidden}
+.br-tool-call button{font:inherit;color:inherit;cursor:pointer}.br-tool-call button:focus-visible{outline:2px solid #639be6;outline-offset:-2px}.br-tool-call button:disabled{cursor:default;opacity:.6}
+.br-tool-open{display:flex;width:100%;align-items:center;gap:10px;padding:12px;border:0;background:var(--dsw-alias-bg-module-platform,#8881);text-align:left}.br-tool-open:hover:not(:disabled){background:var(--dsw-alias-fill-l1,#8882)}.br-tool-open>span:last-child{margin-left:auto}
+.br-tool-main{display:flex;flex-wrap:wrap;align-items:baseline;gap:3px 8px;min-width:0}.br-tool-target{overflow-wrap:anywhere;color:var(--dsw-alias-label-secondary,inherit)}.br-tool-summary{flex-basis:100%;font-size:11px}.br-tool-call[data-state=failed] .br-tool-summary,.br-tool-error{color:var(--dsw-alias-state-error-primary,#c34e59)}
+.br-tool-actions{display:flex;gap:8px;padding:6px 12px}.br-tool-actions button{border:0;background:transparent;font-size:11px;text-decoration:underline;text-underline-offset:3px;padding:3px 0}.br-tool-details{padding:8px 12px;border-top:1px solid var(--dsw-alias-border-l2,#8884)}.br-tool-details pre{font:11px/1.6 ui-monospace,monospace;white-space:pre-wrap;overflow-wrap:anywhere;max-height:220px;overflow:auto}.br-tool-error{padding:0 12px;white-space:pre-wrap;overflow-wrap:anywhere;font-size:11px}
+.br-tool-note{margin:4px 12px;color:var(--dsw-alias-label-secondary,inherit);font-size:10px;opacity:.8}.br-tool-changes{display:flex;flex-wrap:wrap;gap:5px;padding:8px 12px}.br-tool-changes span{padding:3px 6px;border-radius:4px;background:var(--dsw-alias-bg-module-platform,#8881);font-size:10px;overflow-wrap:anywhere}.br-tool-jobs{list-style:none;margin:0;padding:6px 12px;max-height:230px;overflow:auto}.br-tool-jobs button{display:flex;gap:12px;width:100%;padding:6px 0;border:0;background:transparent;text-align:left}.br-tool-jobs span{margin-left:auto}
+`;
diff --git a/integrations/dsh/cordis.patch.yml b/integrations/dsh/cordis.patch.yml
new file mode 100644
index 0000000..d9d53df
--- /dev/null
+++ b/integrations/dsh/cordis.patch.yml
@@ -0,0 +1,3 @@
+- insert:
+    - id: chrok-braid
+      name: "@chrok/dsh-braid"
diff --git a/integrations/dsh/display.ts b/integrations/dsh/display.ts
new file mode 100644
index 0000000..7517d7c
--- /dev/null
+++ b/integrations/dsh/display.ts
@@ -0,0 +1,24 @@
+import type { JobSnapshot } from "./jobs.js";
+
+/** Plain text works in both DSH's native job panel and human command results. */
+export function renderPanel(job: JobSnapshot): string {
+  const state = job.execution;
+  const lines = [`Braid ${job.handle} · ${job.status} · revision ${state.revision}`, job.goal,
+    `Paused: ${state.pausedExecutionIds.join(", ") || "none"}`, ""];
+  for (const node of state.graph.nodes.slice(0, 80)) {
+    const result = state.nodes[node.id];
+    const progress = result?.executionId ? job.progress[result.executionId] : undefined;
+    lines.push(`${result?.status === "running" ? "▶" : "·"} ${node.id} [${node.type}] ${result?.status ?? "pending"}` +
+      (progress ? ` · context ${progress.contextTokens}${progress.contextWindow ? `/${progress.contextWindow}` : ""} (${progress.contextSource}) · tools ${progress.toolCalls}` : "") +
+      (result?.startedAt ? ` · ${Math.max(0, (result.finishedAt ?? Date.now()) - result.startedAt)} ms` : ""));
+    for (const edge of state.graph.edges.filter(edge => edge.from === node.id))
+      lines.push(`  └─${edge.choice ? ` ${edge.choice}` : ""}${edge.feedback ? ` ↻ ${edge.feedback}` : ""} → ${edge.to}`);
+    if (result?.error) lines.push(`  ${result.error.code}: ${result.error.message}`);
+  }
+  if (state.graph.nodes.length > 80) lines.push("… additional nodes available through braid_status");
+  lines.push("", "Recent events:", ...job.events.slice(-12).map(event =>
+    `#${event.sequence} ${event.type}${"nodeId" in event ? ` · ${event.nodeId}` : ""}${event.executionId ? ` · ${event.executionId}` : ""}`));
+  lines.push("", `Usage: ${job.usage.totalTokens ?? 0} tokens (including cache)`,
+    `Results: braid_status({"jobId":"${job.handle}"})`, `/braid cancel ${job.handle}`);
+  return lines.join("\n");
+}
diff --git a/integrations/dsh/index.ts b/integrations/dsh/index.ts
new file mode 100644
index 0000000..a2dce26
--- /dev/null
+++ b/integrations/dsh/index.ts
@@ -0,0 +1,149 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { createUserMessage, type UserMessage } from "@deepseek-ai/dsh-llm";
+import type {} from "@deepseek-ai/dsh-tools";
+import type {} from "@deepseek-ai/dsh-commands";
+import type {} from "@deepseek-ai/dsh-system-prompt";
+import type {} from "@deepseek-ai/dsh-jobs";
+import type { BraidInput } from "@chrok/braid";
+import { BraidJobs, type JobOptions, type JobSnapshot } from "./jobs.js";
+import { createBraidTools, graphReceipt } from "./tools.js";
+import { BRAID_USAGE_GUIDANCE } from "./schema.js";
+import { renderPanel } from "./display.js";
+import { BraidPanel } from "./panel.js";
+
+declare module "@deepseek-ai/dsh-llm" {
+  interface MessageSourceMap {
+    braid: { kind: "braid"; reminderId: string; form: "notice"; summary: string };
+  }
+}
+declare module "@deepseek-ai/dsh-jobs" {
+  interface JobKindMap { braid: "braid" }
+}
+
+export const name = "braid";
+export const inject = ["tools", "llm", "commands", "systemPrompt", "jobs"];
+
+export function apply(ctx: Context): void {
+  const observers = new Set<() => void>();
+  const changed = () => { for (const listener of observers) listener(); };
+  const sessions = new Map<Agent, { jobs: BraidJobs; pending: Map<string, UserMessage>; queued: Set<string>; release: () => Promise<void> }>();
+  ctx.inject(["typert"], ctx => {
+    new BraidPanel(ctx, id => [...sessions].find(([agent]) => agent.session.id === id)?.[1].jobs,
+      listener => { observers.add(listener); return () => { observers.delete(listener); }; });
+  });
+  const send = (agent: Agent, message: UserMessage) => {
+    if (message.source.kind !== "braid") return;
+    const state = sessions.get(agent);
+    if (!state || state.queued.has(message.source.reminderId)) return;
+    state.queued.add(message.source.reminderId);
+    try { agent.steer(message); }
+    catch { state.queued.delete(message.source.reminderId); }
+  };
+  const session = (agent: Agent) => {
+    const existing = sessions.get(agent);
+    if (existing) return existing;
+    const pending = new Map<string, UserMessage>();
+    const jobs = new BraidJobs(ctx.llm, completion => {
+      const { jobId, handle, status, executionId, nodeId, paused, sequence } = completion;
+      const reminderId = JSON.stringify([jobId, executionId ?? "job", sequence ?? 0]);
+      const lookup = JSON.stringify({ jobId: handle, ...(executionId ? { executionId } : {}) });
+      const summary = `Braid ${handle}${nodeId ? ` / ${nodeId}` : ""}: ${paused ? "paused" : status}`.slice(0, 120);
+      const message = createUserMessage({
+        source: { kind: "braid", reminderId, form: "notice", summary },
+        content: [{ type: "text", text: `[system-reminder] ${summary}. Retrieve results with braid_status(${lookup}) and continue the original task. Failed or cancelled jobs may contain successful partial results. ${paused ? "Outgoing scheduling was paused. Inspect CURRENT execution.revision and pausedExecutionIds before braid_update with resume or braid_resume. Deadlines continue; finalized jobs cannot resume." : "This reminder does not pause scheduling."} [/system-reminder]` }],
+      });
+      pending.set(reminderId, message); send(agent, message);
+    });
+    const value = { jobs, pending, queued: new Set<string>(), release: () => jobs.dispose() };
+    sessions.set(agent, value);
+    const off = jobs.subscribe(changed);
+    changed();
+    // Agent-scoped effects unwind on clear, reload, disposal, or session replacement.
+    value.release = agent.ctx.effect(() => () => {
+      off(); pending.clear(); sessions.delete(agent); changed(); return jobs.dispose();
+    });
+    return value;
+  };
+  const requireAgent = (agent: Agent | undefined): Agent => {
+    if (!agent) throw new Error("Braid requires an owning DSH agent");
+    return agent;
+  };
+  ctx.jobs.attachController("braid");
+  for (const tool of createBraidTools(exec => session(requireAgent(exec.agent)).jobs, (args, exec) => {
+    const jobs = session(requireAgent(exec.agent)).jobs;
+    const agent = requireAgent(exec.agent);
+    const { options, ...input } = args;
+    let snapshot: JobSnapshot | undefined;
+    const nativeJobId = ctx.jobs.start({
+      kind: "braid", label: args.goal.slice(0, 200), owner: agent.session.id,
+      run(native) {
+        const { provider, model } = agent.options;
+        snapshot = jobs.start(input as BraidInput, (options ?? {}) as JobOptions, {
+          cwd: agent.session.header.cwd ?? process.cwd(),
+          ...(provider && model ? { model: `${provider}/${model}` } : {}),
+        });
+        const handle = snapshot.handle;
+        native.append(renderPanel(snapshot) + "\n", { channel: "log" });
+        let previous = "", timer: ReturnType<typeof setTimeout> | undefined;
+        const refresh = () => {
+          timer = undefined;
+          const job = jobs.get(handle);
+          const panel = renderPanel(job);
+          if (panel !== previous) { previous = panel; native.append("\n" + panel + "\n", { channel: "log" }); }
+          native.updateProgress(`${handle} · ${job.execution.status} · ${Object.keys(job.execution.executions).length} executions`);
+        };
+        const unsubscribe = jobs.subscribe(() => { timer ??= setTimeout(refresh, 250); });
+        return {
+          cancel: () => { jobs.cancel(handle); },
+          done: jobs.wait(handle).then(() => {
+            clearTimeout(timer); unsubscribe(); refresh();
+            const job = jobs.get(handle);
+            return { status: job.status === "cancelled" ? "killed" as const : job.status === "completed" ? "completed" as const : "failed" as const,
+              detail: `Braid ${handle}; retrieve with braid_status`, result: JSON.stringify({ jobId: handle, status: job.status }) };
+          }),
+        };
+      },
+    });
+    return { jobId: snapshot!.handle, canonicalJobId: snapshot!.jobId, nativeJobId, status: snapshot!.status,
+      graph: graphReceipt(snapshot!), message: "Running in background. Open Braid in the session header for the live graph and execution details, or use the Jobs panel / /braid. Completion reminders wake an idle agent or steer at the next step. Do not poll repeatedly." };
+  })) ctx.tools.register(tool);
+
+  ctx.systemPrompt.section({ name: "braid", order: 80, text: BRAID_USAGE_GUIDANCE, interpolate: false });
+  ctx.commands.register({ name: "braid", description: "Show Braid flow/progress or cancel a job; live progress also appears in the Jobs panel.", input: { hint: "[jobId] | cancel <jobId> | list" },
+    handler({ agent, rawInput, signal }) {
+      signal.throwIfAborted();
+      try {
+        const jobs = session(agent).jobs;
+        const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+        if (parts[0] === "cancel" && parts.length === 2)
+          return { kind: "success", text: jobs.cancel(parts[1]!) ? "Cancellation requested." : "Job already finished." };
+        if (parts.length > 1 || parts[0] === "cancel") return { kind: "error", text: "Usage: /braid [jobId] | cancel <jobId> | list" };
+        if (parts[0] === "list") return { kind: "success", text: JSON.stringify(jobs.list(), null, 2) };
+        const id = parts[0] ?? jobs.list()[0]?.handle;
+        return { kind: "success", text: id ? renderPanel(jobs.get(id)) : "No Braid jobs in this session." };
+      } catch (error) { return { kind: "error", text: error instanceof Error ? error.message : String(error) }; }
+    },
+  });
+  ctx.on("agent/inbox/claimed", ({ agent, message }) => {
+    if (message.source.kind === "braid") {
+      sessions.get(agent)?.pending.delete(message.source.reminderId);
+      sessions.get(agent)?.queued.delete(message.source.reminderId);
+    }
+  });
+  ctx.on("agent/inbox/discarded", ({ agent, message }) => {
+    if (message.source.kind === "braid") sessions.get(agent)?.queued.delete(message.source.reminderId);
+  });
+  ctx.on("agent/status", ({ agent, status }) => {
+    if (status === "idle") for (const message of sessions.get(agent)?.pending.values() ?? []) send(agent, message);
+  });
+  ctx.on("agent/disposed", ({ agent }) => {
+    const value = sessions.get(agent);
+    value?.pending.clear(); sessions.delete(agent); changed(); void value?.release();
+  });
+  ctx.effect(() => async () => {
+    const active = [...sessions.values()]; sessions.clear();
+    for (const value of active) value.pending.clear();
+    await Promise.all(active.map(value => value.release()));
+  });
+}
diff --git a/integrations/dsh/jobs.ts b/integrations/dsh/jobs.ts
new file mode 100644
index 0000000..78e18be
--- /dev/null
+++ b/integrations/dsh/jobs.ts
@@ -0,0 +1,182 @@
+import { randomUUID } from "node:crypto";
+import { setImmediate as nextTurn } from "node:timers/promises";
+import { startBraid, validateGraph, type BraidInput, type BraidRun, type BraidResult, type BraidSnapshot, type GraphUpdate, type ExecutionEvent, type NodeResult } from "@chrok/braid";
+import type { TokenUsage } from "@deepseek-ai/dsh-llm";
+import { createDshRunner, sumUsage, validateBudgets, type NodeProgress, type DshLlm } from "./runner.js";
+
+export interface JobOptions {
+  maxConcurrency?: number;
+  maxExecutions?: number;
+  nodeTimeoutMs?: number;
+  graphTimeoutMs?: number;
+  maxToolRounds?: number;
+  maxToolCalls?: number;
+}
+
+export interface JobSnapshot {
+  jobId: string;
+  handle: string;
+  goal: string;
+  status: "running" | "completed" | "failed" | "cancelled";
+  createdAt: number;
+  execution: BraidSnapshot;
+  result?: BraidResult;
+  error?: string;
+  usage: TokenUsage;
+  progress: Record<string, NodeProgress>;
+  events: ExecutionEvent[];
+}
+
+interface Job {
+  jobId: string;
+  handle: string;
+  goal: string;
+  status: JobSnapshot["status"];
+  createdAt: number;
+  run: BraidRun;
+  done: Promise<void>;
+  result?: BraidResult;
+  error?: string;
+  reports: TokenUsage[];
+  progress: Record<string, NodeProgress>;
+  events: ExecutionEvent[];
+}
+
+export interface Completion {
+  jobId: string;
+  handle: string;
+  status: string;
+  executionId?: string;
+  nodeId?: string;
+  iteration?: number;
+  paused?: boolean;
+  sequence?: number;
+}
+
+/** One manager per live DSH agent; foreground cancellation never owns these runs. */
+export class BraidJobs {
+  private jobs = new Map<string, Job>();
+  private handles = new Map<string, string>();
+  private listeners = new Set<() => void>();
+  private disposed = false;
+  private nextHandle = 1;
+
+  constructor(private llm: DshLlm, private notify: (completion: Completion) => void = () => {}) {}
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+
+  private changed(): void {
+    for (const listener of this.listeners) { try { listener(); } catch { /* UI isolation. */ } }
+  }
+
+  start(input: BraidInput, options: JobOptions, context: { cwd: string; model?: string }): JobSnapshot {
+    if (this.disposed) throw new Error("Braid session has closed");
+    validateGraph(input);
+    validateBudgets({ maxToolRounds: options.maxToolRounds, maxToolCalls: options.maxToolCalls });
+    const jobId = randomUUID(), handle = `job-${this.nextHandle}`;
+    const reports: TokenUsage[] = [];
+    const events: ExecutionEvent[] = [];
+    const progress: Record<string, NodeProgress> = Object.create(null);
+    const invoke = createDshRunner(this.llm, { cwd: context.cwd,
+      ...(options.maxToolRounds === undefined ? {} : { maxToolRounds: options.maxToolRounds }),
+      ...(options.maxToolCalls === undefined ? {} : { maxToolCalls: options.maxToolCalls }),
+      onUsage: usage => { reports.push(usage); },
+      onProgress: value => { progress[value.executionId] = value; this.changed(); },
+    });
+    // Core options and graph validation happen synchronously before publishing a handle.
+    const run = startBraid(structuredClone(input), {
+      cwd: context.cwd, ...options,
+      nodeTimeoutMs: options.nodeTimeoutMs ?? Infinity, graphTimeoutMs: options.graphTimeoutMs ?? Infinity,
+      ...(context.model ? { defaultModel: context.model } : {}),
+      runner: async request => { await nextTurn(); return invoke(request); },
+      onEvent: event => {
+        events.push(structuredClone(event));
+        if (events.length > 80) events.shift();
+        this.changed();
+        this.onEvent(jobId, handle, event);
+      },
+    });
+    const job: Job = { jobId, handle, goal: input.goal, status: "running", createdAt: Date.now(), run, reports, progress, events, done: Promise.resolve() };
+    this.nextHandle++;
+    this.jobs.set(jobId, job); this.handles.set(handle, jobId);
+    job.done = (async () => {
+      try {
+        job.result = await run.result;
+        job.status = job.result.error?.code === "CANCELLED" ? "cancelled" : job.result.status;
+      } catch (error) {
+        job.error = error instanceof Error ? error.message : String(error);
+        job.status = "failed";
+      }
+      this.changed();
+      this.remind({ jobId, handle, status: job.status });
+    })();
+    this.changed();
+    return this.get(handle);
+  }
+
+  private onEvent(jobId: string, handle: string, event: ExecutionEvent): void {
+    if (!["execution_paused", "node_completed", "node_failed"].includes(event.type) || !event.executionId) return;
+    const state = this.jobs.get(jobId)?.run.snapshot();
+    const node = state?.executions[event.executionId];
+    if (!node) return;
+    const paused = event.type === "execution_paused";
+    if (!paused && (!node.node.notifyOnCompletion || (node.node.pauseAfter && !state?.error))) return;
+    this.remind({ jobId, handle, status: node.status, executionId: node.executionId, nodeId: node.id,
+      ...(node.iteration === undefined ? {} : { iteration: node.iteration }), paused, sequence: event.sequence });
+  }
+
+  private remind(completion: Completion): void {
+    if (this.disposed) return;
+    try { this.notify(completion); } catch { /* Notification failures cannot fail jobs. */ }
+  }
+
+  private lookup(id: string): Job {
+    const job = this.jobs.get(this.handles.get(id) ?? id);
+    if (!job) throw new Error(`Unknown Braid job: ${id}. Use an exact session handle or UUID. Available jobs: ${JSON.stringify(this.list())}`);
+    return job;
+  }
+
+  get(id: string): JobSnapshot {
+    const { run, done: _done, reports, ...job } = this.lookup(id);
+    return structuredClone({ ...job, execution: run.snapshot(), usage: sumUsage(reports) });
+  }
+
+  getNode(id: string, nodeId?: string, executionId?: string): NodeResult {
+    const state = this.lookup(id).run.snapshot();
+    const selected = executionId ? state.executions : state.nodes;
+    const key = executionId ?? nodeId;
+    const node = key && Object.hasOwn(selected, key) ? selected[key] : undefined;
+    if (!node || (nodeId && node.id !== nodeId)) throw new Error("Unknown Braid node or execution; inspect braid_status with only jobId");
+    return structuredClone(node);
+  }
+
+  list() {
+    return [...this.jobs.values()].reverse().map(({ jobId, handle, goal, status, createdAt }) => ({ jobId, handle, goal, status, createdAt }));
+  }
+
+  update(id: string, patch: GraphUpdate): JobSnapshot {
+    this.lookup(id).run.update(patch); this.changed(); return this.get(id);
+  }
+
+  resume(id: string, executionIds: readonly string[], expectedRevision: number): JobSnapshot {
+    this.lookup(id).run.resume(executionIds, expectedRevision); this.changed(); return this.get(id);
+  }
+
+  cancel(id: string): boolean {
+    const job = this.lookup(id);
+    if (job.status !== "running") return false;
+    job.run.cancel(); return true;
+  }
+
+  async wait(id: string): Promise<void> { await this.lookup(id).done; }
+
+  async dispose(): Promise<void> {
+    this.disposed = true;
+    this.listeners.clear();
+    for (const job of this.jobs.values()) job.run.cancel();
+    await Promise.all([...this.jobs.values()].map(job => job.done));
+  }
+}
diff --git a/integrations/dsh/package.json b/integrations/dsh/package.json
new file mode 100644
index 0000000..ed05de0
--- /dev/null
+++ b/integrations/dsh/package.json
@@ -0,0 +1,119 @@
+{
+  "name": "@chrok/dsh-braid",
+  "version": "0.3.0",
+  "license": "MIT",
+  "description": "DeepSeek Harness plugin for Braid: background agent graphs, bounded loops, live updates, and execution progress",
+  "type": "module",
+  "dependencies": {
+    "@chrok/braid": "0.3.0",
+    "@sinclair/typebox": "^0.34.41"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-commands": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-jobs": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "0.2.0-rc.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-api-gateway": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-chat": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-tool": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-commands": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-jobs": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-jobs-local": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "0.2.0-rc.2",
+    "@types/jsdom": "21.1.7",
+    "@types/node": "^22.0.0",
+    "@types/react": "18.3.28",
+    "@types/react-dom": "18.3.7",
+    "esbuild": "0.25.12",
+    "jsdom": "26.1.0",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "check": "tsc --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "test": "node build-client.mjs && tsx --tsconfig tsconfig.json --test test/*.test.ts test/*.test.mjs test/client/*.test.tsx",
+    "build": "node ../../scripts/build.mjs dsh",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Epsirom/braid.git",
+    "directory": "integrations/dsh"
+  },
+  "homepage": "https://github.com/Epsirom/braid/tree/main/integrations/dsh#readme",
+  "bugs": {
+    "url": "https://github.com/Epsirom/braid/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "llm",
+    "ai-agents",
+    "agents",
+    "agent-orchestration",
+    "graph",
+    "bounded-loops",
+    "git-worktree",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "cordis.patch.yml"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "default": "./dist/client.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-api-gateway",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-tool"
+      ]
+    }
+  }
+}
diff --git a/integrations/dsh/panel-contract.ts b/integrations/dsh/panel-contract.ts
new file mode 100644
index 0000000..c38e9ed
--- /dev/null
+++ b/integrations/dsh/panel-contract.ts
@@ -0,0 +1,37 @@
+import type { InvocationDescriptor, RemoteResult } from "@deepseek-ai/dsh-typert-protocol";
+import type { ControlRequest, DetailRequest, PanelDetail, PanelFrame, PanelRequest } from "./panel-types.js";
+
+/** One descriptor table shared by Host registration and Client Remote mounting. */
+export const PANEL_PACKAGE = "@chrok/dsh-braid";
+function parseRequest(value: unknown, method: string): unknown {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid Braid panel request");
+  const r = value as Record<string, unknown>;
+  const id = (key: string) => typeof r[key] === "string" && (r[key] as string).length > 0 && (r[key] as string).length <= 1024;
+  if (!id("sessionId") || (r.jobId !== undefined && !id("jobId"))) throw new Error("Invalid session or job ID");
+  if (r.createdBefore !== undefined && (!Number.isSafeInteger(r.createdBefore) || Number(r.createdBefore) < 0)) throw new Error("Invalid call timestamp");
+  if (method !== "watch" && !id("jobId")) throw new Error("A job ID is required");
+  if (method === "control" && (
+    !["cancel", "resume"].includes(String(r.action)) || !Number.isSafeInteger(r.revision) || Number(r.revision) < 0 ||
+    !Array.isArray(r.executionIds) || r.executionIds.length > 10000 || r.executionIds.some(v => typeof v !== "string" || !v || v.length > 1024)
+  )) throw new Error("Invalid Braid control request");
+  if (method === "detail" && (!id("executionId") || !Number.isSafeInteger(r.offset) || Number(r.offset) < 0)) throw new Error("Invalid execution or offset");
+  return value;
+}
+export const panelDescriptors: InvocationDescriptor[] = ["watch", "control", "detail"].map(method => ({
+  id: `${PANEL_PACKAGE}#braidPanel/${method}`, service: "braidPanel", namespace: "braidPanel", method,
+  invocation: { kind: "direct" },
+  parameters: [{ name: "request", wire: "request", source: "json", codec: {
+    mode: "strict", typeSymbol: `${PANEL_PACKAGE}/${method}Request`, create: () => ({ parse: value => parseRequest(value, method) }),
+  } }],
+  result: { mode: "src-json" },
+  ...(method === "watch" ? { mode: "stream" as const, cancellation: { parameter: "signal" as const } } : {}),
+}));
+export interface PanelRemote {
+  watch(request: PanelRequest, signal?: AbortSignal): AsyncIterable<PanelFrame>;
+  control(request: ControlRequest): Promise<RemoteResult<PanelFrame>>;
+  detail(request: DetailRequest): Promise<RemoteResult<PanelDetail>>;
+}
+declare module "@deepseek-ai/dsh-typert-protocol" {
+  interface TypertRemoteNamespaceMap { braidPanel: PanelRemote }
+  interface RemoteErrorDetailsMap { "braid/panel": { sessionId: string } }
+}
diff --git a/integrations/dsh/panel-types.ts b/integrations/dsh/panel-types.ts
new file mode 100644
index 0000000..f8fa391
--- /dev/null
+++ b/integrations/dsh/panel-types.ts
@@ -0,0 +1,30 @@
+/** Browser-safe, bounded projections. Prompts and provider messages never enter the panel stream. */
+export interface PanelRequest { sessionId: string; jobId?: string; createdBefore?: number }
+export interface ControlRequest extends PanelRequest { jobId: string; action: "cancel" | "resume"; revision: number; executionIds: string[] }
+export interface DetailRequest extends PanelRequest { jobId: string; executionId: string; offset: number }
+export interface PanelRow { jobId: string; handle: string; goal: string; status: string; createdAt: number }
+export interface PanelExecution {
+  id: string; executionId: string; status: string; type: string; revision: number;
+  iteration?: number; loopId?: string; latencyMs?: number;
+  progress?: { contextTokens: number; contextWindow?: number; contextSource: string; toolCalls: number; toolRounds: number; phase: string };
+}
+export interface PanelJob extends PanelRow {
+  revision: number; phase: string; error?: string;
+  nodes: { id: string; type: string; status: string }[];
+  edges: { from: string; to: string; choice?: string; feedback?: string; executionId?: string }[];
+  loops: { id: string; entry: string; maxIterations: number }[];
+  executions: PanelExecution[];
+  pausedExecutionIds: string[];
+  usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number };
+  events: { sequence: number; timestamp: number; type: string; executionId?: string; nodeId?: string; message: string }[];
+}
+export interface PanelFrame { rows: PanelRow[]; job: PanelJob | null }
+export interface PanelDetail {
+  executionId: string; status: string; output: string; offset: number; next: number; total: number;
+  decision?: string; error?: string; workspace?: string;
+}
+export interface PanelApi {
+  watch(request: PanelRequest, signal: AbortSignal): AsyncIterable<PanelFrame>;
+  control(request: ControlRequest): Promise<PanelFrame>;
+  detail(request: DetailRequest): Promise<PanelDetail>;
+}
diff --git a/integrations/dsh/panel.ts b/integrations/dsh/panel.ts
new file mode 100644
index 0000000..ce73687
--- /dev/null
+++ b/integrations/dsh/panel.ts
@@ -0,0 +1,103 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import type {} from "@deepseek-ai/dsh-typert-registry";
+import type { BraidJobs, JobSnapshot } from "./jobs.js";
+import { PANEL_PACKAGE, panelDescriptors } from "./panel-contract.js";
+import type { ControlRequest, DetailRequest, PanelDetail, PanelFrame, PanelJob, PanelRequest } from "./panel-types.js";
+
+const clip = (text: string, limit = 2000) => text.length > limit ? text.slice(0, limit) + "…" : text;
+export function panelJob(job: JobSnapshot): PanelJob {
+  const state = job.execution;
+  return {
+    jobId: job.jobId, handle: job.handle, goal: clip(job.goal), status: job.status, createdAt: job.createdAt,
+    revision: state.revision, phase: state.status,
+    ...(job.error || state.error ? { error: clip(job.error ?? state.error!.message) } : {}),
+    nodes: state.graph.nodes.map(node => ({ id: node.id, type: node.type, status: state.nodes[node.id]?.status ?? "pending" })),
+    edges: state.graph.edges.map(edge => ({ ...edge })), loops: [...state.graph.loops ?? []],
+    executions: Object.values(state.executions).map(e => ({
+      id: e.id, executionId: e.executionId, status: e.status, type: e.node.type, revision: e.revision,
+      ...(e.iteration === undefined ? {} : { iteration: e.iteration }),
+      ...(e.loopId === undefined ? {} : { loopId: e.loopId }),
+      ...(e.latencyMs === undefined ? {} : { latencyMs: e.latencyMs }),
+      ...(job.progress[e.executionId] ? { progress: job.progress[e.executionId]! } : {}),
+    })),
+    pausedExecutionIds: [...state.pausedExecutionIds],
+    usage: { inputTokens: job.usage.inputTokens ?? 0, outputTokens: job.usage.outputTokens ?? 0,
+      cacheReadTokens: job.usage.cacheReadTokens ?? 0, cacheWriteTokens: job.usage.cacheWriteTokens ?? 0 },
+    events: job.events.map(e => ({ sequence: e.sequence, timestamp: e.timestamp, type: e.type,
+      ...(e.executionId ? { executionId: e.executionId } : {}), ...("nodeId" in e ? { nodeId: e.nodeId } : {}),
+      message: clip("error" in e ? e.error.message : e.type === "handoff" ? `${e.from} → ${e.to}` : e.type === "edge_created" ? `${e.from} → ${e.to}` : e.type.replaceAll("_", " "), 500),
+    })),
+  };
+}
+
+/** Session managers are borrowed; viewing a panel never creates an Agent or starts model work. */
+export class BraidPanel extends TypertRemoteService {
+  constructor(ctx: Context, private readonly find: (sessionId: string) => BraidJobs | undefined,
+    private readonly subscribe: (listener: () => void) => () => void) {
+    super(ctx, "braidPanel");
+    ctx.typert.register({ package: PANEL_PACKAGE, face: "host", schemas: [], model: { services: [], events: [], objects: [] }, invocations: panelDescriptors });
+  }
+  snapshot(request: PanelRequest): PanelFrame {
+    const jobs = this.find(request.sessionId);
+    const rows = jobs?.list().map(row => ({ ...row, goal: clip(row.goal) })) ?? [];
+    // Old tool cards can carry short handles. Fence them by the call's timestamp
+    // so a Host/plugin restart cannot redirect an old card to a reused handle.
+    const selected = request.jobId ? rows.find(row => (row.jobId === request.jobId || row.handle === request.jobId)
+      && (request.createdBefore === undefined || row.createdAt <= request.createdBefore)) : rows[0];
+    if (request.jobId && !selected) throw new Error("Braid job is no longer available in this session");
+    const id = selected?.jobId;
+    return { rows, job: id && jobs ? panelJob(jobs.get(id)) : null };
+  }
+  @Remote({ mode: "stream" })
+  async *watch(request: PanelRequest, signal: AbortSignal): AsyncIterable<PanelFrame> {
+    let dirty = true, wake: (() => void) | undefined;
+    const changed = () => { dirty = true; wake?.(); };
+    const off = this.subscribe(changed);
+    signal.addEventListener("abort", changed, { once: true });
+    try {
+      while (!signal.aborted) {
+        if (!dirty) await new Promise<void>(resolve => { wake = resolve; });
+        wake = undefined;
+        if (signal.aborted) break;
+        dirty = false;
+        try { yield this.snapshot(request); }
+        catch (error) { throw this.failure(request, error); }
+        // Coalesce token bursts; cancellation also wakes this delay.
+        await new Promise<void>(resolve => {
+          const done = () => { clearTimeout(timer); signal.removeEventListener("abort", done); resolve(); };
+          const timer = setTimeout(done, 150);
+          signal.addEventListener("abort", done, { once: true });
+          if (signal.aborted) done();
+        });
+      }
+    } finally { off(); signal.removeEventListener("abort", changed); }
+  }
+  @Remote
+  control(request: ControlRequest): PanelFrame {
+    try {
+      this.snapshot(request);
+      const jobs = this.find(request.sessionId)!;
+      if (request.action === "resume") jobs.resume(request.jobId, request.executionIds, request.revision);
+      else jobs.cancel(request.jobId);
+      return this.snapshot(request);
+    } catch (error) { throw this.failure(request, error); }
+  }
+  @Remote
+  detail(request: DetailRequest): PanelDetail {
+    try {
+      this.snapshot(request);
+      const node = this.find(request.sessionId)!.getNode(request.jobId, undefined, request.executionId);
+      const output = node.output ?? "";
+      const offset = Math.min(request.offset, output.length), next = Math.min(offset + 32768, output.length);
+      return { executionId: request.executionId, status: node.status, output: output.slice(offset, next), offset, next, total: output.length,
+        ...(node.decision === undefined ? {} : { decision: clip(node.decision) }),
+        ...(node.error ? { error: clip(node.error.message) } : {}),
+        ...(node.workspace ? { workspace: clip(JSON.stringify(node.workspace, null, 2), 8000) } : {}),
+      };
+    } catch (error) { throw this.failure(request, error); }
+  }
+  private failure(request: PanelRequest, error: unknown) {
+    return new RemoteError("braid/panel", error instanceof Error ? error.message : String(error), { sessionId: request.sessionId });
+  }
+}
diff --git a/integrations/dsh/runner.ts b/integrations/dsh/runner.ts
new file mode 100644
index 0000000..582579c
--- /dev/null
+++ b/integrations/dsh/runner.ts
@@ -0,0 +1,188 @@
+import { resolve } from "node:path";
+import {
+  BlockAssembler, createToolResultMessage,
+  type LlmRuntime, type RequestMessage, type TokenUsage,
+} from "@deepseek-ai/dsh-llm";
+import {
+  formatBudgetReminder, gitToolDefinition, finishMergeToolDefinition,
+  mergeInstructions, parseGitToolArguments, parseFinishMergeArguments,
+  type ModelRunner,
+} from "@chrok/braid";
+import { createWorkerTools } from "./worker-tools.js";
+
+export interface NodeProgress {
+  nodeId: string;
+  executionId: string;
+  contextTokens: number;
+  contextWindow?: number;
+  contextSource: "reported" | "estimate";
+  toolCalls: number;
+  toolRounds: number;
+  phase: "model" | "tool";
+}
+
+export interface RunnerOptions {
+  cwd: string;
+  maxToolRounds?: number;
+  maxToolCalls?: number;
+  onUsage?: (usage: TokenUsage) => void;
+  onProgress?: (progress: NodeProgress) => void;
+}
+
+export function validateBudgets(options: { maxToolRounds?: number | undefined; maxToolCalls?: number | undefined }): void {
+  for (const [key, value] of Object.entries(options)) {
+    if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value < 1))
+      throw new Error(`${key} must be a positive safe integer or Infinity`);
+  }
+}
+
+/** Fresh, private model contexts. DSH owns provider routing and credentials. */
+export type DshLlm = Pick<LlmRuntime, "stream"> & Partial<Pick<LlmRuntime, "resolveModelInfo">>;
+
+export function createDshRunner(llm: DshLlm, options: RunnerOptions): ModelRunner {
+  validateBudgets({ maxToolRounds: options.maxToolRounds, maxToolCalls: options.maxToolCalls });
+  return async request => {
+    const route = request.model;
+    const slash = route?.indexOf("/") ?? -1;
+    if (!route || slash < 1 || slash === route.length - 1)
+      throw new Error("Choose a DSH provider/model, or set node.model to an exact provider/model-id");
+    const provider = route.slice(0, slash), model = route.slice(slash + 1);
+    const modelInfo = await llm.resolveModelInfo?.(provider, model, request.signal);
+    const contextWindow = modelInfo?.context?.contextWindow;
+    request.signal.throwIfAborted();
+    const workspace = request.workspace ?? {
+      nodeId: request.node.id, mode: "read-only" as const,
+      workingDirectory: resolve(options.cwd), state: "ready" as const,
+    };
+    const files = await createWorkerTools(request, workspace);
+    const tools = files.map(({ name, description, parameters }) => ({ name, description, parameters: JSON.parse(JSON.stringify(parameters)) as Record<string, unknown> }));
+    const integrating = request.node.type === "merge" || request.node.type === "integrate";
+    if (request.git) tools.push(gitToolDefinition(integrating));
+    if (request.merge) tools.push(finishMergeToolDefinition(request.merge.sources.map(source => source.executionId!)));
+    if (request.node.type === "decision") tools.push({
+      name: "decide", description: "Select exactly one declared choice before answering.",
+      parameters: { type: "object", properties: { choice: { type: "string", enum: request.node.choices } }, required: ["choice"], additionalProperties: false },
+    });
+    const messages: RequestMessage[] = [{ role: "user", content: [{ type: "text", text: JSON.stringify({
+      goal: request.goal, nodeId: request.node.id, execution: request.execution,
+      prompt: request.node.prompt, predecessors: request.predecessors, workspace,
+      ...(request.merge ? { mergeSources: request.merge.sources, sourceCheckoutStatus: request.merge.sourceStatus } : {}),
+    }) }] }];
+    const system = "You are an isolated Braid worker. Complete only the assigned node. " +
+      "Use read, ls, grep, and find to inspect files. Only writable Git workspaces have write, edit, and shell tools. " +
+      "Use your assigned workingDirectory. Never write outside it; integrate alone may edit sourceRoot. " +
+      "Shell tools have host permissions, not a sandbox. Do not change shared Git refs, branches, configuration, hooks, or worktree registrations. " +
+      "Do not launch recursive agents, daemons, or background servers. Use execution-specific temporary resources. " +
+      "Checkpoints exclude ignored new dependencies, caches, and build outputs. Run tests for your changes. " +
+      "Parent transcript, skills, extension tools, and MCP tools are not inherited. " +
+      mergeInstructions(request) +
+      (request.node.type === "decision" ? "Call decide exactly once, then answer. " : "") +
+      "Return a nonempty natural-language result.";
+    let toolRounds = 0, toolCalls = 0, decided = false;
+    let contextTokens = 0;
+    let contextSource: NodeProgress["contextSource"] = "estimate";
+    const reports: TokenUsage[] = [];
+    const output: string[] = [];
+    const progress = (phase: NodeProgress["phase"]) => {
+      try { options.onProgress?.({ nodeId: request.node.id, executionId: request.execution.executionId!, contextTokens, ...(contextWindow === undefined ? {} : { contextWindow }), contextSource, toolCalls, toolRounds, phase }); }
+      catch { /* Observers cannot fail a worker. */ }
+    };
+    while (true) {
+      request.signal.throwIfAborted();
+      const budgets = [
+        ...(options.maxToolRounds === undefined ? [] : [`Tool round budget: ${toolRounds}/${options.maxToolRounds} used.`]),
+        ...(options.maxToolCalls === undefined ? [] : [`Tool call budget: ${toolCalls}/${options.maxToolCalls} used; rejected requests count.`]),
+        "Reserve budget for decide or finish_merge. At zero remaining, return your final answer without further tools.",
+      ];
+      const activeTools = tools.filter(tool => !decided || tool.name !== "decide");
+      const prompt = system + formatBudgetReminder(request, budgets);
+      contextTokens = Math.ceil(JSON.stringify({ messages, system: prompt, tools: activeTools }).length / 4);
+      contextSource = "estimate";
+      progress("model");
+      const assembler = new BlockAssembler();
+      let finished = false;
+      try {
+        for await (const chunk of llm.stream({ provider, model, messages, system: prompt, tools: activeTools, signal: request.signal })) {
+          request.signal.throwIfAborted();
+          assembler.push(chunk);
+          if (chunk.type === "finish") finished = true;
+        }
+      } finally {
+        if (assembler.usage) {
+          const usage = structuredClone(assembler.usage);
+          reports.push(usage);
+          options.onUsage?.(usage);
+          contextTokens = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+          contextSource = "reported";
+          progress("model");
+        }
+      }
+      request.signal.throwIfAborted();
+      const finish = assembler.finish;
+      if (!finished) throw new Error("DSH model stream ended without a finish event");
+      if (finish.kind !== "stop" && finish.kind !== "tool-calls")
+        throw new Error("failure" in finish ? finish.failure.message : `DSH model ended with ${finish.kind}`);
+      const response = assembler.message({ provider, model, ...(assembler.replayState ? { replayState: assembler.replayState } : {}) });
+      output.push(...response.content.flatMap(block => block.type === "text" ? [block.text] : []));
+      const calls = response.content.filter(block => block.type === "tool-call");
+      if (!calls.length) {
+        if (finish.kind === "tool-calls") throw new Error("DSH requested tool use without tool calls");
+        break;
+      }
+      if (finish.kind !== "tool-calls") throw new Error("DSH returned tool calls with an invalid finish reason");
+      toolRounds++;
+      toolCalls += calls.length;
+      progress("tool");
+      if (toolRounds > (options.maxToolRounds ?? Infinity) || toolCalls > (options.maxToolCalls ?? Infinity))
+        throw new Error("Braid node exceeded its tool budget");
+      messages.push(response);
+      for (const call of calls) {
+        request.signal.throwIfAborted();
+        let text: string, isError = false;
+        try {
+          const args: unknown = JSON.parse(call.arguments);
+          if (call.name === "decide" && request.decide) {
+            if (!args || typeof args !== "object" || Array.isArray(args) || Object.keys(args).length !== 1 || !("choice" in args) || typeof args.choice !== "string")
+              throw new Error("decide requires exactly one string argument: choice");
+            request.decide(args.choice);
+            decided = true;
+            text = JSON.stringify({ choice: args.choice });
+          } else if (call.name === "git" && request.git) {
+            const parsed = parseGitToolArguments(args, integrating);
+            const result = await request.git(parsed.args, parsed.input);
+            text = JSON.stringify(result); isError = result.exitCode !== 0;
+          } else if (call.name === "finish_merge" && request.merge) {
+            await request.merge.finish(parseFinishMergeArguments(args, request.merge.sources.map(source => source.executionId!)));
+            text = "Merge dispositions recorded. Return your final answer.";
+          } else {
+            const tool = files.find(tool => tool.name === call.name);
+            if (!tool) throw new Error(`Unavailable tool '${call.name}'. Available: ${activeTools.map(tool => tool.name).join(", ")}`);
+            const invoke = () => tool.execute(args);
+            text = tool.writes && request.withWorkspaceWrite ? await request.withWorkspaceWrite(invoke) : await invoke();
+          }
+        } catch (error) {
+          request.signal.throwIfAborted();
+          // Invalid or duplicate decisions are terminal, matching core's exactly-once contract.
+          if (call.name === "decide" && request.decide) throw error;
+          isError = true;
+          text = error instanceof Error ? error.message : String(error);
+        }
+        messages.push(createToolResultMessage({ callId: call.id, content: [{ type: "text", text }], isError }));
+      }
+    }
+    const text = output.filter(part => part.trim()).join("\n\n");
+    if (!text.trim()) throw new Error("DSH model returned no textual output");
+    const usage = sumUsage(reports);
+    return { output: text, model: route, usage: {
+      inputTokens: usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0), outputTokens: usage.outputTokens,
+    } };
+  };
+}
+
+export function sumUsage(reports: readonly TokenUsage[]): TokenUsage {
+  const total: TokenUsage = { inputTokens: 0, outputTokens: 0 };
+  for (const report of reports) for (const key of ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"] as const)
+    if (report[key] !== undefined) total[key] = (total[key] ?? 0) + report[key];
+  total.totalTokens = total.inputTokens + total.outputTokens + (total.cacheReadTokens ?? 0) + (total.cacheWriteTokens ?? 0);
+  return total;
+}
diff --git a/integrations/dsh/schema.ts b/integrations/dsh/schema.ts
new file mode 100644
index 0000000..5ff9b6f
--- /dev/null
+++ b/integrations/dsh/schema.ts
@@ -0,0 +1,103 @@
+import { Type } from "@sinclair/typebox";
+const StringEnum = (values: string[], options = {}) => Type.Union(values.map(value => Type.Literal(value)), options);
+const text = (description?: string) => Type.String({ minLength: 1, pattern: "\\S", ...(description ? { description } : {}) });
+const prompt = () => Type.Union([
+  text("Instructions for this node; it does not receive the parent conversation."),
+  Type.Object({
+    template: text("Exact key in promptTemplates."),
+    variables: Type.Record(Type.String(), Type.String(), {
+      description: "Exactly the template's placeholder names with string values; use {} if there are no placeholders. No missing or extra keys.",
+    }),
+  }, { additionalProperties: false }),
+], { description: "Required for execute/decision; optional for merge/integrate. A non-blank instruction string or a reference to a declared prompt template." });
+const timeout = (scope: "node" | "graph") =>
+  Type.Optional(
+    Type.Number({
+      exclusiveMinimum: 0,
+      maximum: 2_147_483_647,
+      description: scope === "graph"
+        ? "Total wall-clock timeout in milliseconds, including queueing and pauses. Updates/resume do not reset it; reserve time for final integration. Omit for no time limit."
+        : "Timeout in milliseconds per node execution; omit for no time limit.",
+    }),
+  );
+const toolBudget = (unit: string) =>
+  Type.Optional(
+    Type.Integer({
+      minimum: 1,
+      maximum: Number.MAX_SAFE_INTEGER,
+      description: `Maximum tool ${unit} per node, including decide and rejected requests; omit for no limit`,
+    }),
+  );
+
+const commonNodeParameters = {
+  id: text("Unique node definition ID; edges refer to this exact ID. This is not an executionId."),
+  model: Type.Optional(text("Model override as provider/model-id; omit to use the parent model.")),
+  notifyOnCompletion: Type.Optional(Type.Boolean({ description: "Send an execution completion reminder; default false. Does not pause scheduling." })),
+  pauseAfter: Type.Optional(Type.Boolean({ description: "Hold this execution's outgoing dependencies until braid_resume or an atomic braid_update with resume. Sends a pause reminder." })),
+  requireSuccess: Type.Optional(Type.Boolean({ description: "If true, failure aborts the entire job and cancels running siblings. Default false: unconditional successors can recover." })),
+};
+const workspace = Type.Optional(StringEnum(["read-only", "worktree"], {
+  description: "Only for execute/decision; omit for merge/integrate. Defaults to worktree in Git. Both modes use fresh predecessor snapshots; read-only disables writes and shell tools. Outside Git, all workers are read-only.",
+}));
+// Keep all fields visible in one object. Kimi sessions using object-variant
+// unions repeatedly emitted bare merge nodes instead of intended executions.
+// Core validates the conditional requirements before starting or changing a job.
+export const nodeParameters = Type.Object({
+  id: commonNodeParameters.id,
+  type: StringEnum(["execute", "decision", "merge", "integrate"], {
+    description: "execute: analyze/implement; decision: choose a route; merge: combine predecessor checkpoints in an isolated worktree; integrate: apply predecessor changes to the invoking checkout.",
+  }),
+  prompt: Type.Optional(prompt()),
+  choices: Type.Optional(Type.Array(text(), { minItems: 1, uniqueItems: true, description: "Required only for decision; omit for every other type. Distinct routing labels used by decide and outgoing choice edges." })),
+  workspace,
+  model: commonNodeParameters.model,
+  notifyOnCompletion: commonNodeParameters.notifyOnCompletion,
+  pauseAfter: commonNodeParameters.pauseAfter,
+  requireSuccess: commonNodeParameters.requireSuccess,
+}, { additionalProperties: false, description: "execute/decision REQUIRE prompt; decision also REQUIRES choices. merge/integrate may omit prompt but MUST omit choices and workspace. Omit unused optional fields. All types accept model, notifyOnCompletion, pauseAfter, and requireSuccess." });
+const edgeFields = {
+  from: text("Source node ID."),
+  to: text("Target node ID."),
+  choice: Type.Optional(text("Only for a decision source: one exact declared choice. Omit for an unconditional dependency, including error recovery.")),
+  feedback: Type.Optional(text("Loop ID, only on the single back edge from its decision to its entry. Requires choice and a matching loops definition; not a boolean. Cannot be combined with executionId.")),
+};
+const edgeParameters = Type.Object(edgeFields, { additionalProperties: false });
+export const updateEdgeParameters = Type.Object({
+  ...edgeFields,
+  executionId: Type.Optional(text("Pin a completed historical source execution from braid_status; from must match that execution's node ID. Available only in braid_update, never in the initial graph.")),
+}, { additionalProperties: false });
+export const loopParameters = Type.Object({
+  id: text("Unique loop ID referenced by exactly one edge.feedback."),
+  entry: text("Node ID where every iteration starts; the feedback edge must target this node."),
+  maxIterations: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: "Total rounds including the first, not the number of retries. Choosing feedback on the last round fails with LOOP_LIMIT." }),
+}, { additionalProperties: false, description: "A bounded loop with one entry and a decision that selects retry or exit. The body is acyclic after removing the feedback edge; external edges enter only at entry and leave only from that decision. Loops cannot overlap or nest." });
+const templateDescription = "Named prompt strings. Placeholders use {{name}} with names matching [A-Za-z_][A-Za-z0-9_]*. Node variables must match exactly; string values are inserted literally.";
+const templates = Type.Record(Type.String(), text(), { description: templateDescription });
+export const braidParameters = Type.Object({
+  goal: text("Shared goal included in every worker's context."),
+  nodes: Type.Array(nodeParameters, { minItems: 1 }),
+  edges: Type.Array(edgeParameters, { description: "Dependencies between node IDs; use [] for independent roots. Cycles require a declared loop and explicit feedback edge. Historical executionId is not allowed at submission." }),
+  promptTemplates: Type.Optional(templates), loops: Type.Optional(Type.Array(loopParameters)),
+  options: Type.Optional(Type.Object({
+    maxConcurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Maximum simultaneous node executions; default 4." })),
+    maxExecutions: Type.Optional(Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: "Total execution limit across all iterations and updates; default 1000." })),
+    nodeTimeoutMs: timeout("node"), graphTimeoutMs: timeout("graph"), maxToolRounds: toolBudget("rounds"), maxToolCalls: toolBudget("calls"),
+  }, { additionalProperties: false })),
+}, { additionalProperties: false });
+
+const BRAID_FILESYSTEM_GUIDANCE =
+  "Every execute/decision activation gets a fresh worktree in Git, based on its predecessor execution checkpoint (roots use the initial job snapshot). Set workspace=read-only to disable writes. Multiple independent code snapshots require an explicit merge node. " +
+  "merge combines selected predecessor checkpoints into a new isolated worktree; integrate writes selected changes to the invoking checkout while preserving user edits. Workers apply changes with Git/file tools, then call finish_merge using executionId for each source; finish_merge only records dispositions and does not apply changes. There is no automatic final integration. " +
+  "Do not set workspace on merge/integrate nodes. Checkpoints remain recoverable after cleanup. Optional failed predecessors pass errors and partial work along unconditional edges; requireSuccess=true makes failure abort the job. " +
+  "Nodes have local read/ls/grep/find and Git inspection; writable nodes have write/edit and shell tools for dependencies, builds, and tests, while merge/integrate also have local Git integration tools. Search tools require local rg. Outside Git all filesystem access is read-only; read-only nodes have no shell. Worktrees are not an OS sandbox: prompts constrain shell writes and shared resources. Checkpoints omit ignored new files. Parent extension/MCP tools and recursive Braid calls are not provided. Nodes should verify their changes; the parent reviews results and performs any remaining validation after integration.";
+
+export const BRAID_USAGE_GUIDANCE = [
+  "Braid is a proactive execution primitive, not only a user-requested command.",
+  "Selection rule: for a code review, bug investigation, design comparison, test-planning request, or change spanning multiple files, call braid FIRST when two or more concerns can be handled independently. Nodes can analyze the project and implement changes in isolated Git worktrees. Do this without waiting for the user to say Braid; do not read everything in the parent and then decide whether to delegate.",
+  BRAID_FILESYSTEM_GUIDANCE,
+  "For repeated instructions, define promptTemplates once and use prompt={template: name, variables: {name: value}} on nodes. Values are strings inserted literally into {{name}} placeholders; plain-string prompts remain supported.",
+  "When Braid fits, submit a graph: use parallel execute nodes for independent analysis or implementation, execute nodes to synthesize findings, merge nodes to combine code snapshots, and integrate nodes to apply changes to the working branch. The tool returns a jobId immediately. Continue independent work or finish your turn while it runs; do not poll repeatedly. A completion reminder will resume you. Use braid_status with the jobId to retrieve terminal outputs before relying on them.",
+  "Set notifyOnCompletion=true on selected nodes to receive intermediate success/failure reminders. Use braid_status({jobId, executionId}) to retrieve the exact execution; nodeId selects the latest instance. Use pauseAfter=true to hold outgoing scheduling. Definitions can always be changed with braid_update using expectedRevision; existing executions retain their captured inputs. Use resume in the same update to apply changes and release held executions atomically, or braid_resume for no graph changes.",
+  "Make the delegation choice once per user request. Reminders and definition errors are not new tasks. Check the accepted node types and settings in the tool response. If the same definition problem recurs, stop resubmitting and report the concrete mismatch; do not launch repeated probe/replacement jobs. In braid_update, add new nodes together with their dependencies and loops: a node added without incoming edges can start immediately, even while another execution is paused.",
+  "Do not use braid for a simple one-step answer, a trivial direct edit, a single shell command, or when decomposition adds no value. Writable nodes can implement and test their work. The parent reviews results and performs any remaining validation after Braid completes.",
+].join("\n");
diff --git a/integrations/dsh/shell-tools.ts b/integrations/dsh/shell-tools.ts
new file mode 100644
index 0000000..99a898a
--- /dev/null
+++ b/integrations/dsh/shell-tools.ts
@@ -0,0 +1,75 @@
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:os";
+import { join } from "node:path";
+/** Own the entire process group through completion, cancellation, and timeout. */
+export async function runCommand(shell: string, args: string[], cwd: string, signal: AbortSignal, timeout?: number): Promise<string> {
+  let output = "";
+  const onData = (data: Buffer) => { output = (output + data.toString()).slice(-50_000); };
+  signal?.throwIfAborted();
+  if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0 || timeout * 1000 > 2_147_483_647))
+    throw new Error("Invalid timeout: expected positive seconds within the timer limit");
+
+  const child = spawn(shell, args, {
+    cwd, detached: process.platform !== "win32", windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const closed = new Promise<void>(resolve => child.once("close", () => resolve()));
+  const exited = new Promise<number | null>((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", resolve);
+  });
+  child.stdout!.on("data", onData);
+  child.stderr!.on("data", onData);
+  let termination: Promise<void> | undefined;
+  const terminate = (): Promise<void> => termination ??= (async () => {
+    if (!child.pid) return;
+    if (process.platform === "win32") {
+      await new Promise<void>((resolve, reject) => {
+        execFile(join(process.env.SystemRoot ?? "C:\\Windows", "System32", "taskkill.exe"),
+          ["/F", "/T", "/PID", String(child.pid)], { windowsHide: true }, error => {
+            // taskkill reports 128 when the process has already exited.
+            if (error && error.code !== 128) reject(error);
+            else resolve();
+          });
+      });
+    } else {
+      try { process.kill(-child.pid, "SIGKILL"); }
+      catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ESRCH") throw error;
+      }
+    }
+  })();
+  // The completion path awaits termination; event handlers must not create
+  // unhandled rejections while the shell is still exiting.
+  const stop = () => { void terminate().catch(() => {}); };
+  let timedOut = false;
+  const timer = timeout === undefined ? undefined : setTimeout(() => {
+    timedOut = true;
+    stop();
+  }, timeout * 1000);
+  signal?.addEventListener("abort", stop, { once: true });
+  if (signal?.aborted) stop();
+  let exitCode: number | null;
+  try {
+    exitCode = await exited;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", stop);
+    // Stop leftover children even on successful command completion. Commands
+    // cannot leave a server/watch process writing during checkpoint/cleanup.
+    try { await terminate(); }
+    finally {
+      // A daemon can leave the process group while holding inherited pipes.
+      // Bound pipe draining; this process-group cleanup is not an OS sandbox.
+      const drainTimer = setTimeout(() => {
+        child.stdout!.destroy();
+        child.stderr!.destroy();
+      }, 250);
+      try { await closed; }
+      finally { clearTimeout(drainTimer); }
+    }
+  }
+  if (signal?.aborted) throw new Error("aborted");
+  if (timedOut) throw new Error(`timeout:${timeout}`);
+  return JSON.stringify({ output, exitCode: exitCode ?? (child.signalCode ? 128 + (constants.signals[child.signalCode] ?? 0) : 1) });
+}
diff --git a/integrations/dsh/test/client-bundle.test.mjs b/integrations/dsh/test/client-bundle.test.mjs
new file mode 100644
index 0000000..40c543d
--- /dev/null
+++ b/integrations/dsh/test/client-bundle.test.mjs
@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { JSDOM } from "jsdom";
+import * as cordis from "@deepseek-ai/cordis";
+import * as React from "react";
+import * as jsx from "react/jsx-runtime";
+const require = createRequire(import.meta.url);
+function bundle(file) {
+  let plugin;
+  const shared = { "@deepseek-ai/cordis": cordis, react: React, "react/jsx-runtime": jsx };
+  new Function("window", readFileSync(file, "utf8"))({ __ModuleLoader__: { load({ factory }) {
+    plugin = factory(id => { assert.ok(id in shared, `Unexpected browser external: ${id}`); return shared[id]; });
+  } } });
+  assert.equal(typeof plugin.apply, "function"); return plugin;
+}
+
+test("built browser factory mounts native Remote namespace and tool/sidebar slots; unload withdraws services/styles", async () => {
+  const dom = new JSDOM("<html><head></head><body></body></html>");
+  globalThis.document = dom.window.document;
+  const ctx = new cordis.Context();
+  const entries = new Map(), tabs = new Map(), calls = [];
+  const frame = { rows: [], job: null };
+  try {
+    await ctx.plugin(bundle(require.resolve("@deepseek-ai/dsh-typert-registry/client")));
+    ctx.provide("connection", {
+      registerGenerationSource: () => () => {}, start: () => ({ stop() {} }),
+      rpc: {
+        async call(base, endpoint, payload) { calls.push({ base, endpoint, payload }); return { ok: true, value: frame }; },
+        async *open(base, endpoint, payload, signal) {
+          calls.push({ base, endpoint, payload }); yield frame;
+          if (!signal.aborted) await new Promise(resolve => signal.addEventListener("abort", resolve, { once: true }));
+        },
+      },
+    });
+    await ctx.plugin(bundle(require.resolve("@deepseek-ai/dsh-api-gateway/client")));
+    // Slot owner boundaries are represented here; the real browser renderer supplies their props.
+    ctx.provide("slots", {
+      inject: (_name, register) => register(),
+      register: (definition, Component) => { entries.set(`${definition.name}/${definition.key ?? ""}`, { definition, Component }); return () => { entries.delete(`${definition.name}/${definition.key ?? ""}`); }; },
+    });
+    let opened;
+    ctx.provide("sidebarRight", { openTab: kind => { opened = kind; }, openTabIn: (sessionId, kind, options) => { opened = { sessionId, kind, options }; } });
+    ctx.provide("sidebarRightTabs", { register: definition => { tabs.set(definition.id, definition); return () => { tabs.delete(definition.id); }; } });
+    const fiber = await ctx.plugin(bundle(new URL("../dist/client.js", import.meta.url)));
+    for (let i = 0; i < 30 && entries.size !== 7; i++) await new Promise(resolve => setTimeout(resolve, 5));
+    assert.equal(entries.size, 7); assert.equal(tabs.get("@chrok/dsh-braid").kind, "braid");
+    entries.get("conversation.session.header.actions/").definition.inject().open();
+    assert.equal(opened, "braid");
+    for (const name of ["braid", "braid_status", "braid_update", "braid_resume", "braid_cancel"]) {
+      const entry = entries.get(`tool.call.toolview/${name}`);
+      assert.ok(entry, `Missing tool renderer: ${name}`);
+      entry.definition.inject("tool-owner").openBraid({ jobId: "recorded-job", executionId: "review@1" });
+      assert.deepEqual(opened, { sessionId: "tool-owner", kind: "braid", options: { params: { jobId: "recorded-job", executionId: "review@1" } } });
+    }
+    const face = entries.get("sidebar.right.pane.tab/@chrok/dsh-braid").definition.inject("owner-session");
+    assert.equal(face.sessionId, "owner-session");
+    const request = { sessionId: face.sessionId, jobId: "job-uuid", revision: 2, action: "resume", executionIds: ["review@1"] };
+    assert.deepEqual(await face.api.control(request), frame);
+    assert.deepEqual(JSON.parse(JSON.stringify(calls.at(-1))), { base: "/api", endpoint: "braidPanel/control", payload: { args: { request } } });
+    const abort = new AbortController();
+    const iterator = face.api.watch({ sessionId: face.sessionId }, abort.signal)[Symbol.asyncIterator]();
+    assert.deepEqual((await iterator.next()).value, frame);
+    abort.abort(); await iterator.return();
+    assert.ok(document.querySelector('style[data-plugin="@chrok/dsh-braid"]'));
+    await fiber.dispose();
+    assert.equal(entries.size, 0); assert.equal(tabs.size, 0);
+    assert.equal(document.querySelector('style[data-plugin="@chrok/dsh-braid"]'), null);
+    assert.equal(ctx.get("remote.braidPanel"), undefined);
+  } finally { await ctx.fiber.dispose(); dom.window.close(); delete globalThis.document; }
+});
diff --git a/integrations/dsh/test/client/panel.test.tsx b/integrations/dsh/test/client/panel.test.tsx
new file mode 100644
index 0000000..07d4609
--- /dev/null
+++ b/integrations/dsh/test/client/panel.test.tsx
@@ -0,0 +1,111 @@
+import * as React from "react";
+import assert from "node:assert/strict";
+import test from "node:test";
+import { JSDOM } from "jsdom";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { BraidPanelView } from "../../client/Panel.js";
+import { layoutGraph } from "../../client/layout.js";
+import type { ControlRequest, PanelApi, PanelFrame } from "../../panel-types.js";
+
+const fixture: PanelFrame = {
+  rows: [{ jobId: "uuid-a", handle: "job-1", goal: "Review and implement", status: "running", createdAt: 0 }],
+  job: { jobId: "uuid-a", handle: "job-1", goal: "Review and implement", status: "running", createdAt: 0,
+    revision: 4, phase: "waiting", nodes: [{ id: "review", type: "execute", status: "completed" }, { id: "apply", type: "integrate", status: "pending" }],
+    edges: [{ from: "review", to: "apply" }], loops: [], pausedExecutionIds: ["review@1"],
+    usage: { inputTokens: 100, outputTokens: 25, cacheReadTokens: 10, cacheWriteTokens: 0 },
+    executions: [{ id: "review", executionId: "review@1", revision: 3, status: "completed", type: "execute", iteration: 1, latencyMs: 1800 }],
+    events: [{ sequence: 1, timestamp: 0, type: "execution_paused", executionId: "review@1", message: "execution paused" }],
+  },
+};
+async function setup() {
+  const dom = new JSDOM("<div id='root'></div>", { url: "http://localhost" });
+  Object.assign(globalThis, { window: dom.window, document: dom.window.document, HTMLElement: dom.window.HTMLElement, IS_REACT_ACT_ENVIRONMENT: true });
+  const root = createRoot(document.getElementById("root")!);
+  const controls: ControlRequest[] = [];
+  const signals: AbortSignal[] = [];
+  const sessions: string[] = [];
+  let fail = false;
+  const api: PanelApi = {
+    async *watch(request, signal) {
+      signals.push(signal); sessions.push(request.sessionId);
+      if (fail) throw new Error("Connection lost");
+      yield request.sessionId === "empty" ? { rows: [], job: null } : fixture;
+      await new Promise<void>(resolve => signal.addEventListener("abort", () => resolve(), { once: true }));
+    },
+    control: async request => { controls.push(request); return fixture; },
+    detail: async request => ({ executionId: request.executionId, status: "completed", output: "<script>untrusted</script>\nReview passed", offset: 0, next: 42, total: 42 }),
+  };
+  const render = async (sessionId = "owner") => { await act(async () => { root.render(<BraidPanelView sessionId={sessionId} api={api}/>); }); };
+  const click = async (label: string) => {
+    const button = [...document.querySelectorAll("button")].find(b => b.textContent === label || b.getAttribute("aria-label") === label);
+    assert.ok(button, `Missing ${label}`); await act(async () => button.click());
+  };
+  return { dom, root, api, controls, signals, sessions, render, click, disconnect: () => { fail = true; },
+    close: async () => { await act(async () => root.unmount()); dom.window.close(); } };
+}
+
+test("panel renders DAG, output as text, exact-revision resume and cancel; switching session aborts observation", async () => {
+  const h = await setup();
+  try {
+    await h.render();
+    assert.match(document.body.textContent!, /Review and implement/);
+    assert.equal(document.querySelectorAll(".br-node").length, 2);
+    assert.equal(document.querySelector(".br-output script"), null);
+    assert.match(document.querySelector(".br-output")!.textContent!, /<script>untrusted/);
+    await h.click("Resume this execution");
+    assert.deepEqual(h.controls[0], { sessionId: "owner", jobId: "uuid-a", action: "resume", executionIds: ["review@1"], revision: 4 });
+    await h.click("Event log (1)"); assert.match(document.querySelector(".br-events")!.textContent!, /execution paused/);
+    await h.click("Cancel job"); assert.equal(h.controls[1]!.action, "cancel");
+    await h.render("empty"); assert.equal(h.signals[0]!.aborted, true);
+    assert.match(document.body.textContent!, /No Braid jobs/); assert.ok(!document.body.textContent!.includes("Review and implement"));
+  } finally { await h.close(); }
+});
+
+test("connection failures are visible, controls cannot act on stale frames and unmount cancels retry", async () => {
+  const h = await setup();
+  try {
+    h.disconnect(); await h.render();
+    assert.match(document.body.textContent!, /Connection lost/);
+    assert.equal(document.querySelector(".br-node"), null);
+    assert.ok(document.querySelector('[role="alert"]'));
+    await h.click("Reconnect"); assert.equal(h.signals[0]!.aborted, true);
+  } finally { await h.close(); }
+  assert.ok(h.signals.every(signal => signal.aborted));
+});
+
+test("forward DAG ranks remain stable with loop feedback, branching and disconnected nodes", () => {
+  const nodes = ["a", "b", "c", "d", "isolated"].map(id => ({ id, type: "execute", status: "pending" }));
+  const { positions, width, height } = layoutGraph(nodes, [{ from: "a", to: "b" }, { from: "a", to: "c" }, { from: "b", to: "d" }, { from: "c", to: "d" }, { from: "d", to: "a", feedback: "review" }]);
+  assert.ok(positions.get("a")!.y < positions.get("b")!.y);
+  assert.equal(positions.get("b")!.y, positions.get("c")!.y);
+  assert.ok(positions.get("b")!.y < positions.get("d")!.y);
+  assert.equal(new Set([...positions.values()].map(p => `${p.x},${p.y}`)).size, nodes.length);
+  assert.ok(width > 300 && height > 300);
+});
+
+test("tool navigation selects an older loop execution and reopening the tab resets manual selection", async () => {
+  const h = await setup();
+  const requests: object[] = [];
+  const data = structuredClone(fixture);
+  data.job!.executions.unshift({ ...data.job!.executions[0]!, executionId: "review@0", iteration: 0 });
+  const api: PanelApi = { ...h.api, async *watch(request, signal) {
+    requests.push(request); yield data;
+    if (!signal.aborted) await new Promise<void>(resolve => signal.addEventListener("abort", () => resolve(), { once: true }));
+  } };
+  const target = { jobId: "uuid-a", executionId: "review@0", createdBefore: 2000 };
+  try {
+    await act(async () => h.root.render(<BraidPanelView key={1} sessionId="owner" api={api} target={target}/>));
+    assert.deepEqual(requests[0], { sessionId: "owner", jobId: "uuid-a", createdBefore: 2000 });
+    assert.equal(document.querySelector<HTMLSelectElement>('[aria-label="Execution history"]')!.value, "review@0");
+    assert.ok(!document.body.textContent!.includes("Resume this execution"));
+    await act(async () => document.querySelector<HTMLButtonElement>('.br-node[title^="apply"]')!.click());
+    assert.match(document.body.textContent!, /This node has not run yet/);
+    await act(async () => h.root.render(<BraidPanelView key={2} sessionId="owner" api={api} target={target}/>));
+    assert.equal(document.querySelector<HTMLSelectElement>('[aria-label="Execution history"]')!.value, "review@0");
+    assert.equal(requests.length, 2);
+    await act(async () => h.root.render(<BraidPanelView key={3} sessionId="owner" api={api} target={{ jobId: "uuid-a", executionId: "missing" }}/>));
+    assert.match(document.body.textContent!, /requested execution \(missing\) is no longer available/);
+    assert.equal(document.querySelector('[aria-label="Execution output"]'), null);
+  } finally { await h.close(); }
+});
diff --git a/integrations/dsh/test/client/tool-call.test.tsx b/integrations/dsh/test/client/tool-call.test.tsx
new file mode 100644
index 0000000..807eaca
--- /dev/null
+++ b/integrations/dsh/test/client/tool-call.test.tsx
@@ -0,0 +1,69 @@
+import * as React from "react";
+import assert from "node:assert/strict";
+import test from "node:test";
+import { JSDOM } from "jsdom";
+import { act, useState } from "react";
+import { createRoot } from "react-dom/client";
+import type { ToolCallOwnerProps, ToolCallPhaseProps } from "@deepseek-ai/dsh-client-ui-tool/client";
+import { BraidToolCall } from "../../client/ToolCall.js";
+import { toolNavigation, toolPresentation, readNavigation, type BraidNavigation } from "../../client/navigation.js";
+
+function result(args: object, value: object, isError = false): ToolCallPhaseProps {
+  return { phase: "result", block: { kind: "tool-result", callId: "call-1", seq: 1, time: 2000, callTime: 1000,
+    call: { name: "braid", argsRaw: JSON.stringify(args) }, content: [{ type: "text", text: JSON.stringify(value) }], isError, subCalls: [] } };
+}
+const start: ToolCallPhaseProps = { phase: "start", block: { phase: "start", callId: "call-1", name: "braid", turn: 1, step: 1, time: 1000, argsRaw: "{}", subCalls: [] } };
+
+test("tool links resolve canonical receipts, exact historical execution, single resume, and legacy handles", () => {
+  assert.deepEqual(toolNavigation("braid", result({}, { jobId: "job-1", canonicalJobId: "uuid-1" })), { jobId: "uuid-1", createdBefore: 2000 });
+  assert.equal(toolNavigation("braid", start), null);
+  assert.equal(toolNavigation("braid", result({}, { message: "failed" }, true)), null);
+  assert.deepEqual(toolNavigation("braid_status", result({ jobId: "job-1", nodeId: "review" }, { jobId: "uuid-1", node: { id: "review", executionId: "review@2" } })), { jobId: "uuid-1", nodeId: "review", executionId: "review@2", createdBefore: 2000 });
+  assert.deepEqual(toolNavigation("braid_status", result({ jobId: "job-1", executionId: "review@1" }, { jobId: "uuid-1", truncated: true })), { jobId: "uuid-1", executionId: "review@1", createdBefore: 2000 });
+  for (const name of ["braid_update", "braid_resume", "braid_cancel"]) {
+    assert.deepEqual(toolNavigation(name, result({ jobId: "job-1" }, { canonicalJobId: "uuid-1" })), { jobId: "uuid-1", createdBefore: 2000 });
+  }
+  assert.deepEqual(toolNavigation("braid_resume", result({ jobId: "job-1", executionIds: ["review@2"] }, { jobId: "job-1" })), { jobId: "job-1", executionId: "review@2", createdBefore: 2000 });
+  assert.deepEqual(toolNavigation("braid_cancel", result({ jobId: "job-1" }, { cancelled: true })), { jobId: "job-1", createdBefore: 2000 });
+  assert.deepEqual(toolNavigation("braid_status", result({}, { jobs: [] })), {});
+  assert.equal(toolNavigation("bash", result({}, { jobId: "uuid-1" })), null);
+  assert.deepEqual(readNavigation({ jobId: [], executionId: "e", createdBefore: -1 }), { executionId: "e" });
+});
+
+test("operation summaries distinguish snapshot progress, updates not applied, resume and cancellation outcomes", () => {
+  const update = { jobId: "job-1", expectedRevision: 4, upsertNodes: [{ id: "review" }], removeNodeIds: ["old"], addEdges: [{ from: "review", to: "apply" }], resume: ["review@1"] };
+  const card = toolPresentation("braid_update", result(update, { canonicalJobId: "uuid-1", revision: 5 }));
+  assert.match(card.summary, /r4 → r5/);
+  assert.deepEqual(card.changes, ["Upsert nodes: review", "Remove nodes: old", "Resume executions: review@1", "Add edges: 1"]);
+  assert.match(toolPresentation("braid_update", result(update, {}, true)).summary, /not applied/);
+  const status = toolPresentation("braid_status", result({ jobId: "job-1" }, { execution: { status: "waiting", revision: 5, executions: { a: { status: "completed" }, b: { status: "running" } }, pausedExecutionIds: ["a"] } }));
+  assert.match(status.summary, /waiting · r5 · 1\/2 executions complete · 1 paused/);
+  assert.equal(toolPresentation("braid_cancel", result({ jobId: "job-1" }, { cancelled: false })).summary, "Job already finished");
+  assert.equal(toolPresentation("braid_resume", result({ executionIds: ["a", "b"] }, {})).summary, "Resumed 2 execution(s)");
+  const list = toolPresentation("braid_status", result({}, { jobs: [{ jobId: "uuid-2", handle: "job-2", status: "running" }] }));
+  assert.deepEqual(list.jobs[0], { label: "job-2", status: "running", target: { jobId: "uuid-2", createdBefore: 2000 } });
+});
+
+test("clicking the tool card opens its target; raw evidence, errors and each listed job remain accessible", async () => {
+  const dom = new JSDOM("<div id='root'></div>");
+  Object.assign(globalThis, { window: dom.window, document: dom.window.document, IS_REACT_ACT_ENVIRONMENT: true });
+  const root = createRoot(document.getElementById("root")!);
+  const opened: BraidNavigation[] = [];
+  function useDisclosure() { const [expanded, setExpanded] = useState(false); return { expanded, setExpanded, toggle: () => setExpanded(v => !v) }; }
+  const common: Omit<ToolCallOwnerProps, "phase" | "block"> = { toolName: "braid_status", callId: "call-1", useDisclosure, openFile() {}, loadImage: async () => { throw new Error("unused"); } };
+  const render = async (data: ToolCallPhaseProps) => { await act(async () => root.render(<BraidToolCall {...common} {...data} openBraid={target => opened.push(target)}/>)); };
+  const click = async (query: string) => { await act(async () => document.querySelector<HTMLButtonElement>(query)!.click()); };
+  try {
+    await render(result({ jobId: "job-1", executionId: "review@1" }, { jobId: "uuid-1", status: "running", note: "<script>untrusted</script>" }));
+    await click(".br-tool-open");
+    assert.deepEqual(opened[0], { jobId: "uuid-1", executionId: "review@1", createdBefore: 2000 });
+    await click(".br-tool-actions button");
+    assert.equal(document.querySelector(".br-tool-details script"), null);
+    assert.match(document.querySelector(".br-tool-details")!.textContent!, /<script>untrusted/);
+    assert.match(document.body.textContent!, /Recorded result/);
+    await render(result({}, { jobs: [{ jobId: "uuid-2", handle: "job-2", status: "completed" }] }));
+    await click('[aria-label="View job-2"]'); assert.equal(opened.at(-1)!.jobId, "uuid-2");
+    await render(result({ jobId: "job-1" }, { error: "query failed" }, true));
+    assert.ok(document.querySelector('[role="alert"]')); assert.match(document.body.textContent!, /query failed/);
+  } finally { await act(async () => root.unmount()); dom.window.close(); }
+});
diff --git a/integrations/dsh/test/helpers.ts b/integrations/dsh/test/helpers.ts
new file mode 100644
index 0000000..9998812
--- /dev/null
+++ b/integrations/dsh/test/helpers.ts
@@ -0,0 +1,45 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { after } from "node:test";
+import type { GenerateOptions, StreamChunk, LlmRuntime, ToolCallBlock } from "@deepseek-ai/dsh-llm";
+
+const directories: string[] = [];
+after(() => { for (const directory of directories) rmSync(directory, { recursive: true, force: true }); });
+export function directory(git = false): string {
+  const cwd = mkdtempSync(join(tmpdir(), "braid-dsh-test-")); directories.push(cwd);
+  if (git) {
+    for (const args of [["init", "-b", "main"], ["config", "user.name", "Test"], ["config", "user.email", "test@example.com"]])
+      execFileSync("git", args, { cwd, stdio: "ignore" });
+    writeFileSync(join(cwd, "file.txt"), "original\n");
+    execFileSync("git", ["add", "."], { cwd }); execFileSync("git", ["commit", "-m", "initial"], { cwd, stdio: "ignore" });
+  }
+  return cwd;
+}
+export const input = { goal: "Test", nodes: [{ type: "execute" as const, id: "a", prompt: "Do work" }], edges: [] };
+export const context = (cwd = directory()) => ({ cwd, model: "fake/model/with/slashes" });
+export function answer(text = "done"): StreamChunk[] {
+  return [{ type: "text-delta", index: 0, text },
+    { type: "usage", usage: { inputTokens: 2, outputTokens: 3, cacheReadTokens: 4, cacheWriteTokens: 1 } },
+    { type: "finish", reason: { kind: "stop" } }];
+}
+export function calls(...entries: { name: string; args: object }[]): StreamChunk[] {
+  return [...entries.map(({ name, args }, index): StreamChunk => ({ type: "block-end", index,
+    block: { type: "tool-call", id: `call-${index}` as ToolCallBlock["id"], name, arguments: JSON.stringify(args) } })),
+    { type: "usage", usage: { inputTokens: 1, outputTokens: 1 } }, { type: "finish", reason: { kind: "tool-calls" } }];
+}
+export function llm(respond: (options: GenerateOptions, index: number) => StreamChunk[] | Promise<StreamChunk[]> = () => answer()): Pick<LlmRuntime, "stream"> {
+  let index = 0;
+  return { async *stream(options) { for (const chunk of await respond(options, index++)) yield chunk; } };
+}
+export function payload(options: GenerateOptions) {
+  return JSON.parse((options.messages[0]!.content[0] as { text: string }).text);
+}
+export async function until(check: () => boolean): Promise<void> {
+  const deadline = Date.now() + 5000;
+  while (!check()) {
+    if (Date.now() > deadline) throw new Error("Test condition timed out");
+    await new Promise(resolve => setTimeout(resolve, 5));
+  }
+}
diff --git a/integrations/dsh/test/host.test.ts b/integrations/dsh/test/host.test.ts
new file mode 100644
index 0000000..4deee9c
--- /dev/null
+++ b/integrations/dsh/test/host.test.ts
@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Context } from "@deepseek-ai/cordis";
+import AgentRegistry, { type Agent } from "@deepseek-ai/dsh-agent";
+import LlmRuntime, { LlmAdapter, ToolCallId, type GenerateOptions, type StreamChunk, type UserMessage } from "@deepseek-ai/dsh-llm";
+import SessionStore, { SessionId } from "@deepseek-ai/dsh-session";
+import SystemPrompt from "@deepseek-ai/dsh-system-prompt";
+import ToolRuntime from "@deepseek-ai/dsh-tools";
+import CommandRuntime from "@deepseek-ai/dsh-commands";
+import Registry from "@deepseek-ai/dsh-typert-registry";
+import Gateway from "@deepseek-ai/dsh-api-gateway";
+import LocalJobRegistry from "@deepseek-ai/dsh-jobs-local";
+import { JobId } from "@deepseek-ai/dsh-jobs";
+import * as plugin from "../index.js";
+import { answer, directory, input, until } from "./helpers.js";
+
+async function harness(respond: (options: GenerateOptions) => Promise<StreamChunk[]> = async () => answer()) {
+  const ctx = new Context();
+  await ctx.plugin(Registry);
+  await ctx.plugin(Gateway);
+  await ctx.plugin(SessionStore);
+  await ctx.plugin(SystemPrompt);
+  await ctx.plugin(ToolRuntime, { mode: "native" });
+  await ctx.plugin(CommandRuntime);
+  await ctx.plugin(AgentRegistry);
+  await ctx.plugin(LocalJobRegistry);
+  await ctx.plugin(LlmRuntime);
+  class Adapter extends LlmAdapter {
+    async *stream(options: GenerateOptions) { yield* await respond(options); }
+  }
+  ctx.llm.registerAdapter(["fake"], new Adapter());
+  const fiber = await ctx.plugin(plugin);
+  async function agent(name: string) {
+    const owner = ctx.plugin(() => {});
+    const session = ctx.sessions.create(SessionId(name), { meta: { cwd: directory() } });
+    const messages: UserMessage[] = [];
+    const agent = { id: session.id, session, ctx: owner.ctx, options: { provider: "fake", model: "model" },
+      status: "idle", steer: (message: UserMessage) => { messages.push(message); },
+      whenIdle: async () => {}, cancel: () => {},
+    } as unknown as Agent;
+    await ctx.agents.register(agent);
+    return { agent, messages, owner };
+  }
+  let count = 0;
+  const invoke = (agent: Agent | undefined, name: string, args: object, signal = new AbortController().signal) => ctx.tools.execute({
+    callId: ToolCallId(`test-${++count}`), name, arguments: args, ...(agent ? { agent } : {}), signal,
+  });
+  return { ctx, fiber, agent, invoke };
+}
+
+test("loads in actual Cordis/DSH services, produces valid canonical results, native jobs and scoped controls", async () => {
+  const { ctx, fiber, agent, invoke } = await harness();
+  try {
+    const a = await agent("owner-a"), b = await agent("owner-b");
+    assert.deepEqual(ctx.tools.schemas().map(tool => tool.name).sort(), ["braid", "braid_cancel", "braid_resume", "braid_status", "braid_update"]);
+    const assembly = await ctx.systemPrompt.assemble();
+    assert.match(JSON.stringify(assembly), /Braid is a proactive/);
+    const submitted = await invoke(a.agent, "braid", input);
+    assert.equal(submitted.isError, false, JSON.stringify(submitted));
+    assert.ok("value" in submitted);
+    const receipt = submitted.value as { jobId: string; canonicalJobId: string; nativeJobId: string };
+    assert.equal(receipt.jobId, "job-1");
+    await until(() => Boolean(ctx.get("braidPanel")));
+    const observation = await ctx.typertGateway.stream({ namespace: "braidPanel", method: "watch", args: { request: { sessionId: a.agent.id } }, signal: new AbortController().signal });
+    const iterator = observation[Symbol.asyncIterator]();
+    assert.match(JSON.stringify((await iterator.next()).value), new RegExp(receipt.canonicalJobId));
+    await iterator.return?.();
+    await until(() => ctx.jobs.get(JobId(receipt.nativeJobId), a.agent.id).status === "completed");
+    const result = await invoke(a.agent, "braid_status", { jobId: receipt.jobId });
+    assert.equal(result.isError, false); assert.match(JSON.stringify(result), /completed/);
+    assert.ok(ctx.jobs.readAt(JobId(receipt.nativeJobId), 0, a.agent.id).chunks.some(chunk => chunk.text.includes("Braid job-1")));
+    assert.equal((await invoke(b.agent, "braid_status", { jobId: receipt.canonicalJobId })).isError, true);
+    assert.equal((await invoke(undefined, "braid_status", {})).isError, true);
+    assert.equal(a.messages.length, 1); assert.equal(b.messages.length, 0);
+    assert.equal(a.messages[0]!.source.kind, "braid");
+    assert.ok(ctx.commands.find(a.agent, "braid"));
+    await fiber.dispose();
+    assert.equal(ctx.tools.schemas().length, 0); assert.equal(ctx.commands.find(a.agent, "braid"), undefined);
+  } finally { await ctx.fiber.dispose(); }
+});
+
+test("foreground abort leaves submitted jobs alive; native kill cancels and settles them", async () => {
+  let entered = false;
+  const { ctx, agent, invoke } = await harness(async options => {
+    entered = true;
+    await new Promise<void>(resolve => options.signal!.addEventListener("abort", () => resolve(), { once: true }));
+    options.signal!.throwIfAborted(); return answer();
+  });
+  try {
+    const a = await agent("cancel-owner");
+    const controller = new AbortController();
+    const submission = await invoke(a.agent, "braid", input, controller.signal);
+    assert.ok("value" in submission, JSON.stringify(submission));
+    const receipt = submission.value as { jobId: string; nativeJobId: string };
+    controller.abort(); await until(() => entered);
+    assert.equal(ctx.jobs.get(JobId(receipt.nativeJobId), a.agent.id).status, "running");
+    ctx.jobs.kill(JobId(receipt.nativeJobId), a.agent.id);
+    await until(() => ctx.jobs.get(JobId(receipt.nativeJobId), a.agent.id).status === "killed");
+    const status = await invoke(a.agent, "braid_status", { jobId: receipt.jobId });
+    assert.match(JSON.stringify(status), /cancelled/);
+  } finally { await ctx.fiber.dispose(); }
+});
+
+test("dropped reminders retry at idle once and claimed reminders are acknowledged", async () => {
+  const { ctx, agent, invoke } = await harness();
+  try {
+    const a = await agent("reminder-owner");
+    await invoke(a.agent, "braid", input);
+    await until(() => a.messages.length === 1);
+    const message = a.messages[0]!;
+    ctx.emit("agent/status", { agent: a.agent, status: "idle" });
+    assert.equal(a.messages.length, 1, "queued reminders must not duplicate");
+    ctx.emit("agent/inbox/discarded", { agent: a.agent, message });
+    ctx.emit("agent/status", { agent: a.agent, status: "idle" });
+    assert.equal(a.messages.length, 2);
+    ctx.emit("agent/inbox/claimed", { agent: a.agent, message, turn: 1 });
+    ctx.emit("agent/status", { agent: a.agent, status: "idle" });
+    assert.equal(a.messages.length, 2);
+  } finally { await ctx.fiber.dispose(); }
+});
+
+test("unloading the plugin aborts work and suppresses reminders after cleanup", async () => {
+  let entered = false, cleaned = false;
+  const { ctx, fiber, agent, invoke } = await harness(async options => {
+    entered = true;
+    await new Promise<void>(resolve => options.signal!.addEventListener("abort", () => resolve(), { once: true }));
+    cleaned = true; options.signal!.throwIfAborted(); return answer();
+  });
+  try {
+    const a = await agent("dispose-owner");
+    await invoke(a.agent, "braid", input);
+    await until(() => entered);
+    await fiber.dispose();
+    assert.equal(cleaned, true); assert.equal(a.messages.length, 0);
+  } finally { await ctx.fiber.dispose(); }
+});
+
+test("disposing an owning agent drains its work without notifying that agent", async () => {
+  let entered = false, cleaned = false;
+  const { ctx, agent, invoke } = await harness(async options => {
+    entered = true;
+    await new Promise<void>(resolve => options.signal!.addEventListener("abort", () => resolve(), { once: true }));
+    cleaned = true; options.signal!.throwIfAborted(); return answer();
+  });
+  try {
+    const a = await agent("owner-disposal");
+    await invoke(a.agent, "braid", input);
+    await until(() => entered);
+    await a.owner.dispose();
+    assert.equal(cleaned, true); assert.equal(a.messages.length, 0);
+  } finally { await ctx.fiber.dispose(); }
+});
diff --git a/integrations/dsh/test/jobs.test.ts b/integrations/dsh/test/jobs.test.ts
new file mode 100644
index 0000000..01237b9
--- /dev/null
+++ b/integrations/dsh/test/jobs.test.ts
@@ -0,0 +1,121 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFile, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+import { BraidJobs, type Completion } from "../jobs.js";
+import { boundedResult, createBraidTools } from "../tools.js";
+import { answer, calls, context, input, llm, payload, until } from "./helpers.js";
+
+test("immediate submission, exact handles, snapshots, and terminal reminders", async () => {
+  const notifications: Completion[] = [];
+  let release!: () => void;
+  const held = new Promise<void>(resolve => { release = resolve; });
+  const jobs = new BraidJobs(llm(async () => { await held; return answer(); }), value => notifications.push(value));
+  const job = jobs.start(input, {}, context());
+  assert.equal(job.status, "running"); assert.equal(job.handle, "job-1"); assert.equal(notifications.length, 0);
+  assert.equal(jobs.get(job.jobId).handle, job.handle);
+  assert.throws(() => jobs.get("job"), /exact session handle/);
+  (job.execution.graph.nodes as unknown[]).length = 0;
+  assert.equal(jobs.get(job.handle).execution.graph.nodes.length, 1);
+  release(); await jobs.wait(job.handle);
+  assert.equal(jobs.get(job.handle).status, "completed"); assert.equal(notifications.length, 1);
+  assert.equal(jobs.get(job.handle).usage.totalTokens, 10);
+  await jobs.dispose(); assert.throws(() => jobs.start(input, {}, context()), /closed/);
+});
+
+test("pause reminders, atomic update/resume, stale revisions and focused historical reads", async () => {
+  const notifications: Completion[] = [];
+  const jobs = new BraidJobs(llm(), value => notifications.push(value));
+  const job = jobs.start({ ...input, nodes: [{ ...input.nodes[0]!, pauseAfter: true, notifyOnCompletion: true }] }, {}, context());
+  await until(() => jobs.get(job.handle).execution.pausedExecutionIds.length === 1);
+  const before = jobs.get(job.handle).execution;
+  const executionId = before.pausedExecutionIds[0]!;
+  assert.equal(notifications.length, 1); assert.equal(notifications[0]!.paused, true);
+  assert.throws(() => jobs.update(job.handle, { expectedRevision: 100, upsertNodes: [{ type: "execute", id: "b", prompt: "new" }] }), /revision/i);
+  assert.deepEqual(jobs.get(job.handle).execution, before);
+  jobs.update(job.handle, { expectedRevision: before.revision, upsertNodes: [{ type: "execute", id: "b", prompt: "new" }], addEdges: [{ from: "a", to: "b", executionId }], resume: [executionId] });
+  await jobs.wait(job.handle);
+  assert.equal(jobs.get(job.handle).status, "completed");
+  assert.equal(jobs.getNode(job.handle, "a", executionId).output, "done");
+  assert.throws(() => jobs.getNode(job.handle, "b", executionId), /Unknown/);
+  assert.throws(() => jobs.resume(job.handle, [executionId], 1), /no longer accepting/i);
+  await jobs.dispose();
+});
+
+test("failed provider rounds remain in usage and optional failures can recover", async () => {
+  const jobs = new BraidJobs(llm(options => payload(options).nodeId === "bad" ? [
+    { type: "usage", usage: { inputTokens: 5, outputTokens: 6 } },
+    { type: "finish", reason: { kind: "error", failure: { code: "TEST", message: "provider failed" } } },
+  ] : answer()));
+  const job = jobs.start({ goal: "recover", nodes: [{ type: "execute", id: "bad", prompt: "bad" }, { type: "execute", id: "recover", prompt: "recover" }], edges: [{ from: "bad", to: "recover" }] }, {}, context());
+  await jobs.wait(job.handle);
+  assert.equal(jobs.getNode(job.handle, "recover").status, "completed");
+  assert.equal(jobs.get(job.handle).usage.totalTokens, 21);
+  assert.deepEqual(jobs.get(job.handle).usage, jobs.get(job.handle).usage);
+  await jobs.dispose();
+});
+
+test("cancellation and disposal abort providers, wait for cleanup, and suppress disposed reminders", async () => {
+  for (const dispose of [false, true]) {
+    let entered = false, cleaned = false;
+    const notifications: Completion[] = [];
+    const jobs = new BraidJobs(llm(async options => {
+      entered = true;
+      await new Promise<void>(resolve => options.signal!.addEventListener("abort", () => resolve(), { once: true }));
+      cleaned = true; options.signal!.throwIfAborted(); return answer();
+    }), value => notifications.push(value));
+    const job = jobs.start(input, {}, context());
+    await until(() => entered);
+    if (dispose) await jobs.dispose(); else { jobs.cancel(job.handle); await jobs.wait(job.handle); }
+    assert.ok(cleaned); assert.equal(jobs.get(job.handle).status, "cancelled");
+    assert.equal(notifications.length, dispose ? 0 : 1);
+    await jobs.dispose();
+  }
+});
+
+test("graph timeout keeps running through pauses", async () => {
+  const jobs = new BraidJobs(llm());
+  const job = jobs.start({ ...input, nodes: [{ ...input.nodes[0]!, pauseAfter: true }] }, { graphTimeoutMs: 60 }, context());
+  await jobs.wait(job.handle);
+  assert.equal(jobs.get(job.handle).status, "failed");
+  assert.equal(jobs.get(job.handle).execution.pausedExecutionIds.length, 0);
+  await jobs.dispose();
+});
+
+test("large running and focused results preserve current controls and save full JSON", async () => {
+  const original = { jobId: "uuid", handle: "job-1", status: "running", execution: { status: "waiting", revision: 4, pausedExecutionIds: ["execution"] }, node: { output: "x".repeat(100_000) } };
+  const result = await boundedResult(original) as typeof original & { fullOutputPath: string; truncated: boolean };
+  try {
+    assert.equal(result.truncated, true); assert.deepEqual(result.execution, original.execution);
+    assert.deepEqual(JSON.parse(await readFile(result.fullOutputPath, "utf8")), original);
+  } finally { await rm(dirname(result.fullOutputPath), { recursive: true }); }
+});
+
+test("schemas reject malformed graph fields and invalid options before publishing jobs", async () => {
+  const jobs = new BraidJobs(llm());
+  const tools = createBraidTools(() => jobs, () => { throw new Error("should not submit"); });
+  const exec = { signal: new AbortController().signal } as import("@deepseek-ai/dsh-tools").ToolRunContext;
+  for (const invalid of [
+    { ...input, nodes: [{ type: "bogus", id: "a", prompt: "bad" }] },
+    { ...input, options: { maxToolCalls: 0 } },
+    { ...input, options: { maxConcurrency: 1.2 } },
+    { ...input, edges: [{ from: "a", to: "b", executionId: "no" }] },
+  ]) await assert.rejects(tools[0]!.execute(invalid, exec), /Invalid braid arguments/);
+  assert.equal(jobs.list().length, 0);
+  assert.throws(() => jobs.start(input, { maxToolCalls: 0 }, context()), /positive/);
+  await assert.rejects(tools[1]!.execute({ executionId: "no" }, exec), /requires jobId/);
+  await jobs.dispose();
+});
+
+test("merge and integrate require explicit dispositions even outside Git", async () => {
+  const seen = new Set<string>();
+  const jobs = new BraidJobs(llm(options => {
+    const id = payload(options).nodeId;
+    if (id === "a" || seen.has(id)) return answer();
+    seen.add(id);
+    return calls({ name: "finish_merge", args: { dispositions: [] } });
+  }));
+  const job = jobs.start({ ...input, nodes: [...input.nodes, { type: "merge", id: "merge" }, { type: "integrate", id: "apply" }], edges: [{ from: "a", to: "merge" }, { from: "merge", to: "apply" }] }, {}, context());
+  await jobs.wait(job.handle); assert.equal(jobs.get(job.handle).status, "completed");
+  await jobs.dispose();
+});
diff --git a/integrations/dsh/test/panel.test.ts b/integrations/dsh/test/panel.test.ts
new file mode 100644
index 0000000..08a95ac
--- /dev/null
+++ b/integrations/dsh/test/panel.test.ts
@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Context } from "@deepseek-ai/cordis";
+import Registry from "@deepseek-ai/dsh-typert-registry";
+import Gateway from "@deepseek-ai/dsh-api-gateway";
+import { BraidJobs } from "../jobs.js";
+import { BraidPanel } from "../panel.js";
+import type { PanelDetail, PanelFrame } from "../panel-types.js";
+import { answer, context, input, llm, until } from "./helpers.js";
+
+async function setup() {
+  const ctx = new Context();
+  await ctx.plugin(Registry); await ctx.plugin(Gateway);
+  const jobs = new BraidJobs(llm(() => answer("x".repeat(70000))));
+  const listeners = new Set<() => void>();
+  const off = jobs.subscribe(() => { for (const listener of listeners) listener(); });
+  await ctx.inject(["typert"], ctx => { new BraidPanel(ctx, id => id === "owner" ? jobs : undefined,
+    listener => { listeners.add(listener); return () => { listeners.delete(listener); }; }); });
+  const invoke = (method: string, request: object) => ctx.typertGateway.invoke({ namespace: "braidPanel", method, args: { request } });
+  return { ctx, jobs, listeners, invoke, cleanup: async () => { off(); await jobs.dispose(); await ctx.fiber.dispose(); } };
+}
+
+test("native Gateway streams bounded projections, fences controls and pages exact execution output", async () => {
+  const h = await setup();
+  const abort = new AbortController();
+  try {
+    const stream = await h.ctx.typertGateway.stream({ namespace: "braidPanel", method: "watch", args: { request: { sessionId: "owner" } }, signal: abort.signal });
+    const iterator = stream[Symbol.asyncIterator]();
+    assert.deepEqual((await iterator.next()).value, { rows: [], job: null });
+    const receipt = h.jobs.start(input, {}, context());
+    await h.jobs.wait(receipt.jobId);
+    const frame = (await iterator.next()).value as PanelFrame;
+    assert.equal(frame.job!.status, "completed");
+    assert.ok(JSON.stringify(frame).length < 6000, "long outputs must not enter live graph frames");
+    assert.ok(!JSON.stringify(frame).includes("Do work"), "prompts must not enter graph frames");
+    const executionId = frame.job!.executions[0]!.executionId;
+    const detail = await h.invoke("detail", { sessionId: "owner", jobId: receipt.jobId, executionId, offset: 0 }) as PanelDetail;
+    assert.equal(detail.output.length, 32768); assert.equal(detail.total, 70000);
+    const tail = await h.invoke("detail", { sessionId: "owner", jobId: receipt.jobId, executionId, offset: 65536 }) as PanelDetail;
+    assert.equal(tail.output.length, 4464); assert.equal(tail.next, 70000);
+    await assert.rejects(h.invoke("detail", { sessionId: "other", jobId: receipt.jobId, executionId, offset: 0 }), /no longer available/);
+    await assert.rejects(h.invoke("control", { sessionId: "other", jobId: receipt.jobId, action: "cancel", revision: 0, executionIds: [] }), /no longer available/);
+    await assert.rejects(h.invoke("detail", { sessionId: "owner", jobId: receipt.jobId, executionId, offset: -1 }), /boundary validation/);
+    abort.abort(); await iterator.return?.();
+    assert.equal(h.listeners.size, 0);
+  } finally { abort.abort(); await h.cleanup(); }
+});
+
+test("native panel resumes with revision checks and cancellation settles the original run", async () => {
+  const h = await setup();
+  try {
+    const receipt = h.jobs.start({ ...input, nodes: [{ ...input.nodes[0]!, pauseAfter: true }, { type: "execute", id: "b", prompt: "next" }], edges: [{ from: "a", to: "b" }] }, {}, context());
+    await until(() => h.jobs.get(receipt.jobId).execution.pausedExecutionIds.length > 0);
+    const snapshot = h.jobs.get(receipt.jobId).execution;
+    const request = { sessionId: "owner", jobId: receipt.jobId, action: "resume", revision: snapshot.revision, executionIds: snapshot.pausedExecutionIds };
+    await assert.rejects(h.invoke("control", { ...request, revision: snapshot.revision + 1 }), /revision/i);
+    await h.invoke("control", request);
+    await h.jobs.wait(receipt.jobId);
+    assert.equal(h.jobs.get(receipt.jobId).status, "completed");
+    const next = h.jobs.start({ ...input, nodes: [{ ...input.nodes[0]!, pauseAfter: true }, { type: "execute", id: "b", prompt: "next" }], edges: [{ from: "a", to: "b" }] }, {}, context());
+    await until(() => h.jobs.get(next.jobId).execution.pausedExecutionIds.length > 0);
+    await h.invoke("control", { sessionId: "owner", jobId: next.jobId, action: "cancel", revision: 0, executionIds: [] });
+    await h.jobs.wait(next.jobId);
+    assert.equal(h.jobs.get(next.jobId).status, "cancelled");
+  } finally { await h.cleanup(); }
+});
+
+test("legacy tool-card handles resolve in the owning session and reject handles reused after the call", async () => {
+  const h = await setup();
+  try {
+    const receipt = h.jobs.start(input, {}, context()); await h.jobs.wait(receipt.jobId);
+    const executionId = Object.keys(h.jobs.get(receipt.jobId).execution.executions)[0]!;
+    const request = { sessionId: "owner", jobId: receipt.handle, executionId, offset: 0, createdBefore: receipt.createdAt };
+    assert.equal((await h.invoke("detail", request) as PanelDetail).executionId, executionId);
+    await assert.rejects(h.invoke("detail", { ...request, createdBefore: receipt.createdAt - 1 }), /no longer available/);
+    await assert.rejects(h.invoke("detail", { ...request, sessionId: "other" }), /no longer available/);
+  } finally { await h.cleanup(); }
+});
diff --git a/integrations/dsh/test/runner.test.ts b/integrations/dsh/test/runner.test.ts
new file mode 100644
index 0000000..ce53a6a
--- /dev/null
+++ b/integrations/dsh/test/runner.test.ts
@@ -0,0 +1,180 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { braid, type BraidInput } from "@chrok/braid";
+import type { GenerateOptions } from "@deepseek-ai/dsh-llm";
+import { createDshRunner } from "../runner.js";
+import { runCommand } from "../shell-tools.js";
+import { directory, input, llm, answer, calls, payload } from "./helpers.js";
+
+test("uses exact routes, fresh contexts, native tools, cache usage and direct predecessor output", async () => {
+  const cwd = directory();
+  const seen: GenerateOptions[] = [];
+  const result = await braid({ goal: "goal", nodes: [
+    { type: "execute", id: "a", prompt: "first" },
+    { type: "execute", id: "b", prompt: "second", model: "other/id/with/slash" },
+  ], edges: [{ from: "a", to: "b" }] }, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+    seen.push(options);
+    assert.equal(options.messages.length, 1);
+    assert.ok(!options.tools?.some(tool => ["braid", "write", "edit", "bash"].includes(tool.name)));
+    return answer(payload(options).nodeId);
+  }), { cwd }) });
+  assert.equal(result.status, "completed");
+  assert.equal(seen[1]!.provider, "other"); assert.equal(seen[1]!.model, "id/with/slash");
+  assert.equal(payload(seen[1]!).predecessors[0].output, "a");
+  assert.equal(result.metadata.usage?.inputTokens, 14);
+  assert.notEqual(seen[0]!.messages, seen[1]!.messages);
+});
+
+test("decision routes through decide, preserves tool messages and provider replay metadata", async () => {
+  const cwd = directory(); let routeCalls = 0;
+  const result = await braid({ goal: "route", nodes: [
+    { type: "decision", id: "route", prompt: "choose", choices: ["yes", "no"] },
+    { type: "execute", id: "yes", prompt: "yes" }, { type: "execute", id: "no", prompt: "no" },
+  ], edges: [{ from: "route", to: "yes", choice: "yes" }, { from: "route", to: "no", choice: "no" }] }, {
+    cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+      if (payload(options).nodeId !== "route") return answer();
+      if (!routeCalls++) return [...calls({ name: "decide", args: { choice: "yes" } }).slice(0, -1),
+        { type: "finish", reason: { kind: "tool-calls" }, replayState: { response: { requestId: "replay" } } }];
+      assert.equal(options.messages.at(-1)!.role, "tool");
+      const previous = options.messages[1]!;
+      assert.equal(previous.role, "assistant");
+      if (previous.role === "assistant") assert.deepEqual(previous.source.replayState, { response: { requestId: "replay" } });
+      assert.ok(!options.tools!.some(tool => tool.name === "decide"));
+      return answer("yes selected");
+    }), { cwd }),
+  });
+  assert.equal(result.nodes.yes!.status, "completed"); assert.equal(result.nodes.no!.status, "skipped");
+});
+
+test("bounded loops use fresh invocations and prompt templates", async () => {
+  const cwd = directory();
+  const rounds = new Map<string, number>();
+  const graph: BraidInput = { goal: "loop", promptTemplates: { task: "Work on {{target}}" }, nodes: [
+    { type: "execute", id: "work", prompt: { template: "task", variables: { target: "loop" } } },
+    { type: "decision", id: "check", prompt: "check", choices: ["retry", "done"] },
+  ], edges: [{ from: "work", to: "check" }, { from: "check", to: "work", choice: "retry", feedback: "retry" }], loops: [{ id: "retry", entry: "work", maxIterations: 2 }] };
+  const result = await braid(graph, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+    const p = payload(options);
+    if (p.nodeId === "work") { assert.equal(p.prompt, "Work on loop"); return answer(); }
+    const id = p.execution.executionId;
+    if (!rounds.has(id)) { rounds.set(id, 1); return calls({ name: "decide", args: { choice: p.execution.iteration === 1 ? "retry" : "done" } }); }
+    return answer();
+  }), { cwd }) });
+  assert.equal(result.status, "completed"); assert.equal(Object.keys(result.executions).length, 4);
+});
+
+test("tool limits fail before an over-budget batch can write", async () => {
+  const cwd = directory(true);
+  const result = await braid(input, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(() => calls(
+    { name: "write", args: { path: "no.txt", content: "no" } }, { name: "write", args: { path: "also-no.txt", content: "no" } },
+  )), { cwd, maxToolCalls: 1 }) });
+  assert.equal(result.nodes.a!.status, "failed"); assert.match(result.nodes.a!.error!.message, /budget/);
+  assert.equal(existsSync(join(cwd, "no.txt")), false);
+});
+
+test("writable workers edit isolated snapshots and checkpoints exclude ignored outputs", async () => {
+  const cwd = directory(true); writeFileSync(join(cwd, ".gitignore"), "ignored.txt\n");
+  let round = 0;
+  const result = await braid(input, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+    assert.notEqual(payload(options).workspace.workingDirectory, cwd);
+    if (!round++) return calls({ name: "edit", args: { path: "file.txt", oldText: "original", newText: "changed" } },
+      { name: "write", args: { path: "ignored.txt", content: "cache" } },
+      { name: "write", args: { path: "../escape.txt", content: "bad" } },
+      { name: "write", args: { path: ".git", content: "bad" } });
+    const results = options.messages.filter(message => message.role === "tool");
+    assert.equal(results[0]!.isError, false); assert.equal(results[2]!.isError, true); assert.equal(results[3]!.isError, true);
+    return answer();
+  }), { cwd }) });
+  assert.equal(result.nodes.a!.status, "completed");
+  assert.equal(readFileSync(join(cwd, "file.txt"), "utf8"), "original\n");
+  const checkpoint = result.nodes.a!.workspace!.checkpointRef!;
+  assert.equal(execFileSync("git", ["show", `${checkpoint}:file.txt`], { cwd, encoding: "utf8" }), "changed\n");
+  assert.throws(() => execFileSync("git", ["show", `${checkpoint}:ignored.txt`], { cwd, stdio: "ignore" }));
+});
+
+test("integration applies selected snapshots, preserves caller edits, and retains recovery refs", async () => {
+  const cwd = directory(true);
+  writeFileSync(join(cwd, "file.txt"), "caller changes\n");
+  const rounds = new Map<string, number>();
+  const result = await braid({ goal: "apply", nodes: [
+    { type: "execute", id: "implement", prompt: "write" },
+    { type: "execute", id: "review", prompt: "review", workspace: "read-only" },
+    { type: "integrate", id: "apply", requireSuccess: true },
+  ], edges: [{ from: "implement", to: "review" }, { from: "review", to: "apply" }] }, {
+    cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+      const p = payload(options), round = rounds.get(p.nodeId) ?? 0;
+      rounds.set(p.nodeId, round + 1);
+      if (p.nodeId === "implement") return round ? answer() : calls({ name: "write", args: { path: "selected.txt", content: "selected" } });
+      if (p.nodeId === "review") {
+        assert.equal(readFileSync(join(p.workspace.workingDirectory, "selected.txt"), "utf8"), "selected");
+        assert.ok(!options.tools!.some(tool => tool.name === "write")); return answer("reviewed");
+      }
+      const source = p.mergeSources[0];
+      if (round === 0) {
+        assert.equal(p.sourceCheckoutStatus.dirty, true);
+        return calls({ name: "git", args: { command: "diff", args: ["--binary", source.changes.baseCommit, source.checkpointRef] } });
+      }
+      const latest = options.messages.at(-1)!;
+      assert.equal(latest.role, "tool");
+      if (latest.role === "tool") assert.equal(latest.isError, false, JSON.stringify(latest));
+      if (round === 1) return calls({ name: "git", args: { command: "apply", args: ["-"], input: JSON.parse((latest.content[0] as { text: string }).text).stdout } });
+      if (round === 2) return calls({ name: "finish_merge", args: { dispositions: [{ executionId: source.executionId, disposition: "integrated", reason: "Applied selected diff" }] } });
+      return answer("applied");
+    }), { cwd }),
+  });
+  assert.equal(result.status, "completed", JSON.stringify(result));
+  assert.equal(readFileSync(join(cwd, "selected.txt"), "utf8"), "selected");
+  assert.equal(readFileSync(join(cwd, "file.txt"), "utf8"), "caller changes\n");
+  assert.ok(result.nodes.apply!.workspace!.backupRef);
+});
+
+test("read-only tools execute locally and malformed/unknown calls return errors to the model", async () => {
+  const cwd = directory(); writeFileSync(join(cwd, "sample.txt"), "hello");
+  let round = 0;
+  const result = await braid(input, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+    if (!round++) return calls({ name: "read", args: { path: "sample.txt" } }, { name: "read", args: {} }, { name: "bash", args: { command: "false" } });
+    const results = options.messages.filter(message => message.role === "tool");
+    assert.match(JSON.stringify(results[0]), /hello/); assert.equal(results[1]!.isError, true); assert.equal(results[2]!.isError, true);
+    return answer();
+  }), { cwd }) });
+  assert.equal(result.status, "completed");
+});
+
+test("bounded file reads preserve UTF-8 characters across windows", async () => {
+  const cwd = directory(), original = "你好".repeat(10_000);
+  writeFileSync(join(cwd, "unicode.txt"), original);
+  let text = "", round = 0;
+  const result = await braid(input, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(options => {
+    if (!round++) return calls({ name: "read", args: { path: "unicode.txt" } });
+    const latest = options.messages.at(-1)!;
+    const read = JSON.parse((latest.content[0] as { text: string }).text);
+    text += read.text;
+    return read.eof ? answer() : calls({ name: "read", args: { path: "unicode.txt", offset: read.nextOffset } });
+  }), { cwd }) });
+  assert.equal(result.status, "completed"); assert.equal(text, original);
+});
+
+test("rejects incomplete streams, empty output, max tokens and duplicate decisions", async () => {
+  const cwd = directory();
+  for (const chunks of [answer().slice(0, -1), answer(""), [{ type: "finish" as const, reason: { kind: "max-tokens" as const } }]]) {
+    const result = await braid(input, { cwd, defaultModel: "fake/model", runner: createDshRunner(llm(() => chunks), { cwd }) });
+    assert.equal(result.nodes.a!.status, "failed");
+  }
+  const result = await braid({ goal: "duplicate", nodes: [{ type: "decision", id: "a", prompt: "choose", choices: ["yes"] }], edges: [] }, {
+    cwd, defaultModel: "fake/model", runner: createDshRunner(llm(() => calls({ name: "decide", args: { choice: "yes" } }, { name: "decide", args: { choice: "yes" } })), { cwd }),
+  });
+  assert.equal(result.nodes.a!.status, "failed");
+});
+
+test("shell commands obey timeout and cancellation and use the assigned cwd", async () => {
+  const cwd = directory();
+  const result = JSON.parse(await runCommand(process.execPath, ["-e", "console.log(process.cwd())"], cwd, new AbortController().signal));
+  assert.equal(result.exitCode, 0); assert.match(result.output, /braid-dsh-test-/);
+  await assert.rejects(runCommand(process.execPath, ["-e", "setInterval(()=>{}, 1000)"], cwd, new AbortController().signal, 0.03), /timeout/);
+  const controller = new AbortController();
+  const pending = runCommand(process.execPath, ["-e", "setInterval(()=>{}, 1000)"], cwd, controller.signal);
+  controller.abort(); await assert.rejects(pending, /aborted/);
+});
diff --git a/integrations/dsh/test/write-tools.test.ts b/integrations/dsh/test/write-tools.test.ts
new file mode 100644
index 0000000..3e1deaf
--- /dev/null
+++ b/integrations/dsh/test/write-tools.test.ts
@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { link, readFile, symlink, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { createWriteOperations } from "../write-tools.js";
+import { directory } from "./helpers.js";
+
+test("write operations reject links, submodules, Git metadata and traversal", async t => {
+  const cwd = directory(true);
+  const operations = await createWriteOperations(cwd, cwd, new AbortController().signal, async () => ["submodule"]);
+  await assert.rejects(operations.write("../outside.txt", "bad"), /only inside/);
+  await assert.rejects(operations.write(".git/config", "bad"), /Git metadata/);
+  await assert.rejects(operations.write("submodule/file.txt", "bad"), /submodules/);
+  await link(join(cwd, "file.txt"), join(cwd, "hard.txt"));
+  await assert.rejects(operations.write("hard.txt", "bad"), /hard links/);
+  await assert.rejects(operations.read("hard.txt"), /hard links/);
+  assert.equal(await readFile(join(cwd, "file.txt"), "utf8"), "original\n");
+  // Windows symlink creation needs developer mode or elevated permissions.
+  try { await symlink(join(cwd, "file.txt"), join(cwd, "link.txt")); }
+  catch (error) {
+    if (process.platform === "win32" && (error as NodeJS.ErrnoException).code === "EPERM") { t.diagnostic("Symlink check unavailable without Windows developer mode"); return; }
+    throw error;
+  }
+  await assert.rejects(operations.write("link.txt", "bad"), /symlinks/);
+  await mkdir(join(cwd, "target"));
+  await symlink(join(cwd, "target"), join(cwd, "linked-directory"), "junction");
+  await assert.rejects(operations.write("linked-directory/file.txt", "bad"), /symlinks/);
+});
diff --git a/integrations/dsh/tools.ts b/integrations/dsh/tools.ts
new file mode 100644
index 0000000..11913ad
--- /dev/null
+++ b/integrations/dsh/tools.ts
@@ -0,0 +1,91 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Type, type TSchema } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import type { ToolDefinition, ToolRunContext } from "@deepseek-ai/dsh-tools";
+import type { BraidInput, GraphUpdate } from "@chrok/braid";
+import { braidParameters, nodeParameters, updateEdgeParameters, loopParameters } from "./schema.js";
+import type { BraidJobs, JobSnapshot } from "./jobs.js";
+
+const id = Type.String({ minLength: 1, pattern: "\\S" });
+const revision = Type.Integer({ minimum: 0 });
+
+export function graphReceipt(job: JobSnapshot) {
+  return {
+    nodes: job.execution.graph.nodes.map(({ prompt: _prompt, ...node }) => node),
+    edges: job.execution.graph.edges, loops: job.execution.graph.loops ?? [],
+  };
+}
+
+/** Keep the canonical value lossless; save large responses before returning a bounded preview. */
+export async function boundedResult(value: object): Promise<object> {
+  const full = JSON.stringify(value, null, 2);
+  if (Buffer.byteLength(full) <= 50_000) return JSON.parse(full) as object;
+  const directory = await mkdtemp(join(tmpdir(), "braid-dsh-result-"));
+  const fullOutputPath = join(directory, "result.json");
+  await writeFile(fullOutputPath, full, { mode: 0o600 });
+  const control = value as Partial<JobSnapshot> & { canonicalJobId?: string };
+  return JSON.parse(JSON.stringify({ jobId: control.jobId, canonicalJobId: control.canonicalJobId, handle: control.handle, status: control.status,
+    execution: control.execution && { status: control.execution.status, revision: control.execution.revision, pausedExecutionIds: control.execution.pausedExecutionIds },
+    usage: control.usage, fullOutputPath, truncated: true, preview: full.slice(0, 10_000) })) as object;
+}
+
+export function createBraidTools(
+  getJobs: (context: ToolRunContext) => BraidJobs,
+  submit: (args: { goal: string; nodes: unknown[]; edges: unknown[]; options?: object }, context: ToolRunContext) => object,
+): ToolDefinition[] {
+  function tool<S extends TSchema>(name: string, description: string, parameters: S,
+    execute: (args: import("@sinclair/typebox").Static<S>, context: ToolRunContext) => object | Promise<object>): ToolDefinition {
+    // TypeBox's symbol metadata is local validation state, not lossless wire JSON.
+    return { name, description, parameters: JSON.parse(JSON.stringify(parameters)) as Record<string, unknown>,
+      output: { schema: { type: "object", additionalProperties: true }, render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }] },
+      async execute(args, context) {
+        context.signal.throwIfAborted();
+        if (!Value.Check(parameters, args)) throw new Error(`Invalid ${name} arguments: ${[...Value.Errors(parameters, args)].map(error => `${error.path} ${error.message}`).join("; ")}`);
+        return boundedResult(await execute(args, context));
+      },
+    };
+  }
+  return [
+    tool("braid", "Start a background Braid graph before nontrivial engineering work with independent concerns. Returns jobId immediately. Supports execute/decision/merge/integrate, promptTemplates, bounded loops, worktree isolation, pauseAfter and notifyOnCompletion. Omit workspace on merge/integrate. No automatic integration. Continue independent work; retrieve results after the completion reminder instead of polling.", braidParameters, submit),
+    tool("braid_status", "Retrieve progress and results by exact jobId handle or UUID. Omit all IDs to list this agent's jobs. executionId selects an exact invocation; nodeId selects its latest invocation. Control fields contain the CURRENT revision and paused IDs. Large results provide a fullOutputPath. usage includes completed provider rounds from failed workers and cache tokens; reads do not add charges.", Type.Object({
+      jobId: Type.Optional(id), nodeId: Type.Optional(id), executionId: Type.Optional(id),
+    }, { additionalProperties: false }), (args, context) => {
+      const jobs = getJobs(context);
+      if (!args.jobId) {
+        if (args.nodeId || args.executionId) throw new Error("nodeId/executionId requires jobId");
+        return { jobs: jobs.list() };
+      }
+      const job = jobs.get(args.jobId);
+      return args.nodeId || args.executionId ? {
+        jobId: job.jobId, handle: job.handle, status: job.status,
+        execution: { status: job.execution.status, revision: job.execution.revision, pausedExecutionIds: job.execution.pausedExecutionIds },
+        node: jobs.getNode(args.jobId, args.nodeId, args.executionId),
+      } : job;
+    }),
+    tool("braid_cancel", "Cancel a background job. Foreground cancellation does not stop Braid jobs.", Type.Object({ jobId: id }, { additionalProperties: false }), (args, context) => {
+      const jobs = getJobs(context), job = jobs.get(args.jobId);
+      return { jobId: job.handle, canonicalJobId: job.jobId, cancelled: jobs.cancel(args.jobId) };
+    }),
+    tool("braid_update", "Atomically edit live definitions and optionally resume paused executions at expectedRevision. Upserts replace complete definitions. Include new nodes and all dependencies/loops in the SAME update: disconnected roots may start immediately. removeEdges matches exact identities, not wildcards. Rejected patches have no effects; retry the complete corrected patch. Finalized jobs cannot be reopened.", Type.Object({
+      jobId: id, expectedRevision: revision,
+      upsertNodes: Type.Optional(Type.Array(nodeParameters)), removeNodeIds: Type.Optional(Type.Array(id)),
+      addEdges: Type.Optional(Type.Array(updateEdgeParameters)), removeEdges: Type.Optional(Type.Array(updateEdgeParameters)),
+      promptTemplates: Type.Optional(Type.Record(Type.String(), id)), loops: Type.Optional(Type.Array(loopParameters)),
+      resume: Type.Optional(Type.Array(id, { uniqueItems: true })),
+    }, { additionalProperties: false }), (args, context) => {
+      const { jobId, ...patch } = args;
+      let job: JobSnapshot;
+      try { job = getJobs(context).update(jobId, patch as GraphUpdate); }
+      catch (error) { throw new Error(`Braid update rejected; no changes or resumes applied. ${error instanceof Error ? error.message : String(error)}. Retry the complete corrected patch with dependencies, loops, and resume IDs.`); }
+      return { jobId: job.handle, canonicalJobId: job.jobId, revision: job.execution.revision, pausedExecutionIds: job.execution.pausedExecutionIds, graph: graphReceipt(job) };
+    }),
+    tool("braid_resume", "Release selected paused execution IDs at expectedRevision. This does not reset budgets or deadlines.", Type.Object({
+      jobId: id, expectedRevision: revision, executionIds: Type.Array(id, { minItems: 1, uniqueItems: true }),
+    }, { additionalProperties: false }), (args, context) => {
+      const job = getJobs(context).resume(args.jobId, args.executionIds, args.expectedRevision);
+      return { jobId: job.handle, canonicalJobId: job.jobId, revision: job.execution.revision, pausedExecutionIds: job.execution.pausedExecutionIds };
+    }),
+  ];
+}
diff --git a/integrations/dsh/tsconfig.build.json b/integrations/dsh/tsconfig.build.json
new file mode 100644
index 0000000..1bd7f95
--- /dev/null
+++ b/integrations/dsh/tsconfig.build.json
@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "rootDir": ".",
+    "outDir": "dist",
+    "declaration": true
+  },
+  "include": [
+    "*.ts"
+  ],
+  "exclude": [
+    "test",
+    "dist",
+    "node_modules"
+  ]
+}
diff --git a/integrations/dsh/tsconfig.client.json b/integrations/dsh/tsconfig.client.json
new file mode 100644
index 0000000..3e1b090
--- /dev/null
+++ b/integrations/dsh/tsconfig.client.json
@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": { "jsx": "react-jsx", "declaration": true, "rootDir": ".", "outDir": "dist", "types": ["react", "react-dom", "node"] },
+  "include": ["client/**/*.ts", "client/**/*.tsx", "panel-types.ts", "panel-contract.ts"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/integrations/dsh/tsconfig.json b/integrations/dsh/tsconfig.json
new file mode 100644
index 0000000..120c87e
--- /dev/null
+++ b/integrations/dsh/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": { "jsx": "react-jsx" },
+  "include": [
+    "*.ts",
+    "test/**/*.ts"
+  ]
+}
diff --git a/integrations/dsh/worker-tools.ts b/integrations/dsh/worker-tools.ts
new file mode 100644
index 0000000..a84fa68
--- /dev/null
+++ b/integrations/dsh/worker-tools.ts
@@ -0,0 +1,84 @@
+import { readdir, open } from "node:fs/promises";
+import { constants } from "node:fs";
+import { resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { Type, type TSchema } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import type { ModelRequest, NodeWorkspace } from "@chrok/braid";
+import { createWriteOperations } from "./write-tools.js";
+import { runCommand } from "./shell-tools.js";
+
+export interface WorkerTool {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  writes: boolean;
+  execute(args: unknown): Promise<string>;
+}
+
+export async function createWorkerTools(request: ModelRequest, workspace: NodeWorkspace): Promise<WorkerTool[]> {
+  const cwd = workspace.workingDirectory, signal = request.signal;
+  const tools: WorkerTool[] = [];
+  function add<S extends TSchema>(name: string, description: string, parameters: S, writes: boolean, execute: (args: import("@sinclair/typebox").Static<S>) => Promise<string>) {
+    tools.push({ name, description, parameters, writes, async execute(args) {
+      signal.throwIfAborted();
+      if (!Value.Check(parameters, args)) throw new Error(`Invalid ${name} arguments: ${[...Value.Errors(parameters, args)].map(error => `${error.path} ${error.message}`).join("; ")}`);
+      const result = await execute(args);
+      signal.throwIfAborted();
+      return result;
+    } });
+  }
+  const path = Type.String({ minLength: 1 });
+  add("read", "Read a UTF-8 file, with optional byte offset. Returns at most 50 KB; use the next offset for more.", Type.Object({
+    path, offset: Type.Optional(Type.Integer({ minimum: 0 })),
+  }, { additionalProperties: false }), false, async args => {
+    // Do not block opening a FIFO before the regular-file check can reject it.
+    const file = await open(resolve(cwd, args.path), constants.O_RDONLY | constants.O_NONBLOCK);
+    try {
+      if (!(await file.stat()).isFile()) throw new Error("read requires a regular file");
+      const buffer = Buffer.alloc(50_000);
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, args.offset ?? 0);
+      // Leave incomplete UTF-8 characters for the next window instead of corrupting them.
+      const text = new TextDecoder().decode(buffer.subarray(0, bytesRead), { stream: bytesRead === buffer.length });
+      const consumed = bytesRead === buffer.length ? Math.min(bytesRead, Buffer.byteLength(text)) : bytesRead;
+      return JSON.stringify({ text, nextOffset: (args.offset ?? 0) + consumed, eof: bytesRead < buffer.length });
+    } finally { await file.close(); }
+  });
+  add("ls", "List a directory (up to 1000 entries).", Type.Object({ path: Type.Optional(path) }, { additionalProperties: false }), false, async args => {
+    const entries = await readdir(resolve(cwd, args.path ?? "."), { withFileTypes: true });
+    return JSON.stringify({ entries: entries.slice(0, 1000).map(entry => entry.name + (entry.isDirectory() ? "/" : "")), truncated: entries.length > 1000 });
+  });
+  // Search is exposed only when rg is installed. No automatic downloads.
+  try {
+    execFileSync("rg", ["--version"], { stdio: "ignore", timeout: 2000 });
+    add("grep", "Search file content using ripgrep. Output is bounded to the last 50 KB.", Type.Object({ pattern: Type.String(), path: Type.Optional(path) }, { additionalProperties: false }), false,
+      args => runCommand("rg", ["--no-config", "-n", "--", args.pattern, args.path ?? "."], cwd, signal));
+    add("find", "Find file paths by glob using ripgrep; respects ignore rules. Output is bounded to the last 50 KB.", Type.Object({ pattern: path }, { additionalProperties: false }), false,
+      args => runCommand("rg", ["--no-config", "--files", "--glob", args.pattern], cwd, signal));
+  } catch { /* ls and read remain available without rg. */ }
+  const root = workspace.mode === "read-only" ? undefined : workspace.mode === "integrate" ? workspace.sourceRoot : workspace.worktreeRoot;
+  if (root) {
+    const writes = await createWriteOperations(cwd, root, signal, async () => {
+      if (!request.git) return [];
+      const result = await request.git(["ls-files", "--stage", "-z"]);
+      if (result.exitCode !== 0) throw new Error("Cannot validate submodule write boundaries");
+      return result.stdout.split("\0").filter(entry => entry.startsWith("160000 ")).map(entry => entry.slice(entry.indexOf("\t") + 1));
+    });
+    add("write", "Write a UTF-8 file inside the assigned workspace; create parent directories as needed.", Type.Object({ path, content: Type.String() }, { additionalProperties: false }), true, async args => {
+      await writes.write(args.path, args.content); return "File written.";
+    });
+    add("edit", "Replace exactly one occurrence of oldText with newText in a workspace file.", Type.Object({ path, oldText: Type.String({ minLength: 1 }), newText: Type.String() }, { additionalProperties: false }), true, async args => {
+      const content = await writes.read(args.path);
+      const first = content.indexOf(args.oldText);
+      if (first < 0 || content.indexOf(args.oldText, first + 1) >= 0) throw new Error("oldText must match exactly once");
+      await writes.write(args.path, content.slice(0, first) + args.newText + content.slice(first + args.oldText.length));
+      return "File edited.";
+    });
+    const shellParameters = Type.Object({ command: path, timeout: Type.Optional(Type.Number({ exclusiveMinimum: 0, maximum: 2_147_483.647 })) }, { additionalProperties: false });
+    add("bash", "Run a foreground shell command in the assigned workspace. timeout is seconds. Output retains the last 50 KB. Host permissions apply; do not daemonize.", shellParameters, true,
+      args => runCommand("bash", ["-c", args.command], cwd, signal, args.timeout));
+    if (process.platform === "win32") add("powershell", "Run a foreground PowerShell command in the assigned workspace. timeout is seconds.", shellParameters, true,
+      args => runCommand("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", args.command], cwd, signal, args.timeout));
+  }
+  return tools;
+}
diff --git a/integrations/dsh/write-tools.ts b/integrations/dsh/write-tools.ts
new file mode 100644
index 0000000..d130cdc
--- /dev/null
+++ b/integrations/dsh/write-tools.ts
@@ -0,0 +1,68 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+
+/** Enforce the write boundary in filesystem operations, not in model instructions. */
+export async function createWriteOperations(
+  cwd: string, root: string, signal: AbortSignal,
+  readOnlyPaths: () => Promise<string[]> = async () => [],
+) {
+  const boundary = await realpath(root);
+  const gitMetadata = await lstat(join(boundary, ".git"));
+  const checked = async (path: string): Promise<string> => {
+    signal.throwIfAborted();
+    const target = resolve(path);
+    // Callers can pass a lexical /tmp path while realpath uses /private/tmp on macOS.
+    const outside = (path: string) => path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path);
+    let relativePath = relative(root, target);
+    if (outside(relativePath)) relativePath = relative(boundary, target);
+    if (outside(relativePath))
+      throw new Error("Writes are allowed only inside this node's worktree");
+    if ((await readOnlyPaths()).some(path => relativePath === path || relativePath.startsWith(`${path}${sep}`)))
+      throw new Error("Writing inside submodules is not supported");
+    const parts = relativePath.split(sep).filter(Boolean);
+    if (parts.some(part => part.toLowerCase() === ".git"))
+      throw new Error("Writing Git metadata is not allowed");
+    let current = boundary;
+    // Reject symlinks, including dangling links and linked parent directories.
+    for (const part of parts) {
+      current = join(current, part);
+      try {
+        const stat = await lstat(current);
+        // Also catch filesystem-specific aliases of .git (case/Unicode/streams).
+        if (stat.dev === gitMetadata.dev && stat.ino === gitMetadata.ino)
+          throw new Error("Writing Git metadata is not allowed");
+        if (stat.isSymbolicLink()) throw new Error("Writing through symlinks is not allowed");
+        if (!stat.isDirectory() && (!stat.isFile() || stat.nlink > 1))
+          throw new Error("Writing special files or hard links is not allowed");
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      }
+    }
+    signal.throwIfAborted();
+    return current;
+  };
+  const writeFile = async (path: string, content: string): Promise<void> => {
+    const target = await checked(path);
+    // O_NOFOLLOW prevents following a replaced final symlink. Nodes have no
+    // operations that create links or rename directories; workspaces are private.
+    const file = await open(target, constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW, 0o644);
+    try {
+      const stat = await file.stat();
+      if (!stat.isFile() || stat.nlink > 1) throw new Error("Writing special files or hard links is not allowed");
+      signal.throwIfAborted();
+      await file.truncate(0);
+      await file.writeFile(content, "utf8");
+    } finally {
+      await file.close();
+    }
+  };
+  return {
+    read: async (path: string) => readFile(await checked(resolve(cwd, path)), "utf8"),
+    write: async (path: string, content: string) => {
+      const target = await checked(resolve(cwd, path));
+      await mkdir(await checked(resolve(target, "..")), { recursive: true });
+      await writeFile(target, content);
+    },
+  };
+}
diff --git a/package-lock.json b/package-lock.json
index 434e96a..f665993 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,8 @@
       "version": "0.3.0",
       "license": "MIT",
       "workspaces": [
-        "integrations/pi"
+        "integrations/pi",
+        "integrations/dsh"
       ],
       "devDependencies": {
         "@chrok/braid": "file:.",
@@ -21,19 +22,41 @@
         "node": ">=22"
       }
     },
-    "integrations/pi": {
-      "name": "@chrok/pi-braid",
+    "integrations/dsh": {
+      "name": "@chrok/dsh-braid",
       "version": "0.3.0",
       "license": "MIT",
       "dependencies": {
         "@chrok/braid": "0.3.0",
-        "grok-mermaid": "^0.2.2"
+        "@sinclair/typebox": "^0.34.41"
       },
       "devDependencies": {
-        "@earendil-works/pi-ai": "1.0.1",
-        "@earendil-works/pi-coding-agent": "1.0.1",
-        "@earendil-works/pi-tui": "1.0.1",
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-api-gateway": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-client-ui-chat": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-client-ui-sidebar-right": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-client-ui-tool": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-commands": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-jobs": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-jobs-local": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-registry": "0.2.0-rc.2",
+        "@types/jsdom": "21.1.7",
         "@types/node": "^22.0.0",
+        "@types/react": "18.3.28",
+        "@types/react-dom": "18.3.7",
+        "esbuild": "0.25.12",
+        "jsdom": "26.1.0",
+        "react": "18.3.1",
+        "react-dom": "18.3.1",
         "tsx": "^4.0.0",
         "typescript": "^5.0.0"
       },
@@ -41,50 +64,878 @@
         "node": ">=22.19.0"
       },
       "peerDependencies": {
-        "@earendil-works/pi-ai": "*",
-        "@earendil-works/pi-coding-agent": "*",
-        "@earendil-works/pi-tui": "*"
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-commands": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-jobs": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-registry": "0.2.0-rc.2"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@anthropic-ai/sdk": {
-      "version": "0.129.0",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.129.0.tgz",
-      "integrity": "sha512-MH7LB20kNpGLUpPTe2OG5XvL/KhX8HUO9XyBaFjgFk6TLS4Xjt0VPIuMKywe7POKKPslX+QxSlVok9e+8kG5Nw==",
+    "integrations/dsh/node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "json-schema-to-ts": "^3.1.1",
-        "standardwebhooks": "^1.0.0"
-      },
-      "bin": {
-        "anthropic-ai-sdk": "bin/cli"
-      },
-      "peerDependencies": {
-        "zod": "^3.25.0 || ^4.0.0"
-      },
-      "peerDependenciesMeta": {
-        "zod": {
-          "optional": true
-        }
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/dsh/node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "integrations/pi": {
+      "name": "@chrok/pi-braid",
+      "version": "0.3.0",
+      "license": "MIT",
+      "dependencies": {
+        "@chrok/braid": "0.3.0",
+        "grok-mermaid": "^0.2.2"
+      },
+      "devDependencies": {
+        "@earendil-works/pi-ai": "1.0.1",
+        "@earendil-works/pi-coding-agent": "1.0.1",
+        "@earendil-works/pi-tui": "1.0.1",
+        "@types/node": "^22.0.0",
+        "tsx": "^4.0.0",
+        "typescript": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=22.19.0"
+      },
+      "peerDependencies": {
+        "@earendil-works/pi-ai": "*",
+        "@earendil-works/pi-coding-agent": "*",
+        "@earendil-works/pi-tui": "*"
+      }
+    },
+    "node_modules/@anthropic-ai/sdk": {
+      "version": "0.129.0",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.129.0.tgz",
+      "integrity": "sha512-MH7LB20kNpGLUpPTe2OG5XvL/KhX8HUO9XyBaFjgFk6TLS4Xjt0VPIuMKywe7POKKPslX+QxSlVok9e+8kG5Nw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-schema-to-ts": "^3.1.1",
+        "standardwebhooks": "^1.0.0"
+      },
+      "bin": {
+        "anthropic-ai-sdk": "bin/cli"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",
+      "integrity": "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.3",
+        "@csstools/css-color-parser": "^3.0.9",
+        "@csstools/css-parser-algorithms": "^3.0.4",
+        "@csstools/css-tokenizer": "^3.0.3",
+        "lru-cache": "^10.4.3"
+      }
+    },
+    "node_modules/@aws-sdk/client-bedrock-runtime": {
+      "version": "3.1127.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/client-bedrock-runtime/-/client-bedrock-runtime-3.1127.0.tgz",
+      "integrity": "sha512-IDl/lrPb90aH+pZFHGNDmgH9nAUQj5PlZH1sJ3w7RikctyjHSnY3oNjZhrLoaBoQn/rNK0zsP6OHEqEhj2tdLA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.977.9",
+        "@aws-sdk/credential-provider-node": "^3.972.82",
+        "@aws-sdk/eventstream-handler-node": "^3.972.34",
+        "@aws-sdk/middleware-eventstream": "^3.972.29",
+        "@aws-sdk/middleware-websocket": "^3.972.52",
+        "@aws-sdk/token-providers": "3.1127.0",
+        "@aws-sdk/types": "^3.974.5",
+        "@smithy/core": "^3.33.3",
+        "@smithy/fetch-http-handler": "^5.7.2",
+        "@smithy/node-http-handler": "^4.11.3",
+        "@smithy/types": "^4.17.2",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/core": {
+      "version": "3.978.1",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.978.1.tgz",
+      "integrity": "sha512-LbY9aGsEiznDWmUc30Nwv3aIX/+dbwTx8KfS0yOC3NPYMO+O91e6jkT1azf34FwjOndq8/Q+RcVVZz5xnerwdg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.6",
+        "@aws-sdk/xml-builder": "^3.972.41",
+        "@aws/lambda-invoke-store": "^0.3.0",
+        "@smithy/core": "^3.35.0",
+        "@smithy/signature-v4": "^5.7.3",
+        "@smithy/types": "^4.19.0",
+        "bowser": "^2.11.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-env": {
+      "version": "3.972.72",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.72.tgz",
+      "integrity": "sha512-xTKO/FWJPozTIXbozVnVGoNBhaGba8TBcx+KyUjRVeOlXE+dUc7GTR1cLvu0uTdIdmemzaFbqqCshXeZA1fZew==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-http": {
+      "version": "3.972.74",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.74.tgz",
+      "integrity": "sha512-u91E/hT8f4d1xy0Jl7VG4nVKJ3lxbrZkoBTeSVoJdWBiSEUMwMS/9+e0H/aJVQV//Lt5wuzP+E69v4aRSsNTmw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/fetch-http-handler": "^5.8.0",
+        "@smithy/node-http-handler": "^4.12.1",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-ini": {
+      "version": "3.973.17",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.17.tgz",
+      "integrity": "sha512-ged4KXdBkvIC81bLvNHHuQKdKak/VXhQTR1NWYTTqW0474nlmsxy9O/vlgTIohDDWH3xpBdtVMZRyjb+DnocDA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/credential-provider-env": "^3.972.72",
+        "@aws-sdk/credential-provider-http": "^3.972.74",
+        "@aws-sdk/credential-provider-login": "^3.972.79",
+        "@aws-sdk/credential-provider-process": "^3.972.72",
+        "@aws-sdk/credential-provider-sso": "^3.973.16",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.78",
+        "@aws-sdk/nested-clients": "^3.997.46",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/credential-provider-imds": "^4.5.2",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-login": {
+      "version": "3.972.79",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.79.tgz",
+      "integrity": "sha512-L+Z85anONJd8MaiuraO4wRxATCdEejBZ3K3eymzWI5JPXa9sOS9CkIm72PBKqXKX+Z9p9NGMX5AIMXm0LEflgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/nested-clients": "^3.997.46",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-node": {
+      "version": "3.972.84",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.84.tgz",
+      "integrity": "sha512-oHt854odINVwzwsh+c5x69j0ajm4DbqqqVJ+O1ECsCIZeMDAbzFpXItaqP7UZstJj/ATdTk/KFSH0LaNAgV+kA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/credential-provider-env": "^3.972.72",
+        "@aws-sdk/credential-provider-http": "^3.972.74",
+        "@aws-sdk/credential-provider-ini": "^3.973.17",
+        "@aws-sdk/credential-provider-process": "^3.972.72",
+        "@aws-sdk/credential-provider-sso": "^3.973.16",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.78",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/credential-provider-imds": "^4.5.2",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-process": {
+      "version": "3.972.72",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.72.tgz",
+      "integrity": "sha512-rLIp2xbMjX/k9/od7APpqq1ZgXXnV0pOL1Th3ZsL8Wu0TRtBsDTVS8iPqcfRFcHakFxPvR04OSTv2ka2qOb/2A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-sso": {
+      "version": "3.973.16",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.16.tgz",
+      "integrity": "sha512-IGihaJfFZYacJJr/odqILCoK7W/mvrZ7cuK7ECn3sAu4vLC6u0V8bS7mCGbdugJ8Aum2tnvqmx0F2MRFp2rn9g==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/nested-clients": "^3.997.46",
+        "@aws-sdk/token-providers": "3.1138.0",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-sso/node_modules/@aws-sdk/token-providers": {
+      "version": "3.1138.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1138.0.tgz",
+      "integrity": "sha512-GpyAr0DD63YOEmYFM6Df+gJuIgC92MMTiBK4FTKfxii5MJ9ge20epR7LyroulscYlG89J+ZB2ivFDPjvfQhzdw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/nested-clients": "^3.997.46",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-web-identity": {
+      "version": "3.972.78",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.78.tgz",
+      "integrity": "sha512-/y9WvNtlcPBGLR0qc1a+9J/xtYZfVczvLUOuXaVWylzttH7ewsxwHtjmiJSolNrVSDorIxHGHMU61CbonRkmwA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/nested-clients": "^3.997.46",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/eventstream-handler-node": {
+      "version": "3.972.35",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/eventstream-handler-node/-/eventstream-handler-node-3.972.35.tgz",
+      "integrity": "sha512-a8xilRoRaalvSPZdfrs0VY3/BPc0uYhXW56Z/k6nmZ5Vk430LHeowf9APIPq8utM3tMJSNGSSuJMlB9YrPsN+A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/middleware-eventstream": {
+      "version": "3.972.30",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-eventstream/-/middleware-eventstream-3.972.30.tgz",
+      "integrity": "sha512-B6gvZlcnRBNWraKgyEjKsbhv+VjtbyHmpU7hmtTHzXpDSxHPpCJnYLpglEOOsF+SFne20DbZC5IVC1aNr2Pb4A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/middleware-websocket": {
+      "version": "3.972.54",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-websocket/-/middleware-websocket-3.972.54.tgz",
+      "integrity": "sha512-bhESdru8u8KosziH8jcVta/NM/dNreeRz2+2aU86si5bfBYOiJ6IiqD+9U4URUcU5WJO3Yw+jO3GLDIHlscXMQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/fetch-http-handler": "^5.8.0",
+        "@smithy/signature-v4": "^5.7.3",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/nested-clients": {
+      "version": "3.997.46",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.46.tgz",
+      "integrity": "sha512-oRxtBcka/JGHGs9l9p9IVajGoTP8vTPmoAzdHGy4Qcy9P5vPnDf6nhIeM/COQNY9k/OahImTRaLkHftoXvfcmQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.978.1",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.47",
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/core": "^3.35.0",
+        "@smithy/fetch-http-handler": "^5.8.0",
+        "@smithy/node-http-handler": "^4.12.1",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/signature-v4-multi-region": {
+      "version": "3.996.47",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.47.tgz",
+      "integrity": "sha512-Zk08macMvQTHzQJCLJVkOlviVoqwYMrpXv4lmLN7b7sAbiMoOK7Go0NYdR5UeF+MW8LIbRmwrNy9u/5VvX1U5g==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.6",
+        "@smithy/signature-v4": "^5.7.3",
+        "@smithy/types": "^4.19.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
       }
     },
-    "node_modules/@aws-sdk/client-bedrock-runtime": {
+    "node_modules/@aws-sdk/token-providers": {
       "version": "3.1127.0",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/client-bedrock-runtime/-/client-bedrock-runtime-3.1127.0.tgz",
-      "integrity": "sha512-IDl/lrPb90aH+pZFHGNDmgH9nAUQj5PlZH1sJ3w7RikctyjHSnY3oNjZhrLoaBoQn/rNK0zsP6OHEqEhj2tdLA==",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1127.0.tgz",
+      "integrity": "sha512-Dv2TMWBshJ+tF6ahs2Sy5bh4Iabsd4GAQqVvE9XZmYmnoaVbpS2QKIKE/HRacc7bTtbjEEvP+laGzHvHlf1CiQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "@aws-sdk/core": "^3.977.9",
-        "@aws-sdk/credential-provider-node": "^3.972.82",
-        "@aws-sdk/eventstream-handler-node": "^3.972.34",
-        "@aws-sdk/middleware-eventstream": "^3.972.29",
-        "@aws-sdk/middleware-websocket": "^3.972.52",
-        "@aws-sdk/token-providers": "3.1127.0",
+        "@aws-sdk/nested-clients": "^3.997.44",
         "@aws-sdk/types": "^3.974.5",
         "@smithy/core": "^3.33.3",
-        "@smithy/fetch-http-handler": "^5.7.2",
-        "@smithy/node-http-handler": "^4.11.3",
         "@smithy/types": "^4.17.2",
         "tslib": "^2.6.2"
       },
@@ -92,36 +943,27 @@
         "node": ">=20.0.0"
       }
     },
-    "node_modules/@aws-sdk/core": {
-      "version": "3.978.1",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.978.1.tgz",
-      "integrity": "sha512-LbY9aGsEiznDWmUc30Nwv3aIX/+dbwTx8KfS0yOC3NPYMO+O91e6jkT1azf34FwjOndq8/Q+RcVVZz5xnerwdg==",
+    "node_modules/@aws-sdk/types": {
+      "version": "3.974.6",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.974.6.tgz",
+      "integrity": "sha512-v/clNZzZnDxGyvpHMOGpJKVXFAExJzUNAAjaWGdcx8QAcXLGwTaOkw33p5SHAi0YAioK32xB3hWwOekRVfmfKg==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@aws-sdk/types": "^3.974.6",
-        "@aws-sdk/xml-builder": "^3.972.41",
-        "@aws/lambda-invoke-store": "^0.3.0",
-        "@smithy/core": "^3.35.0",
-        "@smithy/signature-v4": "^5.7.3",
         "@smithy/types": "^4.19.0",
-        "bowser": "^2.11.0",
         "tslib": "^2.6.2"
       },
       "engines": {
         "node": ">=20.0.0"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-env": {
-      "version": "3.972.72",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.72.tgz",
-      "integrity": "sha512-xTKO/FWJPozTIXbozVnVGoNBhaGba8TBcx+KyUjRVeOlXE+dUc7GTR1cLvu0uTdIdmemzaFbqqCshXeZA1fZew==",
+    "node_modules/@aws-sdk/xml-builder": {
+      "version": "3.972.41",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.41.tgz",
+      "integrity": "sha512-ctjVSyCMegrWfXlx6VqzSBFI6UqmQ5ZlnfMhdLIiWmhoH8UAQxSCP5N3OpG7X3k4LnS7ou74C4mt20+bfTW2aQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
         "@smithy/types": "^4.19.0",
         "tslib": "^2.6.2"
       },
@@ -129,323 +971,670 @@
         "node": ">=20.0.0"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-http": {
-      "version": "3.972.74",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.74.tgz",
-      "integrity": "sha512-u91E/hT8f4d1xy0Jl7VG4nVKJ3lxbrZkoBTeSVoJdWBiSEUMwMS/9+e0H/aJVQV//Lt5wuzP+E69v4aRSsNTmw==",
+    "node_modules/@aws/lambda-invoke-store": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz",
+      "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==",
       "dev": true,
       "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@chrok/braid": {
+      "resolved": "",
+      "link": true
+    },
+    "node_modules/@chrok/dsh-braid": {
+      "resolved": "integrations/dsh",
+      "link": true
+    },
+    "node_modules/@chrok/pi-braid": {
+      "resolved": "integrations/pi",
+      "link": true
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/fetch-http-handler": "^5.8.0",
-        "@smithy/node-http-handler": "^4.12.1",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
       },
       "engines": {
-        "node": ">=20.0.0"
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-ini": {
-      "version": "3.973.17",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.17.tgz",
-      "integrity": "sha512-ged4KXdBkvIC81bLvNHHuQKdKak/VXhQTR1NWYTTqW0474nlmsxy9O/vlgTIohDDWH3xpBdtVMZRyjb+DnocDA==",
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
       "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/credential-provider-env": "^3.972.72",
-        "@aws-sdk/credential-provider-http": "^3.972.74",
-        "@aws-sdk/credential-provider-login": "^3.972.79",
-        "@aws-sdk/credential-provider-process": "^3.972.72",
-        "@aws-sdk/credential-provider-sso": "^3.973.16",
-        "@aws-sdk/credential-provider-web-identity": "^3.972.78",
-        "@aws-sdk/nested-clients": "^3.997.46",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/credential-provider-imds": "^4.5.2",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
       },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
       "engines": {
-        "node": ">=20.0.0"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@deepseek-ai/cordis": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/cordis/-/cordis-4.0.4.tgz",
+      "integrity": "sha512-obgyxqWAmFn3Re8kvsuUnyW+ihrz6eJCnJO4fh1cQzDtmPYz/zzVeUkH9R94I0OwSVOocK67Kgakm04j/oQXzg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@deepseek-ai/cosmokit": "~1.8.5",
+        "@standard-schema/spec": "^1.1.0"
+      },
+      "bin": {
+        "cordis": "bin.js"
+      },
+      "peerDependencies": {
+        "@deepseek-ai/cordis-plugin-include": "~1.0.9",
+        "@deepseek-ai/cordis-plugin-loader": "~1.0.5"
+      },
+      "peerDependenciesMeta": {
+        "@deepseek-ai/cordis-plugin-include": {
+          "optional": true
+        },
+        "@deepseek-ai/cordis-plugin-loader": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@deepseek-ai/cosmokit": {
+      "version": "1.8.5",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/cosmokit/-/cosmokit-1.8.5.tgz",
+      "integrity": "sha512-LXsrlem9z8dq4sLflj2yuCuYX7KqhdzF5hZly3eZyuTo8d6oDSOXuEgC5DbQWKW+lksm6zmOutQLsP/ma6wR6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@deepseek-ai/dsh-agent": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-agent/-/dsh-agent-0.2.0-rc.2.tgz",
+      "integrity": "sha512-CUkbU+c1G0ETXkpoLkpAFo5midz66FQGtlgQOP9pzvU9H3zJQVl4H5LrhhGVbEXKLFgdbtQiOynEW8hpWn3y0Q==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-util-values": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-workspace": "0.2.0-rc.2"
+      },
+      "peerDependenciesMeta": {
+        "@deepseek-ai/dsh-workspace": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-api-gateway": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-api-gateway/-/dsh-api-gateway-0.2.0-rc.2.tgz",
+      "integrity": "sha512-syeclzuoVpGor6JyDHcxg2Iwy9oeM76y4dK8abY19x1s/eMgJMCO3kL/IeKPg+d0Go7aHPTEyWRvCmfkA35U1g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@deepseek-ai/dsh-deque": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-timeout": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+        "@deepseek-ai/schemastery": "~3.18.4",
+        "ws": "^8.21.0"
+      },
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-client-connection": "0.2.0-rc.2"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-attachment": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-attachment/-/dsh-attachment-0.2.0-rc.2.tgz",
+      "integrity": "sha512-asUDLv+mfb30vjjlQtMI9aBnC+kmPoUxS1ooadhwAd8wssIlLetq97nzC5W1qd0GQGwZtPG/gpljVAMcSwPr1g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-brand": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-brand/-/dsh-brand-0.2.0-rc.2.tgz",
+      "integrity": "sha512-A5XlN4tIgP0qObkYFhcZ7Oz/tM2oESEZqLwS0Qq+sM1ivGx6o4AMPgJdfKQlwLzqk0cMLNtAaVBHfiYoElt4lw==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-connection": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-connection/-/dsh-client-connection-0.2.0-rc.2.tgz",
+      "integrity": "sha512-eL66YSZ0+HlWRzAPGU8jtCLd322WXBoMGN1g1OsM5T7Skqbbo9hSwV1FO3Lm0IcMZR3Y07sGPQBwZwf/l66T3w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@deepseek-ai/dsh-credentials": "0.2.0-rc.2",
+        "@deepseek-ai/schemastery": "~3.18.4",
+        "zod": "^4.4.3"
+      },
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-ui-chat": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-ui-chat/-/dsh-client-ui-chat-0.2.0-rc.2.tgz",
+      "integrity": "sha512-1rsCHGvWNLaO6B6t1fJa8Qsov0OvJC6bnhpyK2NmDCaLu9uzb4dC4DxCH3OzmJwJkEByHrb3j3l9kbpaV+dTCw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@deepseek-ai/schemastery": "~3.18.4"
+      },
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-ui-conversation": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-ui-conversation/-/dsh-client-ui-conversation-0.2.0-rc.2.tgz",
+      "integrity": "sha512-Y1eWKVeh84cbB0fcV0MFOMUHBeptlzBCzsw6xslZS7p1a8l9PeFcjx5ZVTkKFuFMCfwEHWTeV9HcYqWLYH0bhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@deepseek-ai/schemastery": "~3.18.4"
+      },
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-ui-renderer": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-ui-renderer/-/dsh-client-ui-renderer-0.2.0-rc.2.tgz",
+      "integrity": "sha512-vQ/LH4A53K1J/UeF5fQs1Dj8km5cnVos7vO0rmj+pJROhE6Vs7pAAKGz5P2e02t2/2to6+iMDu2+SSITrcYWTQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-ui-sidebar-right": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-ui-sidebar-right/-/dsh-client-ui-sidebar-right-0.2.0-rc.2.tgz",
+      "integrity": "sha512-ocVUP6v3X7vShYeJ5I1Z3t1lDC02hJdZ49/kIRj29Xbe+BIfMY9HSDyUVUUDdijdd3jP8dpmhmbHbDJudwFUtQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-ui-slots": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-ui-slots/-/dsh-client-ui-slots-0.2.0-rc.2.tgz",
+      "integrity": "sha512-zfILCyG3ijHT7S8+WDXFz4RMxBJtG9A3ngtDBnqcLbD5wzKz8H7E+HC657USa6RgG13C2RGSs73sfKcSs4WtWQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-client-ui-tool": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-client-ui-tool/-/dsh-client-ui-tool-0.2.0-rc.2.tgz",
+      "integrity": "sha512-Obs9FeOoIHWJUszQTY4MbdqAhlxX+lkzpwPpxk36t2pGCfkvaPWDdKwC0oUrTkRZxqYdx7inY8JK/+PZaWPnoA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-commands": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-commands/-/dsh-commands-0.2.0-rc.2.tgz",
+      "integrity": "sha512-pU5oUyOMPDN0yxEjE1wJRInNeC5hs5vJnbOG8MSSfkFov/7Q8hrfwETxZtcRnbrpzzeG19wsvtRz1twkEMKZBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@deepseek-ai/dsh-util-crypto": "0.2.0-rc.2",
+        "zod": "^4.4.3"
+      },
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-login": {
-      "version": "3.972.79",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.79.tgz",
-      "integrity": "sha512-L+Z85anONJd8MaiuraO4wRxATCdEejBZ3K3eymzWI5JPXa9sOS9CkIm72PBKqXKX+Z9p9NGMX5AIMXm0LEflgw==",
+    "node_modules/@deepseek-ai/dsh-credentials": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-credentials/-/dsh-credentials-0.2.0-rc.2.tgz",
+      "integrity": "sha512-TQlvP0jxXYGy1ZNzh4nVsiCzb8FR9iGarD6BfIZ3LwJC8lDtjSxQHWE8//NYjpn10TIMxmaR4s6niHuJ3JkTOw==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/nested-clients": "^3.997.46",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-node": {
-      "version": "3.972.84",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.84.tgz",
-      "integrity": "sha512-oHt854odINVwzwsh+c5x69j0ajm4DbqqqVJ+O1ECsCIZeMDAbzFpXItaqP7UZstJj/ATdTk/KFSH0LaNAgV+kA==",
+    "node_modules/@deepseek-ai/dsh-deque": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-deque/-/dsh-deque-0.2.0-rc.2.tgz",
+      "integrity": "sha512-XwZvafZAxyDm2TRnQetEizuczZ1UG7RhO8vmmIUbAdjbRbMA15NOTlJ3d24uw+I8gcSKKkmWl/jwoKYKl/qo/A==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-invariants": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-invariants/-/dsh-invariants-0.2.0-rc.2.tgz",
+      "integrity": "sha512-QOVc0HpRsS8ekvprb45FlxieDvgR/cAMaxW289HASjMoV/U/B54FpbkHuPBw4EnTw07/sPkjx2B/23+YqE0cbg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@aws-sdk/credential-provider-env": "^3.972.72",
-        "@aws-sdk/credential-provider-http": "^3.972.74",
-        "@aws-sdk/credential-provider-ini": "^3.973.17",
-        "@aws-sdk/credential-provider-process": "^3.972.72",
-        "@aws-sdk/credential-provider-sso": "^3.973.16",
-        "@aws-sdk/credential-provider-web-identity": "^3.972.78",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/credential-provider-imds": "^4.5.2",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/schemastery": "~3.18.4"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-process": {
-      "version": "3.972.72",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.72.tgz",
-      "integrity": "sha512-rLIp2xbMjX/k9/od7APpqq1ZgXXnV0pOL1Th3ZsL8Wu0TRtBsDTVS8iPqcfRFcHakFxPvR04OSTv2ka2qOb/2A==",
+    "node_modules/@deepseek-ai/dsh-jobs": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-jobs/-/dsh-jobs-0.2.0-rc.2.tgz",
+      "integrity": "sha512-SuCCfXZDabBxsKbHoulXEeQrRSYuOYLSfhvnflQf+CYeb68wggKraejkLyO60LrCGnBJsgCqKIdIKLCUvIeN+g==",
       "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-workspace": "0.2.0-rc.2"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependenciesMeta": {
+        "@deepseek-ai/dsh-workspace": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@aws-sdk/credential-provider-sso": {
-      "version": "3.973.16",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.16.tgz",
-      "integrity": "sha512-IGihaJfFZYacJJr/odqILCoK7W/mvrZ7cuK7ECn3sAu4vLC6u0V8bS7mCGbdugJ8Aum2tnvqmx0F2MRFp2rn9g==",
+    "node_modules/@deepseek-ai/dsh-jobs-local": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-jobs-local/-/dsh-jobs-local-0.2.0-rc.2.tgz",
+      "integrity": "sha512-sNyolYfcNVodxGyoWUM3G0f+numJexMrqwR0HC4x9kvzzZNR1WZV7ca4lCAzlaRSEvY8UPYxKC6Fi4T+MnBkSQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/nested-clients": "^3.997.46",
-        "@aws-sdk/token-providers": "3.1138.0",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/schemastery": "~3.18.4"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-jobs": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-timeout": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-sso/node_modules/@aws-sdk/token-providers": {
-      "version": "3.1138.0",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1138.0.tgz",
-      "integrity": "sha512-GpyAr0DD63YOEmYFM6Df+gJuIgC92MMTiBK4FTKfxii5MJ9ge20epR7LyroulscYlG89J+ZB2ivFDPjvfQhzdw==",
+    "node_modules/@deepseek-ai/dsh-llm": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-llm/-/dsh-llm-0.2.0-rc.2.tgz",
+      "integrity": "sha512-6QFrQn/h0iNqCfPpgQidnHtLSpA99A7ZND/uYKaGSd/4BGP8KBhuRd0w63e9s4u+hfW8jc3j29WKcNLIOeUfcA==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/nested-clients": "^3.997.46",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-timeout": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-util-crypto": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-util-values": "0.2.0-rc.2",
+        "@deepseek-ai/schemastery": "~3.18.4",
+        "zod": "^4.4.3"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
       }
     },
-    "node_modules/@aws-sdk/credential-provider-web-identity": {
-      "version": "3.972.78",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.78.tgz",
-      "integrity": "sha512-/y9WvNtlcPBGLR0qc1a+9J/xtYZfVczvLUOuXaVWylzttH7ewsxwHtjmiJSolNrVSDorIxHGHMU61CbonRkmwA==",
+    "node_modules/@deepseek-ai/dsh-ptc-runtime": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-ptc-runtime/-/dsh-ptc-runtime-0.2.0-rc.2.tgz",
+      "integrity": "sha512-HR/3h1VFRcNlAAjCtCAxZ4V3F5pViYicXcLBuYLGjzXWpOhr4zKzeFKh9+UMLjsc9XWIarJMoSvxl662nDV/xQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-sandbox": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-sandbox/-/dsh-sandbox-0.2.0-rc.2.tgz",
+      "integrity": "sha512-luKF7ey6HRZkGhImqLCB5Npt4f4omDRk1r+x5qQNqqdNOuN9LXciKDMNPfnSbHfKCcqSZbH3sK+APOmKzRAhVA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/nested-clients": "^3.997.46",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/dsh-util-values": "0.2.0-rc.2"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/eventstream-handler-node": {
-      "version": "3.972.35",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/eventstream-handler-node/-/eventstream-handler-node-3.972.35.tgz",
-      "integrity": "sha512-a8xilRoRaalvSPZdfrs0VY3/BPc0uYhXW56Z/k6nmZ5Vk430LHeowf9APIPq8utM3tMJSNGSSuJMlB9YrPsN+A==",
+    "node_modules/@deepseek-ai/dsh-sandbox-policy": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-sandbox-policy/-/dsh-sandbox-policy-0.2.0-rc.2.tgz",
+      "integrity": "sha512-0xXVqWw908/V6scohMyyU9SZSiQJYji+S1hMPulcUNLb3iew89d+WPWMIkWQBJRvcJzdQ2ghHwCESRkONXTJnQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/schemastery": "~3.18.4",
+        "zod": "^4.4.3"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/middleware-eventstream": {
-      "version": "3.972.30",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-eventstream/-/middleware-eventstream-3.972.30.tgz",
-      "integrity": "sha512-B6gvZlcnRBNWraKgyEjKsbhv+VjtbyHmpU7hmtTHzXpDSxHPpCJnYLpglEOOsF+SFne20DbZC5IVC1aNr2Pb4A==",
+    "node_modules/@deepseek-ai/dsh-scope": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-scope/-/dsh-scope-0.2.0-rc.2.tgz",
+      "integrity": "sha512-066p7Wv74GNWt4xA5Cyvl+7c/i9KrNEDALYh2/hu0VsJPLb4T9He+TY7y1bld9OgungmqyTy1n/cB2ZrVskvxA==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-session": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-session/-/dsh-session-0.2.0-rc.2.tgz",
+      "integrity": "sha512-wj+6MeqCYbDcbEvKH3puHyEGdjyu51JwBoN6Ua2tz6griLufDgLM5HpSU40L5xgpbOfrYVhXZs4vRgOrMlFY2g==",
+      "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-util-values": "0.2.0-rc.2"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/middleware-websocket": {
-      "version": "3.972.54",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-websocket/-/middleware-websocket-3.972.54.tgz",
-      "integrity": "sha512-bhESdru8u8KosziH8jcVta/NM/dNreeRz2+2aU86si5bfBYOiJ6IiqD+9U4URUcU5WJO3Yw+jO3GLDIHlscXMQ==",
+    "node_modules/@deepseek-ai/dsh-session-projection": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-session-projection/-/dsh-session-projection-0.2.0-rc.2.tgz",
+      "integrity": "sha512-caJ+XGjmR8ouws0LrvuXrabrzi21akB2l8CniUHdx4IpT6GkLapFYlWLbjZlDYqEWB3ktR+q32nxW2s+f27GSA==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/fetch-http-handler": "^5.8.0",
-        "@smithy/signature-v4": "^5.7.3",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "zod": "^4.4.3"
       },
-      "engines": {
-        "node": ">= 14.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/nested-clients": {
-      "version": "3.997.46",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.46.tgz",
-      "integrity": "sha512-oRxtBcka/JGHGs9l9p9IVajGoTP8vTPmoAzdHGy4Qcy9P5vPnDf6nhIeM/COQNY9k/OahImTRaLkHftoXvfcmQ==",
+    "node_modules/@deepseek-ai/dsh-system-prompt": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-system-prompt/-/dsh-system-prompt-0.2.0-rc.2.tgz",
+      "integrity": "sha512-ZZNk2gkXFV8CIT0IOZXS+pFaxNVJaRknYyH2vc4ZgZAiHKT+RqUYNr8e1F5Kp0AaN0DNlcTkjOGP5MCxeXfDjg==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/core": "^3.978.1",
-        "@aws-sdk/signature-v4-multi-region": "^3.996.47",
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/core": "^3.35.0",
-        "@smithy/fetch-http-handler": "^5.8.0",
-        "@smithy/node-http-handler": "^4.12.1",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/schemastery": "~3.18.4"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/signature-v4-multi-region": {
-      "version": "3.996.47",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.47.tgz",
-      "integrity": "sha512-Zk08macMvQTHzQJCLJVkOlviVoqwYMrpXv4lmLN7b7sAbiMoOK7Go0NYdR5UeF+MW8LIbRmwrNy9u/5VvX1U5g==",
+    "node_modules/@deepseek-ai/dsh-timeout": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-timeout/-/dsh-timeout-0.2.0-rc.2.tgz",
+      "integrity": "sha512-NDob8b8DJDB/sDPz3P7xhrkxOh1O9FbN1EZRKsxP4fuTfp4hrQU7aekYS5qZENFKoR8dBJMTh/zcEBw4m31glQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
+      }
+    },
+    "node_modules/@deepseek-ai/dsh-tools": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-tools/-/dsh-tools-0.2.0-rc.2.tgz",
+      "integrity": "sha512-vquUz8PjHWE4zaS3wH70IpYjL441p2UlUcG8TN2yJZN1RhDkuiHum4bWCsjEPyWLS/aB1QJvzdXC2EK/PRkbsQ==",
+      "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/types": "^3.974.6",
-        "@smithy/signature-v4": "^5.7.3",
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-util-values": "0.2.0-rc.2",
+        "@deepseek-ai/schemastery": "~3.18.4"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-ptc-runtime": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-user-approval": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws-sdk/token-providers": {
-      "version": "3.1127.0",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1127.0.tgz",
-      "integrity": "sha512-Dv2TMWBshJ+tF6ahs2Sy5bh4Iabsd4GAQqVvE9XZmYmnoaVbpS2QKIKE/HRacc7bTtbjEEvP+laGzHvHlf1CiQ==",
+    "node_modules/@deepseek-ai/dsh-typert-protocol": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-typert-protocol/-/dsh-typert-protocol-0.2.0-rc.2.tgz",
+      "integrity": "sha512-95RvIDcVac2BWdv1IxN6yKlRV+8eEvkofqSxV+d0r8x1kx2EIWEsbdxz6C+coYIm+8e03MiN+rwOt8J7sLfe7Q==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@aws-sdk/core": "^3.977.9",
-        "@aws-sdk/nested-clients": "^3.997.44",
-        "@aws-sdk/types": "^3.974.5",
-        "@smithy/core": "^3.33.3",
-        "@smithy/types": "^4.17.2",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
       }
     },
-    "node_modules/@aws-sdk/types": {
-      "version": "3.974.6",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.974.6.tgz",
-      "integrity": "sha512-v/clNZzZnDxGyvpHMOGpJKVXFAExJzUNAAjaWGdcx8QAcXLGwTaOkw33p5SHAi0YAioK32xB3hWwOekRVfmfKg==",
+    "node_modules/@deepseek-ai/dsh-typert-registry": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-typert-registry/-/dsh-typert-registry-0.2.0-rc.2.tgz",
+      "integrity": "sha512-Hjepcu0cDTH4rz/SB121SVozg9ix79NBB+HNr0jW0GSHG9O24kNDyufAJD2/S4B97KVN+1nM0T8k1Dx2JSOEWQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "zod": "^4.4.3"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
       }
     },
-    "node_modules/@aws-sdk/xml-builder": {
-      "version": "3.972.41",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.41.tgz",
-      "integrity": "sha512-ctjVSyCMegrWfXlx6VqzSBFI6UqmQ5ZlnfMhdLIiWmhoH8UAQxSCP5N3OpG7X3k4LnS7ou74C4mt20+bfTW2aQ==",
+    "node_modules/@deepseek-ai/dsh-user-approval": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-user-approval/-/dsh-user-approval-0.2.0-rc.2.tgz",
+      "integrity": "sha512-fZMfDp4IeWZMwAKEQkuAYCiGRrwoVWNObvAbpdmQNUavjfYCtwwduWqYQz+5lMQq8vENdczBj7cxnO/pOQ1oZQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@smithy/types": "^4.19.0",
-        "tslib": "^2.6.2"
+        "@deepseek-ai/schemastery": "~3.18.4"
       },
-      "engines": {
-        "node": ">=20.0.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4",
+        "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+        "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2"
       }
     },
-    "node_modules/@aws/lambda-invoke-store": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz",
-      "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==",
+    "node_modules/@deepseek-ai/dsh-util-crypto": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-util-crypto/-/dsh-util-crypto-0.2.0-rc.2.tgz",
+      "integrity": "sha512-5OvvmepY69uXTagUMlnoHqg7euI4ZMifLgfdV8xZO20OslWGGiRCkJbZRyDtcJG9GsXWz9UimfWmUu52zKXJ5w==",
       "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.0.0"
+      "license": "MIT",
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
       }
     },
-    "node_modules/@babel/runtime": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
-      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+    "node_modules/@deepseek-ai/dsh-util-values": {
+      "version": "0.2.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/dsh-util-values/-/dsh-util-values-0.2.0-rc.2.tgz",
+      "integrity": "sha512-qgpsbgiZABuE9UvgNaVo9b2HiWwLeU93CTl9PFXqE0jN8ap1ALxzQsLGvr/q2MJuWDYqnFBg60XnqnY8ZxPWEg==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
+      "peerDependencies": {
+        "@deepseek-ai/cordis": "~4.0.4"
       }
     },
-    "node_modules/@chrok/braid": {
-      "resolved": "",
-      "link": true
-    },
-    "node_modules/@chrok/pi-braid": {
-      "resolved": "integrations/pi",
-      "link": true
+    "node_modules/@deepseek-ai/schemastery": {
+      "version": "3.18.4",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/schemastery/-/schemastery-3.18.4.tgz",
+      "integrity": "sha512-SSXO6tYuyrIqKVbmOnIq0s+riUywYzouFMcnBluHF9n4KMo2G8HvEzhCYj6pj2617/glOjbJuVInJ9hfONsjkg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@deepseek-ai/cosmokit": "~1.8.5",
+        "@standard-schema/spec": "^1.1.0"
+      }
     },
     "node_modules/@earendil-works/chord": {
       "version": "1.0.1",
@@ -1258,6 +2447,12 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/@sinclair/typebox": {
+      "version": "0.34.52",
+      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.34.52.tgz",
+      "integrity": "sha512-XiMQh7qqVlxZzcVD+kkGMNGMzcTrDMLWI7S4x7z1MkCkbDPrekpZXEUK0eZqZFMuHQg2a2DZOcDIh9o5v3Gonw==",
+      "license": "MIT"
+    },
     "node_modules/@smithy/core": {
       "version": "3.35.0",
       "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.35.0.tgz",
@@ -1352,6 +2547,25 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/jsdom": {
+      "version": "21.1.7",
+      "resolved": "https://registry.npmjs.org/@types/jsdom/-/jsdom-21.1.7.tgz",
+      "integrity": "sha512-yOriVnggzrnQ3a9OKOCxaVuSug3w3/SbOj5i7VwXWZEyUNl3bLF9V3MfxGbZKuwqJOQyRfqXyROBB1CoZLFWzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "@types/tough-cookie": "*",
+        "parse5": "^7.0.0"
+      }
+    },
     "node_modules/@types/node": {
       "version": "22.20.4",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.4.tgz",
@@ -1362,6 +2576,34 @@
         "undici-types": "~6.21.0"
       }
     },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.15",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "18.3.28",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.28.tgz",
+      "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/prop-types": "*",
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "18.3.7",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
+      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^18.0.0"
+      }
+    },
     "node_modules/@types/retry": {
       "version": "0.12.0",
       "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz",
@@ -1369,6 +2611,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/tough-cookie": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/@types/tough-cookie/-/tough-cookie-4.0.5.tgz",
+      "integrity": "sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/agent-base": {
       "version": "9.0.0",
       "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-9.0.0.tgz",
@@ -1462,6 +2711,27 @@
         "node": ">= 8"
       }
     },
+    "node_modules/cssstyle": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-4.6.0.tgz",
+      "integrity": "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^3.2.0",
+        "rrweb-cssom": "^0.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/data-uri-to-buffer": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
@@ -1472,6 +2742,20 @@
         "node": ">= 12"
       }
     },
+    "node_modules/data-urls": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-5.0.0.tgz",
+      "integrity": "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -1490,6 +2774,13 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/diff": {
       "version": "8.0.4",
       "resolved": "https://registry.npmjs.org/diff/-/diff-8.0.4.tgz",
@@ -1510,6 +2801,19 @@
         "safe-buffer": "^5.0.1"
       }
     },
+    "node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/esbuild": {
       "version": "0.28.2",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
@@ -1722,6 +3026,19 @@
         "node": ">=18"
       }
     },
+    "node_modules/html-encoding-sniffer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+      "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-encoding": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/http-proxy-agent": {
       "version": "9.1.0",
       "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-9.1.0.tgz",
@@ -1752,6 +3069,19 @@
         "node": ">= 20"
       }
     },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/ignore": {
       "version": "7.0.8",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.8.tgz",
@@ -1762,6 +3092,13 @@
         "node": ">= 4"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -1769,6 +3106,91 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jsdom": {
+      "version": "26.1.0",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-26.1.0.tgz",
+      "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssstyle": "^4.2.1",
+        "data-urls": "^5.0.0",
+        "decimal.js": "^10.5.0",
+        "html-encoding-sniffer": "^4.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "is-potential-custom-element-name": "^1.0.1",
+        "nwsapi": "^2.2.16",
+        "parse5": "^7.2.1",
+        "rrweb-cssom": "^0.8.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^5.1.1",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^7.0.0",
+        "whatwg-encoding": "^3.1.1",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.1.1",
+        "ws": "^8.18.0",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/jsdom/node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/jsdom/node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/json-bigint": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
@@ -1823,6 +3245,26 @@
       "dev": true,
       "license": "Apache-2.0"
     },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/marked": {
       "version": "18.0.11",
       "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.11.tgz",
@@ -1883,6 +3325,13 @@
         "url": "https://opencollective.com/node-fetch"
       }
     },
+    "node_modules/nwsapi": {
+      "version": "2.2.28",
+      "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.28.tgz",
+      "integrity": "sha512-IlVB7OS7qrOsVYlpnFIkETjMwT9jwvmocJmmM+GZU/PAB3uGi9Ezd7vcWhWBUnSc0ya4ppmQITOyP1ez9gg8cg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/openai": {
       "version": "7.19.0",
       "resolved": "https://registry.npmjs.org/openai/-/openai-7.19.0.tgz",
@@ -1935,6 +3384,19 @@
         "node": ">=8"
       }
     },
+    "node_modules/parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
     "node_modules/partial-json": {
       "version": "0.1.7",
       "resolved": "https://registry.npmjs.org/partial-json/-/partial-json-0.1.7.tgz",
@@ -1994,6 +3456,16 @@
         }
       }
     },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/quickjs-wasi": {
       "version": "3.6.2",
       "resolved": "https://registry.npmjs.org/quickjs-wasi/-/quickjs-wasi-3.6.2.tgz",
@@ -2001,6 +3473,33 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
     "node_modules/retry": {
       "version": "0.13.1",
       "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
@@ -2011,6 +3510,13 @@
         "node": ">= 4"
       }
     },
+    "node_modules/rrweb-cssom": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+      "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/safe-buffer": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
@@ -2032,6 +3538,36 @@
       ],
       "license": "MIT"
     },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -2066,6 +3602,59 @@
         "fast-sha256": "^1.3.0"
       }
     },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tldts": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz",
+      "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^6.1.86"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz",
+      "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tough-cookie": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",
+      "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^6.1.32"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+      "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/ts-algebra": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
@@ -2127,6 +3716,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/web-streams-polyfill": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
@@ -2137,6 +3739,54 @@
         "node": ">= 8"
       }
     },
+    "node_modules/webidl-conversions": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/whatwg-encoding": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+      "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "0.6.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "14.2.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^5.1.0",
+        "webidl-conversions": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -2175,6 +3825,23 @@
         }
       }
     },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/yaml": {
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
@@ -2190,6 +3857,16 @@
       "funding": {
         "url": "https://github.com/sponsors/eemeli"
       }
+    },
+    "node_modules/zod": {
+      "version": "4.6.5",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.5.tgz",
+      "integrity": "sha512-v5l/aFXZQeai4awLbOpSoHecE9UiMrnfx75tEXLjNonXVARxQ5mOeipTjROUchszUNCqnE+hqAMujRsRHsut2Q==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index eea2534..3ca8962 100644
--- a/package.json
+++ b/package.json
@@ -40,11 +40,14 @@
     "prepack": "npm run build",
     "build:pi": "npm run build --workspace @chrok/pi-braid",
     "test:package": "node scripts/package-smoke.mjs",
-    "verify": "npm run check && npm test && npm run check:pi && npm run test:pi && npm run examples && npm run test:package",
+    "verify": "npm run check && npm test && npm run check:pi && npm run test:pi && npm run check:dsh && npm run test:dsh && npm run examples && npm run test:package",
     "examples": "tsx examples/basic.ts && tsx examples/code-review.ts && tsx examples/failure-handling.ts && tsx examples/custom-runner.ts && tsx examples/execution-control.ts",
     "bench": "npm run build && node --expose-gc scripts/benchmark.mjs",
     "demo:panel": "tsx scripts/panel-demo.ts",
-    "test:pi:live": "npm run build:pi && node integrations/pi/test/live/run.mjs"
+    "test:pi:live": "npm run build:pi && node integrations/pi/test/live/run.mjs",
+    "check:dsh": "npm run build && npm run check --workspace @chrok/dsh-braid",
+    "test:dsh": "npm run build && npm test --workspace @chrok/dsh-braid",
+    "build:dsh": "npm run build --workspace @chrok/dsh-braid"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -78,6 +81,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "workspaces": [
-    "integrations/pi"
+    "integrations/pi",
+    "integrations/dsh"
   ]
 }
diff --git a/scripts/build.mjs b/scripts/build.mjs
index 2c91d94..e36a030 100644
--- a/scripts/build.mjs
+++ b/scripts/build.mjs
@@ -4,10 +4,11 @@ import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 
 const root = fileURLToPath(new URL("../", import.meta.url));
-const pi = process.argv[2] === "pi";
-const directory = pi ? resolve(root, "integrations/pi") : root;
-// Pi resolves the current core through the development-only workspace link.
-if (pi) {
+const integration = process.argv[2];
+if (integration && !["pi", "dsh"].includes(integration)) throw new Error(`Unknown integration: ${integration}`);
+const directory = integration ? resolve(root, "integrations", integration) : root;
+// Each integration resolves the current core through the development-only workspace link.
+if (integration) {
   const core = spawnSync(process.execPath, [fileURLToPath(import.meta.url)], { stdio: "inherit" });
   if (core.error) throw core.error;
   if (core.status !== 0) process.exit(core.status ?? 1);
@@ -19,4 +20,9 @@ const result = spawnSync(process.execPath, [
 ], { cwd: root, stdio: "inherit" });
 if (result.error) throw result.error;
 if (result.status !== 0) process.exit(result.status ?? 1);
-if (pi) copyFileSync(resolve(root, "LICENSE"), resolve(directory, "LICENSE"));
+if (integration === "dsh") {
+  const client = spawnSync(process.execPath, [resolve(directory, "build-client.mjs")], { cwd: root, stdio: "inherit" });
+  if (client.error) throw client.error;
+  if (client.status !== 0) process.exit(client.status ?? 1);
+}
+if (integration) copyFileSync(resolve(root, "LICENSE"), resolve(directory, "LICENSE"));
diff --git a/scripts/check-release.mjs b/scripts/check-release.mjs
index eb50cc2..c21b78d 100644
--- a/scripts/check-release.mjs
+++ b/scripts/check-release.mjs
@@ -1,8 +1,10 @@
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 const core = JSON.parse(readFileSync(new URL("../package.json", import.meta.url)));
-const pi = JSON.parse(readFileSync(new URL("../integrations/pi/package.json", import.meta.url)));
-assert.equal(pi.version, core.version, "Core and Pi must release the same version");
 assert.match(core.version, /^\d+\.\d+\.\d+$/, "This workflow publishes stable versions only");
-assert.equal(process.env.RELEASE_TAG, `v${core.version}`, "Release tag must match both package manifests");
-assert.equal(pi.dependencies[core.name], core.version, "Pi must depend on the exact released core version");
+assert.equal(process.env.RELEASE_TAG, `v${core.version}`, "Release tag must match all package manifests");
+for (const integration of core.workspaces) {
+  const manifest = JSON.parse(readFileSync(new URL(`../${integration}/package.json`, import.meta.url)));
+  assert.equal(manifest.version, core.version, `${manifest.name} must release with core`);
+  assert.equal(manifest.dependencies[core.name], core.version, `${manifest.name} must depend on the exact core version`);
+}
diff --git a/scripts/package-smoke.mjs b/scripts/package-smoke.mjs
index 2a9ec3a..a7eda2e 100644
--- a/scripts/package-smoke.mjs
+++ b/scripts/package-smoke.mjs
@@ -7,6 +7,8 @@ import { spawn } from "node:child_process";
 import { createServer } from "node:http";
 
 const root = fileURLToPath(new URL("../", import.meta.url));
+const dshRoot = join(root, "integrations/dsh");
+const dshManifest = JSON.parse(readFileSync(join(dshRoot, "package.json"), "utf8"));
 const piRoot = join(root, "integrations/pi");
 const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
 const piManifest = JSON.parse(readFileSync(join(piRoot, "package.json"), "utf8"));
@@ -33,12 +35,26 @@ let registry;
 
 try {
   // A removed source file must never survive a rebuild into a published package.
-  for (const cwd of [root, piRoot]) {
+  for (const cwd of [root, piRoot, dshRoot]) {
     mkdirSync(join(cwd, "dist"), { recursive: true });
     writeFileSync(join(cwd, "dist/__stale_build_sentinel.js"), "throw new Error('stale build');\n");
   }
   const core = await pack(root);
   const pi = await pack(piRoot);
+  const dsh = await pack(dshRoot);
+  assert.ok(dsh.files.some(file => file.path === "cordis.patch.yml"));
+  assert.ok(dsh.files.some(file => file.path === "dist/index.d.ts"));
+  assert.ok(dsh.files.some(file => file.path === "dist/client.js"));
+  assert.ok(dsh.files.some(file => file.path === "dist/client/index.d.ts"));
+  assert.equal(dshManifest.dsh.client.platform, "web");
+  assert.equal(dshManifest.exports["./client"].default, "./dist/client.js");
+  assert.ok(!dsh.files.some(file => file.path.includes("__stale_build_sentinel")));
+  assert.equal(dshManifest.version, manifest.version);
+  assert.equal(dshManifest.dependencies[manifest.name], manifest.version);
+  assert.equal(dshManifest.dsh.bundle.patch, "./cordis.patch.yml");
+  for (const file of dsh.files.filter(file => file.path.endsWith(".js"))) {
+    assert.ok(!/earendil|integrations\/pi|\.\.\/\.\.\/src/.test(readFileSync(join(dshRoot, file.path), "utf8")), "DSH must be independent of Pi and checkout sources");
+  }
   const expectedCore = readdirSync(join(root, "src"), { recursive: true })
     .filter(path => path.endsWith(".ts"))
     .flatMap(path => ["dist/" + path.replaceAll("\\", "/").replace(/\.ts$/, ".js"), "dist/" + path.replaceAll("\\", "/").replace(/\.ts$/, ".d.ts")]);
@@ -152,7 +168,52 @@ try {
     parseFinishMergeArguments({ dispositions: [{ executionId: 'a', disposition: 'discarded', reason: 'test' }] }, ['a']);
   `);
   await run([join(root, "node_modules/typescript/bin/tsc"), "--noEmit", "--strict", "--skipLibCheck", "--target", "ES2022", "--module", "NodeNext", "--moduleResolution", "NodeNext", "check.mts"], consumer);
-  console.log(`Package smoke passed: ${core.id} (${core.entryCount} files), ${pi.id} (${pi.entryCount} files). Public imports, types, a Pi background job, and clean builds verified outside the checkout.`);
+  const dshConsumer = join(temp, "dsh-consumer");
+  mkdirSync(dshConsumer);
+  writeFileSync(join(dshConsumer, "package.json"), JSON.stringify({ private: true, type: "module" }));
+  const dshPeers = Object.fromEntries(Object.keys(dshManifest.peerDependencies).map(name => [name, dshManifest.devDependencies[name]]));
+  await run([npm, "install", "--no-audit", "--no-fund", `--@chrok:registry=${origin}`, "--cache", join(temp, "npm-cache"), join(temp, dsh.filename), ...Object.entries(dshPeers).map(([name, version]) => `${name}@${version}`)], dshConsumer);
+  writeFileSync(join(dshConsumer, "check.mjs"), `
+    import assert from 'node:assert/strict';
+    import { Context } from '@deepseek-ai/cordis';
+    import SystemPrompt from '@deepseek-ai/dsh-system-prompt';
+    import ToolRuntime from '@deepseek-ai/dsh-tools';
+    import { apply, name, inject } from '@chrok/dsh-braid';
+    import { readFileSync } from 'node:fs';
+    import { createRequire } from 'node:module';
+    import { createBraidTools } from './node_modules/@chrok/dsh-braid/dist/tools.js';
+    import { BraidJobs } from './node_modules/@chrok/dsh-braid/dist/jobs.js';
+    assert.equal(name, 'braid'); assert.equal(typeof apply, 'function'); assert.ok(inject.includes('llm'));
+    // The browser entry is a loader factory, never a Node/ESM import or a second React runtime.
+    let factory;
+    new Function('window', readFileSync(createRequire(import.meta.url).resolve('@chrok/dsh-braid/client'), 'utf8'))({
+      __ModuleLoader__: { load(entry) { assert.equal(entry.id, '@chrok/dsh-braid'); factory = entry.factory; } },
+    });
+    assert.equal(typeof factory, 'function');
+    const browserPlugin = factory(id => {
+      assert.ok(['react', 'react/jsx-runtime'].includes(id), 'Unexpected browser dependency: ' + id);
+      return {};
+    });
+    assert.equal(typeof browserPlugin.apply, 'function');
+    const ctx = new Context();
+    await ctx.plugin(SystemPrompt); await ctx.plugin(ToolRuntime, { mode: 'native' });
+    const jobs = new BraidJobs({ async *stream() {
+      yield { type: 'text-delta', index: 0, text: 'packed DSH worker' };
+      yield { type: 'finish', reason: { kind: 'stop' } };
+    } });
+    try {
+      for (const tool of createBraidTools(() => jobs, () => ({}))) ctx.tools.register(tool);
+      assert.equal(ctx.tools.schemas().length, 5);
+      const job = jobs.start({ goal: 'packed', nodes: [{ type: 'execute', id: 'a', prompt: 'test' }], edges: [] }, {}, { cwd: process.cwd(), model: 'fake/model' });
+      await jobs.wait(job.handle);
+      assert.equal(jobs.getNode(job.handle, 'a').output, 'packed DSH worker');
+      assert.equal(jobs.get(job.handle).status, 'completed');
+    } finally { await jobs.dispose(); await ctx.fiber.dispose(); }
+  `);
+  await run(["check.mjs"], dshConsumer);
+  writeFileSync(join(dshConsumer, "check.mts"), `import { apply, name, inject } from '@chrok/dsh-braid'; void apply; void name; void inject;`);
+  await run([join(root, "node_modules/typescript/bin/tsc"), "--noEmit", "--strict", "--skipLibCheck", "--target", "ES2022", "--module", "NodeNext", "--moduleResolution", "NodeNext", "check.mts"], dshConsumer);
+  console.log(`Package smoke passed: ${core.id} (${core.entryCount} files), ${pi.id} (${pi.entryCount} files), ${dsh.id} (${dsh.entryCount} files). Public imports, types, Pi/DSH background jobs, and clean builds verified outside the checkout.`);
 } finally {
   if (registry) await new Promise((resolve, reject) => registry.close(error => error ? reject(error) : resolve()));
   rmSync(temp, { recursive: true, force: true });
diff --git a/scripts/publish.mjs b/scripts/publish.mjs
index e5ecf3b..6d70e2f 100644
--- a/scripts/publish.mjs
+++ b/scripts/publish.mjs
@@ -8,7 +8,8 @@ const root = fileURLToPath(new URL("../", import.meta.url));
 // Resolve the active npm executable without shell interpolation.
 const npm = process.env.npm_execpath ?? execFileSync(process.platform === "win32" ? "where.exe" : "which", ["npm"], { encoding: "utf8" }).trim().split(/\r?\n/)[0];
 const gitHead = execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim();
-for (const cwd of [root, join(root, "integrations/pi")]) {
+const workspaces = JSON.parse(readFileSync(join(root, "package.json"))).workspaces;
+for (const cwd of [root, ...workspaces.map(workspace => join(root, workspace))]) {
   const { name, version } = JSON.parse(readFileSync(join(cwd, "package.json")));
   const args = [npm, "view", `${name}@${version}`, "version", "--json", "--registry=https://registry.npmjs.org"];
   const existing = spawnSync(process.execPath, args, { encoding: "utf8" });