diff --git a/README.md b/README.md index f2557bc..c1d6ff4 100644 --- a/README.md +++ b/README.md @@ -1,329 +1,138 @@ # @versatly/workgraph -Agent-first workgraph workspace for multi-agent collaboration. - -`@versatly/workgraph` is the standalone coordination core for multi-agent execution. It focuses only on: - -- Dynamic primitive registry (`thread`, `space`, `decision`, `lesson`, `fact`, `agent`, plus custom types) -- Append-only event ledger (`.workgraph/ledger.jsonl`) -- Ledger claim index (`.workgraph/ledger-index.json`) for fast ownership queries -- Tamper-evident ledger hash-chain (`.workgraph/ledger-chain.json`) -- Markdown-native primitive store -- Thread lifecycle coordination (claim/release/block/unblock/done/decompose) -- Space-scoped thread scheduling (`--space`) -- Generated markdown command center (`workgraph command-center`) -- Native skill primitive lifecycle (`workgraph skill write/load/propose/promote`) -- Primitive-registry manifest + auto-generated `.base` files -- Orientation loop commands (`workgraph status/brief/checkpoint/intake`) -- Deterministic context lenses (`workgraph lens list/show`) for real-time situational awareness -- Multi-filter primitive query (`workgraph query ...`) -- Core + QMD-compatible keyword search (`workgraph search ...`) -- Obsidian Kanban board generation/sync (`workgraph board generate|sync`) -- Wiki-link graph intelligence (`workgraph graph index|hygiene|neighborhood|impact|context|edges|export`) -- Policy party registry and sensitive transition gates -- Programmatic dispatch contract (`workgraph dispatch ...`) with explicit status transitions, lease heartbeats, and timeout-aware adapter cancellation -- Programmable trigger engine with composable conditions, idempotent dispatch bridging, and safety-gated high-impact actions -- MCP write surface for trigger CRUD/fire, dispatch, autonomy, and mission orchestration -- JSON-friendly CLI for agent orchestration - -No memory-category scaffolding, no qmd dependency, no observational-memory pipeline. +`@versatly/workgraph` is a focused multi-agent coordination workspace built around four pillars: -## Install - -```bash -npm install @versatly/workgraph -``` +1. **context graph** +2. **thread collaboration** +3. **MCP exposure** +4. **actor registration** -Or global CLI: +The codebase has been narrowed to favor a smaller, more coherent system over a broad control-plane product surface. -```bash -npm install -g @versatly/workgraph -``` +## What it does -## Agent-first CLI +- stores coordination primitives as markdown with frontmatter +- maintains an append-only ledger for thread and actor activity +- models collaboration through: + - `thread` + - `conversation` + - `plan-step` + - thread-scoped context entries +- exposes read/write/collaboration operations over MCP +- supports actor registration, registration requests/reviews, credentials, and presence heartbeats +- builds context graph views from registry-backed primitives and wiki-link graph analysis -```bash -# Initialize pure workgraph workspace -workgraph init ./wg-space --json +## Workspace packages -# Define custom primitive -workgraph primitive define command-center \ - --description "Agent ops cockpit" \ - --fields owner:string \ - --fields panel_refs:list \ - --json - -# Create and route thread work -workgraph thread create "Ship command center" \ - --goal "Production-ready multi-agent command center" \ - --priority high \ - --actor agent-lead \ - --json - -workgraph thread next --claim --actor agent-worker --json -workgraph status --json -workgraph brief --actor agent-worker --json -workgraph lens list --json -workgraph lens show my-work --actor agent-worker --json -workgraph query --type thread --status open --limit 10 --json -workgraph search "auth" --mode auto --json -workgraph checkpoint "Completed API layer" --next "implement tests" --actor agent-worker --json -workgraph board generate --output "ops/Workgraph Board.md" --json -workgraph graph hygiene --json -workgraph graph neighborhood ship-feature --depth 2 --json -workgraph graph impact ship-feature --json -workgraph graph context ship-feature --budget 2000 --json -workgraph graph edges ship-feature --json -workgraph graph export ship-feature --depth 2 --format md --json -workgraph dispatch create "Review blockers" --actor agent-lead --json -workgraph dispatch mark run_123 --status succeeded --output "Review complete" --actor agent-lead --json -workgraph dispatch create-execute "Close all ready threads in platform space" \ - --actor agent-lead \ - --agents agent-a,agent-b,agent-c \ - --space spaces/platform \ - --json -workgraph trigger fire triggers/escalate-blocked.md --event-key "thread-blocked-001" --actor agent-lead --json -workgraph onboarding update onboarding/onboarding-for-agent-architect.md --status paused --actor agent-lead --json -workgraph mcp serve -w /path/to/workspace --actor agent-ops --read-only -workgraph ledger show --count 20 --json -workgraph command-center --output "ops/Command Center.md" --json -workgraph bases generate --refresh-registry --json -``` +- `packages/kernel` — context graph, thread collaboration, auth, and registration domain logic +- `packages/cli` — focused CLI over the retained kernel workflows +- `packages/mcp-server` — stdio + HTTP MCP server +- `packages/sdk` — curated public exports -### JSON contract - -All commands support `--json` and emit: - -- Success: `{ "ok": true, "data": ... }` -- Failure: `{ "ok": false, "error": "..." }` (non-zero exit) - -This is intended for robust parsing by autonomous agents. - -### Monorepo layout - -The repository is now fully organized as a pnpm workspaces monorepo while preserving -the published `@versatly/workgraph` package compatibility surface. - -Legacy root `src/` compatibility wrappers have been removed. Package-owned modules -under `packages/*` are the only implementation source of truth. - -Key workspace packages: - -- `packages/kernel` — domain state machine and coordination core -- `packages/cli` — command surface over kernel workflows -- `packages/sdk` — curated public package surface -- `packages/control-api` — REST, SSE, webhook gateway, and HTTP MCP hosting -- `packages/runtime-adapter-core` — reusable dispatch contracts and generic transports -- `packages/adapter-claude-code` — Claude Code-specific execution adapter -- `packages/adapter-cursor-cloud` — Cursor Cloud-style execution adapter -- `packages/mcp-server` — stdio + HTTP MCP transport and tool registration -- `packages/testkit` — contract fixtures and schema validation helpers -- `packages/search-qmd-adapter` — search compatibility seam -- `packages/obsidian-integration` — editor-facing projections and exports -- `packages/skills` — package-level skill distribution surface - -Package ownership and layering are documented in `docs/PACKAGE_BOUNDARIES.md`. - -Migration notes: see `docs/MIGRATION.md`. -Live workspace repair runbook: see `docs/INVARIANT_REPAIR_PLAYBOOK.md`. -Realtime control-api SSE contract: see `docs/SSE_EVENTS.md`. -Current architecture execution roadmap: see `docs/ARCHITECTURE_ROADMAP.md`. - -### Reliability and autonomy hardening - -Recent hardening focused on making unattended operation safer rather than just -adding more commands: - -- dispatch runs now maintain leases while executing and propagate timeout/cancel - intent into adapter execution contracts -- autonomy cycles now repair dispatch state, reconcile expired leases, recover - thread claim/reference drift, and run mission orchestration passes as part of - the same control loop -- trigger actions can now express composable boolean conditions (`all` / `any` - / `not`) and route risky `shell` / `update-primitive` actions through safety - rails -- MCP now exposes trigger create/update/delete/fire tools in addition to the - trigger engine cycle surface - -### Development workflow (contributors) +## Install ```bash -pnpm install -pnpm run ci +npm install @versatly/workgraph ``` -The default `pnpm run test` script now uses `scripts/run-tests.mjs`, a hardened -Vitest wrapper that enforces deterministic process exit in CI (especially on -Windows where lingering `esbuild` children can keep `vitest run` alive after -all test files report complete). - -- `pnpm run test`: hardened runner (recommended for CI/local reliability) -- `pnpm run test:vitest`: raw Vitest invocation (useful for debugging Vitest itself) - -Optional tuning knobs: - -- `WORKGRAPH_TEST_EXIT_GRACE_MS`: grace period after all file results are - observed before forced process-tree cleanup (default `15000`) -- `WORKGRAPH_TEST_MAX_RUNTIME_MS`: hard timeout for the full run (default - `1200000`) - -### Demo vault generator - -Generate the large Obsidian demo workspace used for stress-testing: +Global CLI: ```bash -pnpm run demo:workspace -pnpm run demo:obsidian-setup +npm install -g @versatly/workgraph ``` -Runbook: `docs/OBSIDIAN_DEMO.md`. - -### Space-scoped scheduling +## Quick start ```bash -workgraph thread create "Implement auth middleware" \ - --goal "Protect private routes" \ - --space spaces/backend.md \ - --actor agent-api \ - --json - -workgraph thread list --space spaces/backend --ready --json -workgraph thread next --space spaces/backend --claim --actor agent-api --json +pnpm install +pnpm run build ``` -### Auto-generate `.base` files from primitive registry +Initialize a workspace: ```bash -# Sync .workgraph/primitive-registry.yaml -workgraph bases sync-registry --json - -# Generate canonical primitive .base files -workgraph bases generate --json - -# Include non-canonical (agent-defined) primitives -workgraph bases generate --all --refresh-registry --json +workgraph init ./wg-space --json ``` -### Graph intelligence workflows +Create and work a thread: ```bash -# Build/refresh graph index first (optional but useful) -workgraph graph index --json - -# Multi-hop neighborhood around a primitive slug/path -workgraph graph neighborhood ship-feature --depth 2 --json - -# Reverse-link blast radius (what references this primitive) -workgraph graph impact ship-feature --json - -# Auto-assemble markdown context bundle within token budget (chars/4) -workgraph graph context ship-feature --budget 2000 --json - -# Inspect typed relationship edges for one primitive -workgraph graph edges ship-feature --json +workgraph thread create "Ship collaboration flow" \ + --goal "Implement the retained MCP collaboration surface" \ + --actor agent-lead \ + --json -# Export a markdown subgraph for handoff/sharing -workgraph graph export ship-feature --depth 2 --format md --json +workgraph thread next --claim --actor agent-worker --json +workgraph thread done threads/ship-collaboration-flow.md \ + --actor agent-worker \ + --output "Completed https://github.com/Versatly/workgraph/pull/123" \ + --json ``` -### Ledger query, blame, and tamper detection +Explore the context graph: ```bash -workgraph ledger query --actor agent-worker --op claim --json -workgraph ledger blame threads/auth.md --json -workgraph ledger verify --strict --json +workgraph graph index --json +workgraph graph neighborhood ship-collaboration-flow --depth 2 --json +workgraph graph context ship-collaboration-flow --budget 2000 --json +workgraph query --type thread --status open --json +workgraph search "registration" --json ``` -### Native skill lifecycle (shared vault / Tailscale) +Register and review actors: ```bash -# with shared vault env (e.g. tailscale-mounted path) -export WORKGRAPH_SHARED_VAULT=/mnt/tailscale/company-workgraph - -workgraph skill write "workgraph-manual" \ - --body-file ./skills/workgraph-manual.md \ - --owner agent-architect \ - --actor agent-architect \ +workgraph agent request agent-1 \ + --role roles/contributor.md \ + --actor agent-1 \ --json -workgraph skill propose workgraph-manual --actor agent-reviewer --space spaces/platform --json -workgraph skill promote workgraph-manual --actor agent-lead --json -workgraph skill load workgraph-manual --json -workgraph skill list --updated-since 2026-02-27T00:00:00.000Z --json -workgraph skill history workgraph-manual --limit 10 --json -workgraph skill diff workgraph-manual --json -``` - -### Optional Clawdapus integration - -List supported optional integrations: +workgraph agent review agent-registration-requests/agent-1-123.md \ + --decision approved \ + --actor admin-reviewer \ + --json -```bash -workgraph integration list --json +workgraph agent heartbeat agent-1 --status online --actor agent-1 --json ``` -Install by integration ID (extensible pattern for future integrations): +Run MCP: ```bash -workgraph integration install clawdapus \ - --actor agent-architect \ - --json -``` +workgraph mcp serve -w ./wg-space --actor agent-ops -Refresh from upstream later (or use the `integration clawdapus` alias): - -```bash -workgraph integration install clawdapus --force --actor agent-architect --json +workgraph serve -w ./wg-space --actor agent-ops --port 8787 ``` -## Legacy memory stacks vs Workgraph primitives +## JSON contract -`@versatly/workgraph` is **execution coordination only**. +All CLI commands support `--json`: -- Use it for: ownership, decomposition, dependency management, typed coordination primitives. -- Do not use it for: long-term memory categories (`decisions/`, `people/`, `projects/` memory workflows), qmd semantic retrieval pipelines, observer/reflector memory compression. +- success: `{ "ok": true, "data": ... }` +- failure: `{ "ok": false, "error": "..." }` -This split keeps the workgraph package focused, portable, and shell-agent-native. - -## Migrating from mixed memory/workgraph vaults - -1. Initialize a clean workgraph workspace: - ```bash - workgraph init ./coordination-space --json - ``` -2. Recreate only coordination entities as workgraph primitives (`thread`, `space`, custom types). -3. Move or archive memory-specific folders outside the coordination workspace. -4. Generate a control plane note for humans/agents: - ```bash - workgraph command-center --output "ops/Command Center.md" --json - ``` +This contract is intended for reliable automation. ## Programmatic API ```ts -import { registry, thread, store, ledger, workspace } from '@versatly/workgraph'; +import { registry, thread, workspace } from '@versatly/workgraph'; workspace.initWorkspace('/tmp/wg'); -registry.defineType('/tmp/wg', 'milestone', 'Release checkpoint', { - thread_refs: { type: 'list', default: [] }, - target_date: { type: 'date' }, +registry.defineType('/tmp/wg', 'note', 'Shared context note', { + context_refs: { type: 'list', default: [] }, }, 'agent-architect'); -const t = thread.createThread('/tmp/wg', 'Build Auth', 'JWT and refresh flow', 'agent-lead'); +const t = thread.createThread('/tmp/wg', 'Build auth', 'Ship actor registration flow', 'agent-lead'); thread.claim('/tmp/wg', t.path, 'agent-worker'); -thread.done('/tmp/wg', t.path, 'agent-worker', 'Shipped'); ``` -## Publish (package-only) - -From this directory: +## Development ```bash -pnpm run ci -pnpm publish --access public +pnpm run typecheck +pnpm run test +pnpm run build ``` -## Skill guide - -See `SKILL.md` for the full operational playbook optimized for autonomous agents (including pi-mono compatibility guidance). +The repository uses the hardened `scripts/run-tests.mjs` wrapper for reliable Vitest exits. diff --git a/apps/web-control-plane/README.md b/apps/web-control-plane/README.md deleted file mode 100644 index 81ad5a1..0000000 --- a/apps/web-control-plane/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# WorkGraph Web Control Plane (Planned) - -This app is intentionally scaffolded as a placeholder for later phases. diff --git a/apps/web-control-plane/app.js b/apps/web-control-plane/app.js deleted file mode 100644 index 5e6475e..0000000 --- a/apps/web-control-plane/app.js +++ /dev/null @@ -1,43 +0,0 @@ -async function loadProjection(name) { - const response = await fetch(`/api/projections/${name}`); - if (!response.ok) { - throw new Error(`Failed to load projection ${name}: ${response.status}`); - } - const body = await response.json(); - if (!body.ok) { - throw new Error(body.error || `Projection ${name} returned an error.`); - } - return body.projection; -} - -function renderJson(target, value) { - target.textContent = JSON.stringify(value, null, 2); -} - -function renderSummaryCards(target, summary) { - target.innerHTML = ''; - for (const [key, value] of Object.entries(summary || {})) { - const card = document.createElement('div'); - card.className = 'card'; - card.innerHTML = `

${key}

${String(value)}

`; - target.appendChild(card); - } -} - -async function boot() { - const root = document.getElementById('projection-root'); - const summaryRoot = document.getElementById('projection-summary'); - const projectionName = document.body.dataset.projection; - if (!root || !summaryRoot || !projectionName) return; - try { - const projection = await loadProjection(projectionName); - renderSummaryCards(summaryRoot, projection.summary || projection.projections || {}); - renderJson(root, projection); - } catch (error) { - root.textContent = error instanceof Error ? error.message : String(error); - } -} - -window.addEventListener('DOMContentLoaded', () => { - void boot(); -}); diff --git a/apps/web-control-plane/autonomy-health.html b/apps/web-control-plane/autonomy-health.html deleted file mode 100644 index 5437381..0000000 --- a/apps/web-control-plane/autonomy-health.html +++ /dev/null @@ -1,14 +0,0 @@ - - - - - - Autonomy Health - - - - -
← Control Plane

Autonomy Health

- 

-  
-
diff --git a/apps/web-control-plane/federation-status.html b/apps/web-control-plane/federation-status.html
deleted file mode 100644
index c160e7b..0000000
--- a/apps/web-control-plane/federation-status.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-  
-    
-    
-    Federation Status
-    
-    
-  
-  
-    
← Control Plane
Federation Status

-    

-  
-
diff --git a/apps/web-control-plane/index.html b/apps/web-control-plane/index.html
deleted file mode 100644
index 172f9c5..0000000
--- a/apps/web-control-plane/index.html
+++ /dev/null
@@ -1,26 +0,0 @@
-
-
-  
-    
-    
-    WorkGraph Control Plane
-    
-  
-  
-    

-      
WorkGraph Operator Control Plane

-      
Operator-facing projections for dispatch, transport, federation, triggers, autonomy, and missions.

-    

-    

-      

-        
Run Health
Active runs, stale runs, and failed reconciliations.

-        
Risk Dashboard
Blocked threads, escalations, and policy violations.

-        
Mission Progress
Mission completion and milestones.

-        
Transport Health
Outbox depth, dead-letter state, and delivery success.

-        
Federation Status
Remote workspace compatibility and sync status.

-        
Trigger Health
Trigger states, cooldowns, and errors.

-        
Autonomy Health
Autonomy daemon status and heartbeat.

-      

-    

-  
-
diff --git a/apps/web-control-plane/mission-progress.html b/apps/web-control-plane/mission-progress.html
deleted file mode 100644
index b4df69d..0000000
--- a/apps/web-control-plane/mission-progress.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-  
-    
-    
-    Mission Progress
-    
-    
-  
-  
-    
← Control Plane
Mission Progress

-    

-  
-
diff --git a/apps/web-control-plane/package.json b/apps/web-control-plane/package.json
deleted file mode 100644
index 38b0125..0000000
--- a/apps/web-control-plane/package.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "name": "@versatly/workgraph-web-control-plane",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module"
-}
diff --git a/apps/web-control-plane/risk-dashboard.html b/apps/web-control-plane/risk-dashboard.html
deleted file mode 100644
index 6c4450b..0000000
--- a/apps/web-control-plane/risk-dashboard.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-  
-    
-    
-    Risk Dashboard
-    
-    
-  
-  
-    
← Control Plane
Risk Dashboard

-    

-  
-
diff --git a/apps/web-control-plane/run-health.html b/apps/web-control-plane/run-health.html
deleted file mode 100644
index 138a88e..0000000
--- a/apps/web-control-plane/run-health.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-  
-    
-    
-    Run Health
-    
-    
-  
-  
-    
← Control Plane
Run Health

-    

-  
-
diff --git a/apps/web-control-plane/style.css b/apps/web-control-plane/style.css
deleted file mode 100644
index 98b630f..0000000
--- a/apps/web-control-plane/style.css
+++ /dev/null
@@ -1,49 +0,0 @@
-body {
-  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-  margin: 0;
-  background: #0b1020;
-  color: #eef2ff;
-}
-
-a {
-  color: #93c5fd;
-}
-
-header, main {
-  max-width: 1200px;
-  margin: 0 auto;
-  padding: 24px;
-}
-
-.cards {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
-  gap: 16px;
-}
-
-.card {
-  background: #16203a;
-  border: 1px solid #334155;
-  border-radius: 12px;
-  padding: 16px;
-}
-
-.nav {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 12px;
-  margin-bottom: 24px;
-}
-
-pre {
-  background: #020617;
-  border: 1px solid #334155;
-  border-radius: 12px;
-  padding: 16px;
-  overflow: auto;
-  white-space: pre-wrap;
-}
-
-.muted {
-  color: #94a3b8;
-}
diff --git a/apps/web-control-plane/transport-health.html b/apps/web-control-plane/transport-health.html
deleted file mode 100644
index 283d695..0000000
--- a/apps/web-control-plane/transport-health.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-  
-    
-    
-    Transport Health
-    
-    
-  
-  
-    
← Control Plane
Transport Health

-    

-  
-
diff --git a/apps/web-control-plane/trigger-health.html b/apps/web-control-plane/trigger-health.html
deleted file mode 100644
index 2b3c92c..0000000
--- a/apps/web-control-plane/trigger-health.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-  
-    
-    
-    Trigger Health
-    
-    
-  
-  
-    
← Control Plane
Trigger Health

-    

-  
-
diff --git a/examples/multi-agent-showcase/README.md b/examples/multi-agent-showcase/README.md
deleted file mode 100644
index 8d9eb2f..0000000
--- a/examples/multi-agent-showcase/README.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# OBJ-09: Signature Multi-Agent Showcase
-
-This showcase demonstrates a full WorkGraph collaboration lifecycle with three agents:
-
-- `governance-admin` (governance + approvals)
-- `agent-intake` (triage + routing)
-- `agent-builder` (implementation)
-- `agent-reviewer` (self-assembly + QA closure)
-
-The flow is intentionally end-to-end and reproducible from a fresh workspace. Every WorkGraph CLI invocation uses `--json`.
-
-## What this demonstrates
-
-1. **Agent registration and governance**
-   - Bootstrap admin registration
-   - Approval-based registration requests for agents
-   - Credential issuance and heartbeat publication
-
-2. **Thread lifecycle and plan-step coordination**
-   - Multi-thread objective decomposition
-   - Conversation and plan-step creation
-   - Claim/start/progress/done transitions across multiple actors
-
-3. **Self-assembly**
-   - Capability advertisement + requirements matching
-   - `assembleAgent()` claims the next suitable thread
-   - Existing plan-step is automatically activated for the assembled agent
-
-4. **Trigger -> run -> evidence loop**
-   - Trigger creation with a structured `dispatch-run` action
-   - Trigger engine cycle executes runs automatically
-   - Dispatch run evidence chain is validated from CLI output
-   - Ledger hash-chain integrity is verified
-
-## Run it
-
-From repo root:
-
-```bash
-node examples/multi-agent-showcase/run.mjs --json
-```
-
-Optional arguments:
-
-- `--workspace `: use a specific workspace directory
-- `--skip-build`: skip `pnpm run build` (useful in tests)
-- `--json`: emit machine-readable summary only
-
-Unix shells can still use the wrapper:
-
-```bash
-bash examples/multi-agent-showcase/run.sh --json
-```
-
-## Script breakdown
-
-- `scripts/01-governance.mjs`
-  - Initializes workspace
-  - Registers `governance-admin` with bootstrap token
-  - Runs request/review approval flow for all collaborating agents
-  - Outputs issued API keys and governance snapshot
-
-- `scripts/02-collaboration.mjs`
-  - Creates threads, conversation, and plan-steps
-  - Drives intake + builder thread lifecycle transitions
-  - Runs self-assembly for reviewer via SDK
-  - Completes reviewer plan-step and closes conversation
-
-- `scripts/03-trigger-loop.mjs`
-  - Creates active trigger via SDK with `dispatch-run` action
-  - Executes trigger engine loop with run execution
-  - Validates run status/evidence and ledger integrity
-
-- `scripts/run-showcase.mjs`
-  - Orchestrates all phases
-  - Collects rollup metrics and boolean capability checks
-  - Returns one final JSON report
-
-## Expected outcome
-
-The final JSON output contains:
-
-- `checks.governance`
-- `checks.selfAssemblyClaimedReviewerThread`
-- `checks.planStepCoordinated`
-- `checks.triggerRunEvidence`
-- `checks.ledgerActivity`
-
-When all checks are `true`, the showcase has completed successfully.
diff --git a/examples/multi-agent-showcase/run.mjs b/examples/multi-agent-showcase/run.mjs
deleted file mode 100644
index 2786aeb..0000000
--- a/examples/multi-agent-showcase/run.mjs
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { execFileSync } from 'node:child_process';
-
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const scriptPath = path.join(scriptDir, 'scripts', 'run-showcase.mjs');
-
-execFileSync('node', [scriptPath, ...process.argv.slice(2)], {
-  stdio: 'inherit',
-  env: process.env,
-});
diff --git a/examples/multi-agent-showcase/run.sh b/examples/multi-agent-showcase/run.sh
deleted file mode 100755
index 2dcb187..0000000
--- a/examples/multi-agent-showcase/run.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
-
-WORKSPACE=""
-SKIP_BUILD=0
-JSON_MODE=0
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --workspace|-w)
-      if [[ $# -lt 2 ]]; then
-        echo "Missing value for $1" >&2
-        exit 1
-      fi
-      WORKSPACE="$2"
-      shift 2
-      ;;
-    --skip-build)
-      SKIP_BUILD=1
-      shift
-      ;;
-    --json)
-      JSON_MODE=1
-      shift
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      echo "Usage: run.sh [--workspace ] [--skip-build] [--json]" >&2
-      exit 1
-      ;;
-  esac
-done
-
-if [[ -z "${WORKSPACE}" ]]; then
-  WORKSPACE="$(mktemp -d /tmp/workgraph-obj09-showcase-XXXXXX)"
-fi
-
-if [[ "${SKIP_BUILD}" -ne 1 ]]; then
-  echo "[obj-09] building repository artifacts..." >&2
-  (
-    cd "${REPO_ROOT}"
-    pnpm run build >/dev/null
-  )
-fi
-
-SHOWCASE_ARGS=(--workspace "${WORKSPACE}" --json)
-if [[ "${SKIP_BUILD}" -eq 1 ]]; then
-  SHOWCASE_ARGS+=(--skip-build)
-fi
-
-if [[ "${JSON_MODE}" -ne 1 ]]; then
-  echo "[obj-09] running showcase in ${WORKSPACE}" >&2
-fi
-
-node "${SCRIPT_DIR}/scripts/run-showcase.mjs" "${SHOWCASE_ARGS[@]}"
diff --git a/examples/multi-agent-showcase/scripts/01-governance.mjs b/examples/multi-agent-showcase/scripts/01-governance.mjs
deleted file mode 100755
index 7215647..0000000
--- a/examples/multi-agent-showcase/scripts/01-governance.mjs
+++ /dev/null
@@ -1,165 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'node:path';
-import {
-  ensureBuild,
-  logLine,
-  resolveRepoRoot,
-  resolveWorkspace,
-  runCliJson,
-} from './lib/demo-utils.mjs';
-
-const AGENTS = {
-  admin: 'governance-admin',
-  intake: 'agent-intake',
-  builder: 'agent-builder',
-  reviewer: 'agent-reviewer',
-};
-
-const roleByAgent = {
-  [AGENTS.intake]: 'roles/contributor.md',
-  [AGENTS.builder]: 'roles/contributor.md',
-  [AGENTS.reviewer]: 'roles/viewer.md',
-};
-
-async function main() {
-  const repoRoot = resolveRepoRoot(import.meta.url);
-  const resolved = resolveWorkspace(process.argv.slice(2));
-  if (!resolved.skipBuild) {
-    logLine('building dist artifacts', resolved.json);
-    await ensureBuild(repoRoot);
-  }
-  const workspacePath = resolved.workspacePath;
-
-  logLine('initializing workspace', resolved.json);
-  const init = await runCliJson(repoRoot, ['init', workspacePath, '--json']);
-  const bootstrapTrustToken = String(init.data.bootstrapTrustToken);
-
-  logLine('registering governance admin', resolved.json);
-  const adminRegistration = await runCliJson(repoRoot, [
-    'agent',
-    'register',
-    AGENTS.admin,
-    '-w',
-    workspacePath,
-    '--token',
-    bootstrapTrustToken,
-    '--role',
-    'roles/admin.md',
-    '--capabilities',
-    'policy:manage,agent:approve-registration,agent:register,dispatch:run,thread:claim,thread:manage',
-    '--actor',
-    AGENTS.admin,
-    '--json',
-  ]);
-  const adminApiKey = String(adminRegistration.data.apiKey ?? '');
-
-  const approvals = [];
-  for (const agent of [AGENTS.intake, AGENTS.builder, AGENTS.reviewer]) {
-    logLine(`requesting registration for ${agent}`, resolved.json);
-    const request = await runCliJson(
-      repoRoot,
-      [
-        'agent',
-        'request',
-        agent,
-        '-w',
-        workspacePath,
-        '--actor',
-        agent,
-        '--role',
-        roleByAgent[agent],
-        '--capabilities',
-        'thread:claim,thread:manage,dispatch:run,agent:heartbeat',
-        '--note',
-        `OBJ-09 demo onboarding for ${agent}`,
-        '--json',
-      ],
-      { env: adminApiKey ? { WORKGRAPH_API_KEY: adminApiKey } : undefined },
-    );
-    const requestPath = String(request.data.request.path);
-
-    logLine(`approving registration for ${agent}`, resolved.json);
-    const review = await runCliJson(
-      repoRoot,
-      [
-        'agent',
-        'review',
-        requestPath,
-        '-w',
-        workspacePath,
-        '--decision',
-        'approved',
-        '--actor',
-        AGENTS.admin,
-        '--role',
-        roleByAgent[agent],
-        '--capabilities',
-        'thread:claim,thread:manage,dispatch:run,agent:heartbeat',
-        '--json',
-      ],
-      { env: adminApiKey ? { WORKGRAPH_API_KEY: adminApiKey } : undefined },
-    );
-    approvals.push({
-      agent,
-      requestPath,
-      approvalPath: String(review.data.approval.path),
-      apiKey: String(review.data.apiKey ?? ''),
-    });
-  }
-
-  logLine('publishing initial agent heartbeats', resolved.json);
-  for (const approval of approvals) {
-    await runCliJson(
-      repoRoot,
-      [
-        'agent',
-        'heartbeat',
-        approval.agent,
-        '-w',
-        workspacePath,
-        '--actor',
-        approval.agent,
-        '--status',
-        'online',
-        '--capabilities',
-        'thread:claim,thread:manage,dispatch:run,agent:heartbeat',
-        '--json',
-      ],
-      { env: approval.apiKey ? { WORKGRAPH_API_KEY: approval.apiKey } : undefined },
-    );
-  }
-
-  const agents = await runCliJson(
-    repoRoot,
-    ['agent', 'list', '-w', workspacePath, '--json'],
-    { env: adminApiKey ? { WORKGRAPH_API_KEY: adminApiKey } : undefined },
-  );
-  const credentials = await runCliJson(
-    repoRoot,
-    ['agent', 'credential-list', '-w', workspacePath, '--json'],
-    { env: adminApiKey ? { WORKGRAPH_API_KEY: adminApiKey } : undefined },
-  );
-
-  const output = {
-    workspacePath,
-    bootstrapTrustToken,
-    admin: {
-      actor: AGENTS.admin,
-      apiKey: adminApiKey,
-      credentialId: String(adminRegistration.data.credential?.id ?? ''),
-    },
-    approvals,
-    governanceSnapshot: {
-      agentCount: Number(agents.data.count ?? 0),
-      credentialCount: Number(credentials.data.count ?? 0),
-    },
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-});
diff --git a/examples/multi-agent-showcase/scripts/02-collaboration.mjs b/examples/multi-agent-showcase/scripts/02-collaboration.mjs
deleted file mode 100755
index a863735..0000000
--- a/examples/multi-agent-showcase/scripts/02-collaboration.mjs
+++ /dev/null
@@ -1,471 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  ensureBuild,
-  loadSdk,
-  logLine,
-  resolveRepoRoot,
-  runCliJson,
-} from './lib/demo-utils.mjs';
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-  if (!args.workspacePath) {
-    throw new Error('Missing required --workspace argument.');
-  }
-
-  const repoRoot = resolveRepoRoot(import.meta.url);
-  if (!args.skipBuild) {
-    logLine('building dist artifacts', args.json);
-    await ensureBuild(repoRoot);
-  }
-  const sdk = await loadSdk(repoRoot);
-
-  const workspacePath = args.workspacePath;
-  const apiKeyEnvByActor = {
-    [args.adminActor]: args.adminApiKey,
-    [args.intakeActor]: args.intakeApiKey,
-    [args.builderActor]: args.builderApiKey,
-    [args.reviewerActor]: args.reviewerApiKey,
-  };
-
-  logLine('creating lifecycle threads', args.json);
-  const intakeThread = await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'create',
-      'OBJ-09 intake triage',
-      '-w',
-      workspacePath,
-      '--goal',
-      'Collect triage context and route implementation work',
-      '--priority',
-      'high',
-      '--actor',
-      args.adminActor,
-      '--tags',
-      'obj-09,intake',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const intakeThreadPath = String(intakeThread.data.thread.path);
-
-  const builderThread = await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'create',
-      'OBJ-09 implementation',
-      '-w',
-      workspacePath,
-      '--goal',
-      'Implement coordinated fix and capture build evidence',
-      '--priority',
-      'high',
-      '--deps',
-      intakeThreadPath,
-      '--actor',
-      args.adminActor,
-      '--tags',
-      'obj-09,implementation',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const builderThreadPath = String(builderThread.data.thread.path);
-
-  const reviewerThread = await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'create',
-      'OBJ-09 verification',
-      '-w',
-      workspacePath,
-      '--goal',
-      'Verify the fix and close the coordination loop',
-      '--priority',
-      'medium',
-      '--deps',
-      builderThreadPath,
-      '--actor',
-      args.adminActor,
-      '--tags',
-      'obj-09,verification',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const reviewerThreadPath = String(reviewerThread.data.thread.path);
-
-  logLine('creating conversation and plan steps', args.json);
-  const conversation = await runCliJson(
-    repoRoot,
-    [
-      'conversation',
-      'create',
-      'OBJ-09 execution room',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--threads',
-      `${intakeThreadPath},${builderThreadPath},${reviewerThreadPath}`,
-      '--tags',
-      'obj-09,multi-agent',
-      '--status',
-      'active',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const conversationPath = String(conversation.data.conversation.path);
-
-  const intakePlanStep = await runCliJson(
-    repoRoot,
-    [
-      'plan-step',
-      'create',
-      conversationPath,
-      'Triage incoming issue and hand off implementation',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--thread',
-      intakeThreadPath,
-      '--assignee',
-      args.intakeActor,
-      '--order',
-      '1',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const intakeStepPath = String(intakePlanStep.data.step.path);
-
-  const builderPlanStep = await runCliJson(
-    repoRoot,
-    [
-      'plan-step',
-      'create',
-      conversationPath,
-      'Implement and validate coordinated fix',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--thread',
-      builderThreadPath,
-      '--assignee',
-      args.builderActor,
-      '--order',
-      '2',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const builderStepPath = String(builderPlanStep.data.step.path);
-
-  const reviewerPlanStep = await runCliJson(
-    repoRoot,
-    [
-      'plan-step',
-      'create',
-      conversationPath,
-      'Run independent QA verification',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--thread',
-      reviewerThreadPath,
-      '--assignee',
-      args.reviewerActor,
-      '--order',
-      '3',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const reviewerStepPath = String(reviewerPlanStep.data.step.path);
-
-  logLine('running intake and builder lifecycle', args.json);
-  await runCliJson(
-    repoRoot,
-    ['dispatch', 'claim', intakeThreadPath, '-w', workspacePath, '--actor', args.intakeActor, '--json'],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'start', intakeStepPath, '-w', workspacePath, '--actor', args.intakeActor, '--json'],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'progress', intakeStepPath, '100', '-w', workspacePath, '--actor', args.intakeActor, '--json'],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'done',
-      intakeThreadPath,
-      '-w',
-      workspacePath,
-      '--actor',
-      args.intakeActor,
-      '--output',
-      'Triage completed with evidence https://github.com/versatly/workgraph/pull/obj-09-intake',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'done', intakeStepPath, '-w', workspacePath, '--actor', args.intakeActor, '--json'],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-
-  await runCliJson(
-    repoRoot,
-    ['dispatch', 'claim', builderThreadPath, '-w', workspacePath, '--actor', args.builderActor, '--json'],
-    { env: toApiKeyEnv(args.builderApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'start', builderStepPath, '-w', workspacePath, '--actor', args.builderActor, '--json'],
-    { env: toApiKeyEnv(args.builderApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'progress', builderStepPath, '75', '-w', workspacePath, '--actor', args.builderActor, '--json'],
-    { env: toApiKeyEnv(args.builderApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'done',
-      builderThreadPath,
-      '-w',
-      workspacePath,
-      '--actor',
-      args.builderActor,
-      '--output',
-      'Implementation completed with verification logs https://github.com/versatly/workgraph/pull/obj-09-build',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.builderApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'done', builderStepPath, '-w', workspacePath, '--actor', args.builderActor, '--json'],
-    { env: toApiKeyEnv(args.builderApiKey) },
-  );
-
-  logLine('advertising reviewer capabilities and running self-assembly', args.json);
-  await runCliJson(
-    repoRoot,
-    [
-      'primitive',
-      'update',
-      reviewerThreadPath,
-      '-w',
-      workspacePath,
-      '--actor',
-      args.reviewerActor,
-      '--set',
-      'required_capabilities=quality:review',
-      '--set',
-      'required_skills=qa-verification',
-      '--set',
-      'required_adapters=shell-worker',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.reviewerApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    [
-      'agent',
-      'heartbeat',
-      args.reviewerActor,
-      '-w',
-      workspacePath,
-      '--actor',
-      args.reviewerActor,
-      '--status',
-      'online',
-      '--current-task',
-      reviewerThreadPath,
-      '--capabilities',
-      'thread:claim,thread:manage,dispatch:run,quality:review,skill:qa-verification,adapter:shell-worker',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.reviewerApiKey) },
-  );
-
-  const selfAssembly = sdk.agentSelfAssembly.assembleAgent(
-    workspacePath,
-    args.reviewerActor,
-    {
-      credentialToken: args.reviewerApiKey,
-      advertise: {
-        capabilities: ['quality:review'],
-        skills: ['qa-verification'],
-        adapters: ['shell-worker'],
-      },
-      createPlanStepIfMissing: true,
-      recoverStaleClaims: true,
-    },
-  );
-
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'progress', reviewerStepPath, '100', '-w', workspacePath, '--actor', args.reviewerActor, '--json'],
-    { env: toApiKeyEnv(args.reviewerApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    ['plan-step', 'done', reviewerStepPath, '-w', workspacePath, '--actor', args.reviewerActor, '--json'],
-    { env: toApiKeyEnv(args.reviewerApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'done',
-      reviewerThreadPath,
-      '-w',
-      workspacePath,
-      '--actor',
-      args.reviewerActor,
-      '--output',
-      'QA sign-off completed with green checks https://github.com/versatly/workgraph/pull/obj-09-qa',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.reviewerApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    [
-      'conversation',
-      'message',
-      conversationPath,
-      'All coordination plan-steps completed by intake, builder, and reviewer agents.',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--kind',
-      'decision',
-      '--thread',
-      reviewerThreadPath,
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-
-  const conversationState = await runCliJson(
-    repoRoot,
-    ['conversation', 'state', conversationPath, '-w', workspacePath, '--json'],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const readyThreads = await runCliJson(
-    repoRoot,
-    ['thread', 'list', '-w', workspacePath, '--ready', '--json'],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-
-  const output = {
-    workspacePath,
-    conversationPath,
-    threadPaths: {
-      intakeThreadPath,
-      builderThreadPath,
-      reviewerThreadPath,
-    },
-    planStepPaths: {
-      intakeStepPath,
-      builderStepPath,
-      reviewerStepPath,
-    },
-    selfAssembly: {
-      agentName: selfAssembly.agentName,
-      claimedThreadPath: selfAssembly.claimedThread?.path,
-      planStepPath: selfAssembly.planStep?.path,
-      warnings: selfAssembly.warnings,
-    },
-    conversationSummary: conversationState.data.summary,
-    readyThreadCount: Number(readyThreads.data.count ?? 0),
-    actorApiKeys: apiKeyEnvByActor,
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-function parseArgs(args) {
-  const parsed = {
-    workspacePath: '',
-    adminActor: 'governance-admin',
-    intakeActor: 'agent-intake',
-    builderActor: 'agent-builder',
-    reviewerActor: 'agent-reviewer',
-    adminApiKey: '',
-    intakeApiKey: '',
-    builderApiKey: '',
-    reviewerApiKey: '',
-    skipBuild: false,
-    json: false,
-  };
-  for (let idx = 0; idx < args.length; idx += 1) {
-    const arg = String(args[idx] ?? '');
-    if ((arg === '--workspace' || arg === '-w') && idx + 1 < args.length) {
-      parsed.workspacePath = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--admin-api-key' && idx + 1 < args.length) {
-      parsed.adminApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--intake-api-key' && idx + 1 < args.length) {
-      parsed.intakeApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--builder-api-key' && idx + 1 < args.length) {
-      parsed.builderApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--reviewer-api-key' && idx + 1 < args.length) {
-      parsed.reviewerApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--skip-build') {
-      parsed.skipBuild = true;
-      continue;
-    }
-    if (arg === '--json') {
-      parsed.json = true;
-    }
-  }
-  return parsed;
-}
-
-function toApiKeyEnv(apiKey) {
-  if (!apiKey) return undefined;
-  return { WORKGRAPH_API_KEY: apiKey };
-}
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-});
diff --git a/examples/multi-agent-showcase/scripts/03-trigger-loop.mjs b/examples/multi-agent-showcase/scripts/03-trigger-loop.mjs
deleted file mode 100755
index 654e391..0000000
--- a/examples/multi-agent-showcase/scripts/03-trigger-loop.mjs
+++ /dev/null
@@ -1,247 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  ensureBuild,
-  loadSdk,
-  logLine,
-  resolveRepoRoot,
-  runCliJson,
-} from './lib/demo-utils.mjs';
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-  if (!args.workspacePath) {
-    throw new Error('Missing required --workspace argument.');
-  }
-
-  const repoRoot = resolveRepoRoot(import.meta.url);
-  if (!args.skipBuild) {
-    logLine('building dist artifacts', args.json);
-    await ensureBuild(repoRoot);
-  }
-  const sdk = await loadSdk(repoRoot);
-  const workspacePath = args.workspacePath;
-
-  logLine('creating active trigger for thread-complete events', args.json);
-  const shellCommand = `"${process.execPath}" -e "console.log('obj09-trigger-ok'); console.log('https://github.com/versatly/workgraph/pull/obj-09-trigger');"`;
-  const trigger = sdk.store.create(
-    workspacePath,
-    'trigger',
-    {
-      title: 'OBJ-09 thread completion trigger',
-      status: 'active',
-      condition: {
-        type: 'event',
-        event: 'thread-complete',
-      },
-      action: {
-        type: 'dispatch-run',
-        objective: 'React to completed thread {{matched_event_latest_target}}',
-        adapter: 'shell-worker',
-        context: {
-          shell_command: shellCommand,
-        },
-      },
-      cooldown: 0,
-      tags: ['obj-09', 'trigger'],
-    },
-    '# OBJ-09 Trigger\n\nDispatches a shell-worker run after thread completion events.\n',
-    args.adminActor,
-  );
-
-  // First cycle initializes event cursor for deterministic behavior.
-  await runCliJson(
-    repoRoot,
-    [
-      'trigger',
-      'engine',
-      'run',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--execute-runs',
-      '--agents',
-      `${args.intakeActor},${args.builderActor},${args.reviewerActor}`,
-      '--max-steps',
-      '40',
-      '--step-delay-ms',
-      '0',
-      '--timeout-ms',
-      '30000',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-
-  logLine('creating a source thread and completing it', args.json);
-  const sourceThread = await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'create',
-      'OBJ-09 trigger source',
-      '-w',
-      workspacePath,
-      '--goal',
-      'Emit one completion event for trigger execution',
-      '--actor',
-      args.adminActor,
-      '--priority',
-      'high',
-      '--tags',
-      'obj-09,trigger-source',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const sourceThreadPath = String(sourceThread.data.thread.path);
-
-  await runCliJson(
-    repoRoot,
-    ['thread', 'claim', sourceThreadPath, '-w', workspacePath, '--actor', args.intakeActor, '--json'],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-  await runCliJson(
-    repoRoot,
-    [
-      'thread',
-      'done',
-      sourceThreadPath,
-      '-w',
-      workspacePath,
-      '--actor',
-      args.intakeActor,
-      '--output',
-      'Trigger source completed for OBJ-09 evidence loop https://github.com/versatly/workgraph/pull/obj-09-trigger-source',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.intakeApiKey) },
-  );
-
-  logLine('running trigger-run-evidence loop', args.json);
-  const secondCycle = await runCliJson(
-    repoRoot,
-    [
-      'trigger',
-      'engine',
-      'run',
-      '-w',
-      workspacePath,
-      '--actor',
-      args.adminActor,
-      '--execute-runs',
-      '--agents',
-      `${args.intakeActor},${args.builderActor},${args.reviewerActor}`,
-      '--max-steps',
-      '40',
-      '--step-delay-ms',
-      '0',
-      '--timeout-ms',
-      '30000',
-      '--json',
-    ],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-
-  const executedRuns = Array.isArray(secondCycle.data.executedRuns) ? secondCycle.data.executedRuns : [];
-  const triggeredRun = executedRuns[0];
-  if (!triggeredRun || !triggeredRun.runId) {
-    throw new Error('Expected at least one executed run from trigger engine.');
-  }
-  const runId = String(triggeredRun.runId);
-
-  const runStatus = await runCliJson(
-    repoRoot,
-    ['dispatch', 'status', runId, '-w', workspacePath, '--json'],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const runLogs = await runCliJson(
-    repoRoot,
-    ['dispatch', 'logs', runId, '-w', workspacePath, '--json'],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-  const ledgerSnapshot = await runCliJson(
-    repoRoot,
-    ['ledger', 'show', '-w', workspacePath, '--count', '20', '--json'],
-    { env: toApiKeyEnv(args.adminApiKey) },
-  );
-
-  const output = {
-    workspacePath,
-    triggerPath: trigger.path,
-    sourceThreadPath,
-    triggerLoop: {
-      runId,
-      status: String(runStatus.data.run.status),
-      evidenceCount: Number(runStatus.data.run?.evidenceChain?.count ?? 0),
-      logEntries: Array.isArray(runLogs.data.logs) ? runLogs.data.logs.length : 0,
-      cycleFired: Number(secondCycle.data.cycle?.fired ?? 0),
-    },
-    ledgerSnapshotCount: Number(ledgerSnapshot.data.count ?? 0),
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-function parseArgs(args) {
-  const parsed = {
-    workspacePath: '',
-    adminActor: 'governance-admin',
-    intakeActor: 'agent-intake',
-    builderActor: 'agent-builder',
-    reviewerActor: 'agent-reviewer',
-    adminApiKey: '',
-    intakeApiKey: '',
-    builderApiKey: '',
-    reviewerApiKey: '',
-    skipBuild: false,
-    json: false,
-  };
-  for (let idx = 0; idx < args.length; idx += 1) {
-    const arg = String(args[idx] ?? '');
-    if ((arg === '--workspace' || arg === '-w') && idx + 1 < args.length) {
-      parsed.workspacePath = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--admin-api-key' && idx + 1 < args.length) {
-      parsed.adminApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--intake-api-key' && idx + 1 < args.length) {
-      parsed.intakeApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--builder-api-key' && idx + 1 < args.length) {
-      parsed.builderApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--reviewer-api-key' && idx + 1 < args.length) {
-      parsed.reviewerApiKey = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--skip-build') {
-      parsed.skipBuild = true;
-      continue;
-    }
-    if (arg === '--json') {
-      parsed.json = true;
-    }
-  }
-  return parsed;
-}
-
-function toApiKeyEnv(apiKey) {
-  if (!apiKey) return undefined;
-  return { WORKGRAPH_API_KEY: apiKey };
-}
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-});
diff --git a/examples/multi-agent-showcase/scripts/lib/demo-utils.mjs b/examples/multi-agent-showcase/scripts/lib/demo-utils.mjs
deleted file mode 100644
index 8ea5e9f..0000000
--- a/examples/multi-agent-showcase/scripts/lib/demo-utils.mjs
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-const execFileAsync = promisify(execFile);
-
-export function resolveRepoRoot(fromImportMetaUrl) {
-  let current = path.resolve(path.dirname(fileURLToPath(fromImportMetaUrl)));
-  for (let depth = 0; depth < 8; depth += 1) {
-    const pkgPath = path.join(current, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        if (pkg && pkg.name === '@versatly/workgraph') {
-          return current;
-        }
-      } catch {
-        // Keep traversing upward.
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  throw new Error('Unable to resolve WorkGraph repository root from showcase script location.');
-}
-
-export function resolveWorkspace(args) {
-  const parsed = parseArgs(args);
-  if (parsed.workspace) {
-    return {
-      workspacePath: path.resolve(parsed.workspace),
-      providedByUser: true,
-      json: parsed.json,
-      skipBuild: parsed.skipBuild,
-    };
-  }
-  const workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'workgraph-obj09-showcase-'));
-  return {
-    workspacePath,
-    providedByUser: false,
-    json: parsed.json,
-    skipBuild: parsed.skipBuild,
-  };
-}
-
-export async function runCliJson(repoRoot, args, options = {}) {
-  const cliPath = path.join(repoRoot, 'bin', 'workgraph.js');
-  const fullArgs = args.includes('--json') ? [...args] : [...args, '--json'];
-  const env = {
-    ...process.env,
-    ...(options.env ?? {}),
-  };
-  const { stdout, stderr } = await execFileAsync('node', [cliPath, ...fullArgs], {
-    cwd: repoRoot,
-    env,
-    maxBuffer: 10 * 1024 * 1024,
-  });
-  const output = String(stdout ?? '').trim();
-  let parsed;
-  try {
-    parsed = JSON.parse(output);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`CLI output was not valid JSON (${fullArgs.join(' ')}): ${detail}\n${output}`);
-  }
-  if (!parsed || parsed.ok !== true) {
-    const rendered = JSON.stringify(parsed, null, 2);
-    const err = String(stderr ?? '').trim();
-    throw new Error(`CLI command failed (${fullArgs.join(' ')}): ${rendered}${err ? `\n${err}` : ''}`);
-  }
-  return parsed;
-}
-
-export async function ensureBuild(repoRoot) {
-  const distCli = path.join(repoRoot, 'dist', 'cli.js');
-  const distIndex = path.join(repoRoot, 'dist', 'index.js');
-  if (fs.existsSync(distCli) && fs.existsSync(distIndex)) {
-    return;
-  }
-  await execFileAsync(resolvePnpmCommand(), ['run', 'build'], {
-    cwd: repoRoot,
-    env: process.env,
-    maxBuffer: 20 * 1024 * 1024,
-  });
-}
-
-export async function loadSdk(repoRoot) {
-  const sdkUrl = pathToFileURL(path.join(repoRoot, 'dist', 'index.js')).href;
-  return import(sdkUrl);
-}
-
-export function logLine(message, jsonMode) {
-  if (!jsonMode) {
-    process.stderr.write(`${message}\n`);
-  }
-}
-
-function parseArgs(args) {
-  const parsed = {
-    workspace: '',
-    json: false,
-    skipBuild: false,
-  };
-  for (let idx = 0; idx < args.length; idx += 1) {
-    const arg = String(args[idx] ?? '');
-    if ((arg === '--workspace' || arg === '-w') && idx + 1 < args.length) {
-      parsed.workspace = String(args[idx + 1]);
-      idx += 1;
-      continue;
-    }
-    if (arg === '--json') {
-      parsed.json = true;
-      continue;
-    }
-    if (arg === '--skip-build') {
-      parsed.skipBuild = true;
-    }
-  }
-  return parsed;
-}
-
-function resolvePnpmCommand() {
-  return process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
-}
diff --git a/examples/multi-agent-showcase/scripts/run-showcase.mjs b/examples/multi-agent-showcase/scripts/run-showcase.mjs
deleted file mode 100755
index 10bcaa8..0000000
--- a/examples/multi-agent-showcase/scripts/run-showcase.mjs
+++ /dev/null
@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { fileURLToPath } from 'node:url';
-import {
-  ensureBuild,
-  logLine,
-  resolveRepoRoot,
-  resolveWorkspace,
-  runCliJson,
-} from './lib/demo-utils.mjs';
-
-const execFileAsync = promisify(execFile);
-
-async function main() {
-  const repoRoot = resolveRepoRoot(import.meta.url);
-  const resolved = resolveWorkspace(process.argv.slice(2));
-  const workspacePath = resolved.workspacePath;
-
-  if (!resolved.skipBuild) {
-    logLine('building dist artifacts', resolved.json);
-    await ensureBuild(repoRoot);
-  }
-
-  const scriptDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
-  logLine('phase 1/3: governance and registration', resolved.json);
-  const governance = await runScriptJson(scriptDir, '01-governance.mjs', [
-    '--workspace',
-    workspacePath,
-    '--json',
-    ...(resolved.skipBuild ? ['--skip-build'] : []),
-  ]);
-
-  const approvalByAgent = new Map();
-  for (const approval of governance.approvals ?? []) {
-    approvalByAgent.set(String(approval.agent), String(approval.apiKey ?? ''));
-  }
-
-  logLine('phase 2/3: collaborative execution with self-assembly', resolved.json);
-  const collaboration = await runScriptJson(scriptDir, '02-collaboration.mjs', [
-    '--workspace',
-    workspacePath,
-    '--admin-api-key',
-    String(governance.admin?.apiKey ?? ''),
-    '--intake-api-key',
-    String(approvalByAgent.get('agent-intake') ?? ''),
-    '--builder-api-key',
-    String(approvalByAgent.get('agent-builder') ?? ''),
-    '--reviewer-api-key',
-    String(approvalByAgent.get('agent-reviewer') ?? ''),
-    '--json',
-    ...(resolved.skipBuild ? ['--skip-build'] : []),
-  ]);
-
-  logLine('phase 3/3: trigger -> run -> evidence loop', resolved.json);
-  const triggerLoop = await runScriptJson(scriptDir, '03-trigger-loop.mjs', [
-    '--workspace',
-    workspacePath,
-    '--admin-api-key',
-    String(governance.admin?.apiKey ?? ''),
-    '--intake-api-key',
-    String(approvalByAgent.get('agent-intake') ?? ''),
-    '--builder-api-key',
-    String(approvalByAgent.get('agent-builder') ?? ''),
-    '--reviewer-api-key',
-    String(approvalByAgent.get('agent-reviewer') ?? ''),
-    '--json',
-    ...(resolved.skipBuild ? ['--skip-build'] : []),
-  ]);
-
-  const threadList = await runCliJson(
-    repoRoot,
-    ['thread', 'list', '-w', workspacePath, '--json'],
-    {
-      env: governance.admin?.apiKey ? { WORKGRAPH_API_KEY: String(governance.admin.apiKey) } : undefined,
-    },
-  );
-  const dispatchRuns = await runCliJson(
-    repoRoot,
-    ['dispatch', 'list', '-w', workspacePath, '--json'],
-    {
-      env: governance.admin?.apiKey ? { WORKGRAPH_API_KEY: String(governance.admin.apiKey) } : undefined,
-    },
-  );
-  const ledgerRecent = await runCliJson(
-    repoRoot,
-    ['ledger', 'show', '-w', workspacePath, '--count', '25', '--json'],
-    {
-      env: governance.admin?.apiKey ? { WORKGRAPH_API_KEY: String(governance.admin.apiKey) } : undefined,
-    },
-  );
-
-  const demoChecks = {
-    governance: Number(governance.governanceSnapshot?.agentCount ?? 0) >= 4,
-    selfAssemblyClaimedReviewerThread:
-      String(collaboration.selfAssembly?.claimedThreadPath ?? '') === String(collaboration.threadPaths?.reviewerThreadPath ?? ''),
-    planStepCoordinated:
-      String(collaboration.selfAssembly?.planStepPath ?? '') === String(collaboration.planStepPaths?.reviewerStepPath ?? ''),
-    triggerRunEvidence:
-      String(triggerLoop.triggerLoop?.status ?? '') === 'succeeded'
-      && Number(triggerLoop.triggerLoop?.evidenceCount ?? 0) > 0,
-    ledgerActivity:
-      Number(triggerLoop.ledgerSnapshotCount ?? 0) > 0,
-  };
-  const pass = Object.values(demoChecks).every(Boolean);
-
-  const output = {
-    ok: pass,
-    workspacePath,
-    providedWorkspacePath: resolved.providedByUser,
-    checks: demoChecks,
-    phases: {
-      governance,
-      collaboration,
-      triggerLoop,
-    },
-    rollup: {
-      threadCount: Number(threadList.data.count ?? 0),
-      runCount: Array.isArray(dispatchRuns.data.runs) ? dispatchRuns.data.runs.length : 0,
-      ledgerEntryCount: Number(ledgerRecent.data.count ?? 0),
-    },
-  };
-
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-  if (!pass) {
-    process.exitCode = 1;
-  }
-}
-
-async function runScriptJson(scriptDir, scriptName, args) {
-  const scriptPath = path.join(scriptDir, scriptName);
-  const { stdout, stderr } = await execFileAsync('node', [scriptPath, ...args], {
-    maxBuffer: 10 * 1024 * 1024,
-    env: process.env,
-  });
-  const output = String(stdout ?? '').trim();
-  try {
-    return JSON.parse(output);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`Script ${scriptName} did not emit valid JSON: ${detail}\nstdout:\n${output}\nstderr:\n${String(stderr ?? '')}`);
-  }
-}
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-});
diff --git a/package.json b/package.json
index b21f90f..44c3671 100644
--- a/package.json
+++ b/package.json
@@ -1,10 +1,12 @@
 {
   "name": "@versatly/workgraph",
   "version": "3.2.2",
-  "description": "Agent-first workgraph workspace for multi-agent coordination with dynamic primitives, append-only ledger, and markdown-native storage.",
+  "description": "Context graph, thread collaboration, MCP exposure, and actor registration for multi-agent workspaces.",
   "workspaces": [
-    "packages/*",
-    "apps/*"
+    "packages/kernel",
+    "packages/cli",
+    "packages/mcp-server",
+    "packages/sdk"
   ],
   "packageManager": "pnpm@10.26.0",
   "type": "module",
@@ -24,13 +26,6 @@
       "types": "./dist/mcp-http-server.d.ts",
       "import": "./dist/mcp-http-server.js"
     },
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js"
-    },
-    "./server-entry": {
-      "import": "./dist/server-entry.js"
-    },
     "./cli": {
       "types": "./dist/cli.d.ts",
       "import": "./dist/cli.js"
@@ -54,18 +49,16 @@
     "test": "node scripts/run-tests.mjs",
     "test:vitest": "vitest run --config vitest.config.ts",
     "test:packages": "pnpm -r --if-present run test",
-    "demo:workspace": "pnpm run --silent build && node scripts/generate-demo-workspace.mjs /tmp/workgraph-obsidian-demo",
-    "demo:obsidian-setup": "pnpm run --silent build && node scripts/setup-obsidian-demo.mjs /tmp/workgraph-obsidian-demo",
     "ci": "pnpm run typecheck && pnpm run typecheck:packages && pnpm run test && pnpm run build",
     "prepublishOnly": "pnpm run ci"
   },
   "keywords": [
     "workgraph",
+    "context-graph",
     "multi-agent",
-    "agent-coordination",
-    "ledger",
-    "markdown",
-    "primitives"
+    "thread-collaboration",
+    "mcp",
+    "actor-registration"
   ],
   "author": "Versatly",
   "license": "MIT",
@@ -89,7 +82,6 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@versatly/workgraph-mcp-server": "workspace:*",
     "@types/node": "^20.11.0",
     "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
diff --git a/packages/adapter-claude-code/package.json b/packages/adapter-claude-code/package.json
deleted file mode 100644
index 0da999f..0000000
--- a/packages/adapter-claude-code/package.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "name": "@versatly/workgraph-adapter-claude-code",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-adapter-shell-worker": "workspace:*",
-    "@versatly/workgraph-runtime-adapter-core": "workspace:*"
-  }
-}
diff --git a/packages/adapter-claude-code/src/adapter.ts b/packages/adapter-claude-code/src/adapter.ts
deleted file mode 100644
index 63bca5e..0000000
--- a/packages/adapter-claude-code/src/adapter.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import {
-  ShellWorkerAdapter,
-} from '@versatly/workgraph-adapter-shell-worker';
-import type {
-  DispatchAdapter,
-  DispatchAdapterCreateInput,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterLogEntry,
-  DispatchAdapterRunStatus,
-} from '@versatly/workgraph-runtime-adapter-core';
-
-/**
- * Claude Code adapter backed by the shell worker transport.
- *
- * This keeps runtime orchestration in-kernel while allowing concrete execution
- * through a production command template configured per environment.
- */
-export class ClaudeCodeAdapter implements DispatchAdapter {
-  name = 'claude-code';
-  private readonly shellAdapter = new ShellWorkerAdapter();
-
-  async create(input: DispatchAdapterCreateInput): Promise {
-    return this.shellAdapter.create(input);
-  }
-
-  async status(runId: string): Promise {
-    return this.shellAdapter.status(runId);
-  }
-
-  async followup(runId: string, actor: string, input: string): Promise {
-    return this.shellAdapter.followup(runId, actor, input);
-  }
-
-  async stop(runId: string, actor: string): Promise {
-    return this.shellAdapter.stop(runId, actor);
-  }
-
-  async logs(runId: string): Promise {
-    return this.shellAdapter.logs(runId);
-  }
-
-  async execute(input: DispatchAdapterExecutionInput): Promise {
-    const template = readString(input.context?.claude_command_template)
-      ?? process.env.WORKGRAPH_CLAUDE_COMMAND_TEMPLATE;
-
-    if (!template) {
-      return {
-        status: 'failed',
-        error: [
-          'claude-code adapter requires a command template.',
-          'Set context.claude_command_template or WORKGRAPH_CLAUDE_COMMAND_TEMPLATE.',
-          'Template tokens: {workspace}, {run_id}, {actor}, {objective}, {prompt}, {prompt_shell}.',
-          'Example: claude -p {prompt_shell}',
-        ].join(' '),
-        logs: [
-          {
-            ts: new Date().toISOString(),
-            level: 'error',
-            message: 'Missing Claude command template.',
-          },
-        ],
-      };
-    }
-
-    const prompt = buildPrompt(input);
-    const command = applyTemplate(template, {
-      workspace: input.workspacePath,
-      run_id: input.runId,
-      actor: input.actor,
-      objective: input.objective,
-      prompt,
-      prompt_shell: quoteForShell(prompt),
-    });
-
-    const context = {
-      ...input.context,
-      shell_command: command,
-      shell_cwd: readString(input.context?.shell_cwd) ?? input.workspacePath,
-      shell_timeout_ms: input.context?.shell_timeout_ms ?? process.env.WORKGRAPH_CLAUDE_TIMEOUT_MS,
-    };
-
-    const result = await this.shellAdapter.execute({
-      ...input,
-      context,
-    });
-    const logs = [
-      {
-        ts: new Date().toISOString(),
-        level: 'info' as const,
-        message: 'claude-code adapter dispatched shell execution from command template.',
-      },
-      ...(result.logs ?? []),
-    ];
-    return {
-      ...result,
-      logs,
-      metrics: {
-        ...(result.metrics ?? {}),
-        adapter: 'claude-code',
-      },
-    };
-  }
-}
-
-function buildPrompt(input: DispatchAdapterExecutionInput): string {
-  const extraInstructions = readString(input.context?.claude_instructions);
-  const sections = [
-    `Workgraph run id: ${input.runId}`,
-    `Actor: ${input.actor}`,
-    `Objective: ${input.objective}`,
-    `Workspace: ${input.workspacePath}`,
-  ];
-  if (extraInstructions) {
-    sections.push(`Instructions: ${extraInstructions}`);
-  }
-  return sections.join('\n');
-}
-
-function applyTemplate(template: string, values: Record): string {
-  let rendered = template;
-  for (const [key, value] of Object.entries(values)) {
-    rendered = rendered.replaceAll(`{${key}}`, value);
-  }
-  return rendered;
-}
-
-function quoteForShell(value: string): string {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
diff --git a/packages/adapter-claude-code/src/index.ts b/packages/adapter-claude-code/src/index.ts
deleted file mode 100644
index ddec7b5..0000000
--- a/packages/adapter-claude-code/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './adapter.js';
diff --git a/packages/adapter-claude-code/tsconfig.json b/packages/adapter-claude-code/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/adapter-claude-code/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/adapter-cursor-cloud/package.json b/packages/adapter-cursor-cloud/package.json
deleted file mode 100644
index 46e3070..0000000
--- a/packages/adapter-cursor-cloud/package.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "name": "@versatly/workgraph-adapter-cursor-cloud",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-kernel": "workspace:*",
-    "@versatly/workgraph-runtime-adapter-core": "workspace:*"
-  }
-}
diff --git a/packages/adapter-cursor-cloud/src/adapter.test.ts b/packages/adapter-cursor-cloud/src/adapter.test.ts
deleted file mode 100644
index 146c0cb..0000000
--- a/packages/adapter-cursor-cloud/src/adapter.test.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { CursorCloudAdapter } from './adapter.js';
-import type {
-  DispatchAdapterCancelInput,
-  DispatchAdapterDispatchInput,
-  DispatchAdapterPollInput,
-} from '@versatly/workgraph-runtime-adapter-core';
-
-function makeDispatchInput(overrides: Partial = {}): DispatchAdapterDispatchInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run_cursor_external_1',
-    actor: 'agent-cursor',
-    objective: 'Dispatch cursor task externally',
-    context: {
-      cursor_cloud_api_base_url: 'https://cursor.example/api',
-    },
-    followups: [],
-    ...overrides,
-  };
-}
-
-function makePollInput(overrides: Partial = {}): DispatchAdapterPollInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run_cursor_external_1',
-    actor: 'agent-cursor',
-    objective: 'Poll cursor task externally',
-    context: {
-      cursor_cloud_api_base_url: 'https://cursor.example/api',
-    },
-    external: {
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-123',
-      correlationKeys: ['run_cursor_external_1'],
-    },
-    ...overrides,
-  };
-}
-
-function makeCancelInput(overrides: Partial = {}): DispatchAdapterCancelInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run_cursor_external_1',
-    actor: 'agent-cursor',
-    objective: 'Cancel cursor task externally',
-    context: {
-      cursor_cloud_api_base_url: 'https://cursor.example/api',
-    },
-    external: {
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-123',
-      correlationKeys: ['run_cursor_external_1'],
-    },
-    ...overrides,
-  };
-}
-
-function mockResponse(options: { ok: boolean; status: number; text: string; statusText?: string }): Response {
-  return {
-    ok: options.ok,
-    status: options.status,
-    statusText: options.statusText ?? '',
-    text: async () => options.text,
-  } as Response;
-}
-
-describe('CursorCloudAdapter external broker mode', () => {
-  const fetchMock = vi.fn();
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    fetchMock.mockReset();
-    vi.stubGlobal('fetch', fetchMock);
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('dispatches external runs and returns provider correlation metadata', async () => {
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 202,
-      text: JSON.stringify({
-        id: 'cursor-agent-123',
-        status: 'queued',
-        agentId: 'cursor-agent-primary',
-      }),
-    }));
-
-    const adapter = new CursorCloudAdapter();
-    const result = await adapter.dispatch!(makeDispatchInput());
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      'https://cursor.example/api/runs',
-      expect.objectContaining({
-        method: 'POST',
-        headers: expect.objectContaining({
-          'content-type': 'application/json',
-        }),
-      }),
-    );
-    expect(result.acknowledged).toBe(true);
-    expect(result.status).toBe('queued');
-    expect(result.external).toMatchObject({
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-123',
-      externalAgentId: 'cursor-agent-primary',
-    });
-  });
-
-  it('polls and cancels external runs using provider endpoints', async () => {
-    fetchMock
-      .mockResolvedValueOnce(mockResponse({
-        ok: true,
-        status: 200,
-        text: JSON.stringify({
-          status: 'running',
-          updatedAt: '2026-03-11T10:00:00.000Z',
-        }),
-      }))
-      .mockResolvedValueOnce(mockResponse({
-        ok: true,
-        status: 202,
-        text: JSON.stringify({
-          status: 'cancelled',
-        }),
-      }));
-
-    const adapter = new CursorCloudAdapter();
-    const polled = await adapter.poll!(makePollInput());
-    const cancelled = await adapter.cancel!(makeCancelInput());
-
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      1,
-      'https://cursor.example/api/runs/cursor-agent-123',
-      expect.objectContaining({
-        method: 'GET',
-      }),
-    );
-    expect(polled?.status).toBe('running');
-    expect(polled?.external?.externalRunId).toBe('cursor-agent-123');
-
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      2,
-      'https://cursor.example/api/runs/cursor-agent-123/cancel',
-      expect.objectContaining({
-        method: 'POST',
-      }),
-    );
-    expect(cancelled.acknowledged).toBe(true);
-    expect(cancelled.status).toBe('cancelled');
-  });
-});
diff --git a/packages/adapter-cursor-cloud/src/adapter.ts b/packages/adapter-cursor-cloud/src/adapter.ts
deleted file mode 100644
index 0fcb3c5..0000000
--- a/packages/adapter-cursor-cloud/src/adapter.ts
+++ /dev/null
@@ -1,642 +0,0 @@
-import {
-  orientation as orientationModule,
-  store as storeModule,
-  thread as threadModule,
-} from '@versatly/workgraph-kernel';
-import type {
-  DispatchAdapter,
-  DispatchAdapterCancelInput,
-  DispatchAdapterCreateInput,
-  DispatchAdapterDispatchInput,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterExternalUpdate,
-  DispatchAdapterLogEntry,
-  DispatchAdapterPollInput,
-  DispatchAdapterRunStatus,
-  RunStatus,
-} from '@versatly/workgraph-runtime-adapter-core';
-
-const orientation = orientationModule;
-const store = storeModule;
-const thread = threadModule;
-
-const DEFAULT_MAX_STEPS = 200;
-const DEFAULT_STEP_DELAY_MS = 25;
-const DEFAULT_AGENT_COUNT = 3;
-const DEFAULT_EXTERNAL_TIMEOUT_MS = 30_000;
-
-export class CursorCloudAdapter implements DispatchAdapter {
-  name = 'cursor-cloud';
-
-  async create(_input: DispatchAdapterCreateInput): Promise {
-    return {
-      runId: 'adapter-managed',
-      status: 'queued',
-    };
-  }
-
-  async status(runId: string): Promise {
-    return { runId, status: 'running' };
-  }
-
-  async followup(runId: string, _actor: string, _input: string): Promise {
-    return { runId, status: 'running' };
-  }
-
-  async stop(runId: string, _actor: string): Promise {
-    return { runId, status: 'cancelled' };
-  }
-
-  async logs(_runId: string): Promise {
-    return [];
-  }
-
-  async dispatch(input: DispatchAdapterDispatchInput): Promise {
-    const config = resolveCursorBrokerConfig(input.context);
-    if (!config) {
-      throw new Error('cursor-cloud external broker requires cursor_cloud_api_base_url or cursor_cloud_dispatch_url.');
-    }
-    const now = new Date().toISOString();
-    const payload = {
-      runId: input.runId,
-      actor: input.actor,
-      objective: input.objective,
-      workspacePath: input.workspacePath,
-      context: input.context ?? {},
-      followups: input.followups ?? [],
-      external: input.external ?? null,
-      ts: now,
-    };
-    const response = await fetchJson(config.dispatchUrl, {
-      method: 'POST',
-      headers: buildCursorHeaders(config),
-      body: JSON.stringify(payload),
-      signal: input.abortSignal,
-    }, config.timeoutMs);
-    const externalRunId = readExternalRunId(response.json);
-    if (!response.ok || !externalRunId) {
-      throw new Error(`cursor-cloud dispatch failed (${response.status}): ${response.text || 'missing external run id'}`);
-    }
-    return {
-      acknowledged: true,
-      acknowledgedAt: now,
-      status: normalizeRunStatus(response.json?.status) ?? 'queued',
-      external: {
-        provider: 'cursor-cloud',
-        externalRunId,
-        externalAgentId: readString(response.json?.agentId) ?? readString(response.json?.agent_id),
-        externalThreadId: readString(response.json?.threadId) ?? readString(response.json?.thread_id),
-        correlationKeys: compactStrings([
-          input.runId,
-          readString(input.context?.cursor_correlation_key),
-          readString(response.json?.correlationKey),
-        ]),
-        metadata: {
-          response: response.json ?? response.text,
-        },
-      },
-      lastKnownAt: now,
-      logs: [
-        {
-          ts: now,
-          level: 'info',
-          message: `cursor-cloud dispatched external run ${externalRunId}.`,
-        },
-      ],
-      metrics: {
-        adapter: 'cursor-cloud',
-        httpStatus: response.status,
-      },
-      metadata: {
-        httpStatus: response.status,
-      },
-    };
-  }
-
-  async poll(input: DispatchAdapterPollInput): Promise {
-    const config = resolveCursorBrokerConfig(input.context);
-    if (!config) return null;
-    const response = await fetchJson(resolveTemplate(config.statusUrlTemplate, input.external.externalRunId), {
-      method: 'GET',
-      headers: buildCursorHeaders(config),
-      signal: input.abortSignal,
-    }, config.timeoutMs);
-    if (!response.ok) {
-      throw new Error(`cursor-cloud poll failed (${response.status}): ${response.text || response.statusText}`);
-    }
-    return {
-      status: normalizeRunStatus(response.json?.status),
-      output: readString(response.json?.output),
-      error: readString(response.json?.error),
-      external: {
-        provider: 'cursor-cloud',
-        externalRunId: input.external.externalRunId,
-        externalAgentId: readString(response.json?.agentId) ?? readString(response.json?.agent_id) ?? input.external.externalAgentId,
-        externalThreadId: readString(response.json?.threadId) ?? readString(response.json?.thread_id) ?? input.external.externalThreadId,
-        correlationKeys: compactStrings([
-          ...(input.external.correlationKeys ?? []),
-          readString(response.json?.correlationKey),
-        ]),
-        metadata: {
-          response: response.json ?? response.text,
-        },
-      },
-      lastKnownAt: readString(response.json?.updatedAt) ?? readString(response.json?.updated_at) ?? new Date().toISOString(),
-      logs: [],
-      metadata: {
-        httpStatus: response.status,
-      },
-    };
-  }
-
-  async cancel(input: DispatchAdapterCancelInput): Promise {
-    const config = resolveCursorBrokerConfig(input.context);
-    if (!config || !input.external?.externalRunId) {
-      return {
-        status: 'cancelled',
-        acknowledged: true,
-        acknowledgedAt: new Date().toISOString(),
-        external: input.external,
-      };
-    }
-    const now = new Date().toISOString();
-    const response = await fetchJson(resolveTemplate(config.cancelUrlTemplate, input.external.externalRunId), {
-      method: 'POST',
-      headers: buildCursorHeaders(config),
-      body: JSON.stringify({
-        runId: input.runId,
-        actor: input.actor,
-        objective: input.objective,
-        externalRunId: input.external.externalRunId,
-        ts: now,
-      }),
-      signal: input.abortSignal,
-    }, config.timeoutMs);
-    if (!response.ok) {
-      throw new Error(`cursor-cloud cancel failed (${response.status}): ${response.text || response.statusText}`);
-    }
-    return {
-      status: normalizeRunStatus(response.json?.status),
-      acknowledged: true,
-      acknowledgedAt: now,
-      external: {
-        provider: 'cursor-cloud',
-        externalRunId: input.external.externalRunId,
-        externalAgentId: input.external.externalAgentId,
-        externalThreadId: input.external.externalThreadId,
-        correlationKeys: input.external.correlationKeys,
-        metadata: {
-          response: response.json ?? response.text,
-        },
-      },
-      lastKnownAt: now,
-      metadata: {
-        httpStatus: response.status,
-      },
-    };
-  }
-
-  async health(): Promise> {
-    return {
-      adapter: this.name,
-      mode: 'dual',
-    };
-  }
-
-  async execute(input: DispatchAdapterExecutionInput): Promise {
-    const start = Date.now();
-    const logs: DispatchAdapterLogEntry[] = [];
-    const agentPool = normalizeAgents(input.agents, input.actor);
-    const maxSteps = normalizeInt(input.maxSteps, DEFAULT_MAX_STEPS, 1, 5000);
-    const stepDelayMs = normalizeInt(input.stepDelayMs, DEFAULT_STEP_DELAY_MS, 0, 5000);
-    const claimedByAgent: Record = {};
-    const completedByAgent: Record = {};
-    let stepsExecuted = 0;
-    let completionCount = 0;
-    let failureCount = 0;
-    let cancelled = false;
-
-    for (const agent of agentPool) {
-      claimedByAgent[agent] = 0;
-      completedByAgent[agent] = 0;
-    }
-
-    pushLog(logs, 'info', `Run ${input.runId} started with agents: ${agentPool.join(', ')}`);
-    pushLog(logs, 'info', `Objective: ${input.objective}`);
-
-    while (stepsExecuted < maxSteps) {
-      if (input.isCancelled?.()) {
-        cancelled = true;
-        pushLog(logs, 'warn', `Run ${input.runId} received cancellation signal.`);
-        break;
-      }
-
-      const claimedThisRound: Array<{ agent: string; threadPath: string; goal: string }> = [];
-      for (const agent of agentPool) {
-        try {
-          const claimed = input.space
-            ? thread.claimNextReadyInSpace(input.workspacePath, agent, input.space)
-            : thread.claimNextReady(input.workspacePath, agent);
-          if (!claimed) {
-            continue;
-          }
-          const path = claimed.path;
-          const goal = String(claimed.fields.goal ?? claimed.fields.title ?? path);
-          claimedThisRound.push({ agent, threadPath: path, goal });
-          claimedByAgent[agent] += 1;
-          pushLog(logs, 'info', `${agent} claimed ${path}`);
-        } catch (error) {
-          // Races are expected in multi-agent scheduling; recover and keep moving.
-          pushLog(logs, 'warn', `${agent} claim skipped: ${errorMessage(error)}`);
-        }
-      }
-
-      if (claimedThisRound.length === 0) {
-        const readyRemaining = listReady(input.workspacePath, input.space).length;
-        if (readyRemaining === 0) {
-          pushLog(logs, 'info', 'No ready threads remaining; autonomous loop complete.');
-          break;
-        }
-        if (stepDelayMs > 0) {
-          await sleep(stepDelayMs);
-        }
-        continue;
-      }
-
-      await Promise.all(claimedThisRound.map(async (claimed) => {
-        if (input.isCancelled?.()) {
-          cancelled = true;
-          return;
-        }
-        if (stepDelayMs > 0) {
-          await sleep(stepDelayMs);
-        }
-        try {
-          thread.done(
-            input.workspacePath,
-            claimed.threadPath,
-            claimed.agent,
-            `Completed by ${claimed.agent} during dispatch run ${input.runId}. Goal: ${claimed.goal}`,
-            {
-              evidence: [
-                { type: 'thread-ref', value: claimed.threadPath },
-                { type: 'reply-ref', value: `thread:${input.runId}` },
-              ],
-            },
-          );
-          completionCount += 1;
-          completedByAgent[claimed.agent] += 1;
-          pushLog(logs, 'info', `${claimed.agent} completed ${claimed.threadPath}`);
-        } catch (error) {
-          failureCount += 1;
-          pushLog(logs, 'error', `${claimed.agent} failed to complete ${claimed.threadPath}: ${errorMessage(error)}`);
-        }
-      }));
-
-      stepsExecuted += claimedThisRound.length;
-      if (cancelled) break;
-    }
-
-    const readyAfter = listReady(input.workspacePath, input.space);
-    const activeAfter = input.space
-      ? store.threadsInSpace(input.workspacePath, input.space).filter((candidate) => candidate.fields.status === 'active')
-      : store.activeThreads(input.workspacePath);
-    const openAfter = input.space
-      ? store.threadsInSpace(input.workspacePath, input.space).filter((candidate) => candidate.fields.status === 'open')
-      : store.openThreads(input.workspacePath);
-    const blockedAfter = input.space
-      ? store.threadsInSpace(input.workspacePath, input.space).filter((candidate) => candidate.fields.status === 'blocked')
-      : store.blockedThreads(input.workspacePath);
-
-    const elapsedMs = Date.now() - start;
-    const summary = renderSummary({
-      objective: input.objective,
-      runId: input.runId,
-      completed: completionCount,
-      failed: failureCount,
-      stepsExecuted,
-      readyRemaining: readyAfter.length,
-      openRemaining: openAfter.length,
-      blockedRemaining: blockedAfter.length,
-      activeRemaining: activeAfter.length,
-      elapsedMs,
-      claimedByAgent,
-      completedByAgent,
-      cancelled,
-    });
-
-    if (input.createCheckpoint !== false) {
-      try {
-        orientation.checkpoint(
-          input.workspacePath,
-          input.actor,
-          `Dispatch run ${input.runId} completed autonomous execution.`,
-          {
-            next: readyAfter.slice(0, 10).map((entry) => entry.path),
-            blocked: blockedAfter.slice(0, 10).map((entry) => entry.path),
-            tags: ['dispatch', 'autonomous-run'],
-          },
-        );
-        pushLog(logs, 'info', `Checkpoint recorded for run ${input.runId}.`);
-      } catch (error) {
-        // Checkpoint creation is helpful but should not fail a completed run.
-        pushLog(logs, 'warn', `Checkpoint creation skipped: ${errorMessage(error)}`);
-      }
-    }
-
-    if (cancelled) {
-      return {
-        status: 'cancelled',
-        output: summary,
-        logs,
-        metrics: {
-          completed: completionCount,
-          failed: failureCount,
-          readyRemaining: readyAfter.length,
-          openRemaining: openAfter.length,
-          blockedRemaining: blockedAfter.length,
-          elapsedMs,
-          claimedByAgent,
-          completedByAgent,
-        },
-      };
-    }
-
-    if (failureCount > 0) {
-      return {
-        status: 'failed',
-        error: summary,
-        logs,
-        metrics: {
-          completed: completionCount,
-          failed: failureCount,
-          readyRemaining: readyAfter.length,
-          openRemaining: openAfter.length,
-          blockedRemaining: blockedAfter.length,
-          elapsedMs,
-          claimedByAgent,
-          completedByAgent,
-        },
-      };
-    }
-
-    const status = readyAfter.length === 0 && activeAfter.length === 0 ? 'succeeded' : 'failed';
-    if (status === 'failed') {
-      pushLog(logs, 'warn', 'Execution stopped with actionable work still remaining.');
-    }
-
-    return {
-      status,
-      output: summary,
-      logs,
-      metrics: {
-        completed: completionCount,
-        failed: failureCount,
-        readyRemaining: readyAfter.length,
-        openRemaining: openAfter.length,
-        blockedRemaining: blockedAfter.length,
-        elapsedMs,
-        claimedByAgent,
-        completedByAgent,
-      },
-    };
-  }
-}
-
-function normalizeAgents(agents: string[] | undefined, actor: string): string[] {
-  const fromInput = (agents ?? []).map((entry) => String(entry).trim()).filter(Boolean);
-  if (fromInput.length > 0) return [...new Set(fromInput)];
-  return Array.from({ length: DEFAULT_AGENT_COUNT }, (_, idx) => `${actor}-worker-${idx + 1}`);
-}
-
-function normalizeInt(
-  rawValue: number | undefined,
-  fallback: number,
-  min: number,
-  max: number,
-): number {
-  const value = Number.isFinite(rawValue) ? Number(rawValue) : fallback;
-  return Math.min(max, Math.max(min, Math.trunc(value)));
-}
-
-function pushLog(target: DispatchAdapterLogEntry[], level: DispatchAdapterLogEntry['level'], message: string): void {
-  target.push({
-    ts: new Date().toISOString(),
-    level,
-    message,
-  });
-}
-
-interface CursorBrokerConfig {
-  dispatchUrl: string;
-  statusUrlTemplate: string;
-  cancelUrlTemplate: string;
-  token?: string;
-  headers: Record;
-  timeoutMs: number;
-}
-
-async function fetchJson(
-  url: string,
-  init: RequestInit,
-  timeoutMs: number,
-): Promise<{
-  ok: boolean;
-  status: number;
-  statusText: string;
-  text: string;
-  json: Record | null;
-}> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(url, {
-      ...init,
-      signal: init.signal ?? controller.signal,
-    });
-    const text = await response.text();
-    return {
-      ok: response.ok,
-      status: response.status,
-      statusText: response.statusText,
-      text,
-      json: safeParseJson(text),
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-function resolveCursorBrokerConfig(context: Record | undefined): CursorBrokerConfig | null {
-  const baseUrl = resolveUrl(
-    context?.cursor_cloud_api_base_url,
-    process.env.WORKGRAPH_CURSOR_CLOUD_API_BASE_URL,
-  );
-  const dispatchUrl = resolveUrl(
-    context?.cursor_cloud_dispatch_url,
-    baseUrl ? `${baseUrl}/runs` : undefined,
-  );
-  if (!dispatchUrl) return null;
-  const statusUrlTemplate = readString(context?.cursor_cloud_status_url_template)
-    ?? (baseUrl ? `${baseUrl}/runs/{externalRunId}` : undefined)
-    ?? `${dispatchUrl.replace(/\/+$/, '')}/{externalRunId}`;
-  const cancelUrlTemplate = readString(context?.cursor_cloud_cancel_url_template)
-    ?? (baseUrl ? `${baseUrl}/runs/{externalRunId}/cancel` : undefined)
-    ?? `${dispatchUrl.replace(/\/+$/, '')}/{externalRunId}/cancel`;
-  return {
-    dispatchUrl,
-    statusUrlTemplate,
-    cancelUrlTemplate,
-    token: readString(context?.cursor_cloud_api_token) ?? readString(process.env.WORKGRAPH_CURSOR_CLOUD_API_TOKEN),
-    headers: readHeaders(context?.cursor_cloud_headers),
-    timeoutMs: normalizeInt(readNumber(context?.cursor_cloud_timeout_ms), DEFAULT_EXTERNAL_TIMEOUT_MS, 1_000, 120_000),
-  };
-}
-
-function buildCursorHeaders(config: CursorBrokerConfig): Record {
-  return {
-    'content-type': 'application/json',
-    ...config.headers,
-    ...(config.token ? { authorization: `Bearer ${config.token}` } : {}),
-  };
-}
-
-function resolveTemplate(template: string, externalRunId: string): string {
-  return template.replaceAll('{externalRunId}', externalRunId);
-}
-
-function readHeaders(value: unknown): Record {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  const record = value as Record;
-  const headers: Record = {};
-  for (const [key, raw] of Object.entries(record)) {
-    if (!key) continue;
-    if (raw === undefined || raw === null) continue;
-    headers[key.toLowerCase()] = String(raw);
-  }
-  return headers;
-}
-
-function safeParseJson(value: string): Record | null {
-  if (!value.trim()) return null;
-  try {
-    const parsed = JSON.parse(value) as unknown;
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
-    return parsed as Record;
-  } catch {
-    return null;
-  }
-}
-
-function readExternalRunId(value: Record | null): string | undefined {
-  return readString(value?.externalRunId)
-    ?? readString(value?.external_run_id)
-    ?? readString(value?.runId)
-    ?? readString(value?.run_id)
-    ?? readString(value?.id)
-    ?? readString(value?.agentId)
-    ?? readString(value?.agent_id);
-}
-
-function resolveUrl(...values: unknown[]): string | undefined {
-  for (const value of values) {
-    const candidate = readString(value);
-    if (!candidate) continue;
-    try {
-      const url = new URL(candidate);
-      if (url.protocol === 'http:' || url.protocol === 'https:') {
-        return url.toString();
-      }
-    } catch {
-      continue;
-    }
-  }
-  return undefined;
-}
-
-function normalizeRunStatus(value: unknown): RunStatus | undefined {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (
-    normalized === 'queued'
-    || normalized === 'running'
-    || normalized === 'succeeded'
-    || normalized === 'failed'
-    || normalized === 'cancelled'
-  ) {
-    return normalized;
-  }
-  return undefined;
-}
-
-function compactStrings(values: Array): string[] {
-  return [...new Set(values.filter((entry): entry is string => Boolean(entry && entry.trim())).map((entry) => entry.trim()))];
-}
-
-function listReady(workspacePath: string, space: string | undefined) {
-  return space
-    ? thread.listReadyThreadsInSpace(workspacePath, space)
-    : thread.listReadyThreads(workspacePath);
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function sleep(ms: number): Promise {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function readNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function renderSummary(data: {
-  objective: string;
-  runId: string;
-  completed: number;
-  failed: number;
-  stepsExecuted: number;
-  readyRemaining: number;
-  openRemaining: number;
-  blockedRemaining: number;
-  activeRemaining: number;
-  elapsedMs: number;
-  claimedByAgent: Record;
-  completedByAgent: Record;
-  cancelled: boolean;
-}): string {
-  const lines = [
-    `Autonomous dispatch summary for ${data.runId}`,
-    `Objective: ${data.objective}`,
-    `Completed threads: ${data.completed}`,
-    `Failed completions: ${data.failed}`,
-    `Scheduler steps executed: ${data.stepsExecuted}`,
-    `Ready remaining: ${data.readyRemaining}`,
-    `Open remaining: ${data.openRemaining}`,
-    `Blocked remaining: ${data.blockedRemaining}`,
-    `Active remaining: ${data.activeRemaining}`,
-    `Elapsed ms: ${data.elapsedMs}`,
-    `Cancelled: ${data.cancelled ? 'yes' : 'no'}`,
-    '',
-    'Claims by agent:',
-    ...Object.entries(data.claimedByAgent).map(([agent, count]) => `- ${agent}: ${count}`),
-    '',
-    'Completions by agent:',
-    ...Object.entries(data.completedByAgent).map(([agent, count]) => `- ${agent}: ${count}`),
-  ];
-  return lines.join('\n');
-}
diff --git a/packages/adapter-cursor-cloud/src/index.ts b/packages/adapter-cursor-cloud/src/index.ts
deleted file mode 100644
index ddec7b5..0000000
--- a/packages/adapter-cursor-cloud/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './adapter.js';
diff --git a/packages/adapter-cursor-cloud/tsconfig.json b/packages/adapter-cursor-cloud/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/adapter-cursor-cloud/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/adapter-http-webhook/package.json b/packages/adapter-http-webhook/package.json
deleted file mode 100644
index f9db226..0000000
--- a/packages/adapter-http-webhook/package.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "@versatly/workgraph-adapter-http-webhook",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-runtime-adapter-core": "workspace:*"
-  }
-}
diff --git a/packages/adapter-http-webhook/src/adapter.ts b/packages/adapter-http-webhook/src/adapter.ts
deleted file mode 100644
index d4a9cb7..0000000
--- a/packages/adapter-http-webhook/src/adapter.ts
+++ /dev/null
@@ -1,242 +0,0 @@
-import type {
-  DispatchAdapter,
-  DispatchAdapterCreateInput,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterLogEntry,
-  DispatchAdapterRunStatus,
-} from '@versatly/workgraph-runtime-adapter-core';
-
-const DEFAULT_POLL_MS = 1000;
-const DEFAULT_MAX_WAIT_MS = 90_000;
-
-export class HttpWebhookAdapter implements DispatchAdapter {
-  name = 'http-webhook';
-
-  async create(_input: DispatchAdapterCreateInput): Promise {
-    return { runId: 'http-webhook-managed', status: 'queued' };
-  }
-
-  async status(runId: string): Promise {
-    return { runId, status: 'running' };
-  }
-
-  async followup(runId: string, _actor: string, _input: string): Promise {
-    return { runId, status: 'running' };
-  }
-
-  async stop(runId: string, _actor: string): Promise {
-    return { runId, status: 'cancelled' };
-  }
-
-  async logs(_runId: string): Promise {
-    return [];
-  }
-
-  async execute(input: DispatchAdapterExecutionInput): Promise {
-    const logs: DispatchAdapterLogEntry[] = [];
-    const webhookUrl = resolveUrl(input.context?.webhook_url, process.env.WORKGRAPH_DISPATCH_WEBHOOK_URL);
-    if (!webhookUrl) {
-      return {
-        status: 'failed',
-        error: 'http-webhook adapter requires context.webhook_url or WORKGRAPH_DISPATCH_WEBHOOK_URL.',
-        logs,
-      };
-    }
-
-    const token = readString(input.context?.webhook_token) ?? process.env.WORKGRAPH_DISPATCH_WEBHOOK_TOKEN;
-    const headers = {
-      'content-type': 'application/json',
-      ...extractHeaders(input.context?.webhook_headers),
-      ...(token ? { authorization: `Bearer ${token}` } : {}),
-    };
-
-    const payload = {
-      runId: input.runId,
-      actor: input.actor,
-      objective: input.objective,
-      workspacePath: input.workspacePath,
-      context: input.context ?? {},
-      ts: new Date().toISOString(),
-    };
-
-    pushLog(logs, 'info', `http-webhook posting run ${input.runId} to ${webhookUrl}`);
-    const response = await fetch(webhookUrl, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(payload),
-    });
-    const rawText = await response.text();
-    const parsed = safeParseJson(rawText);
-    pushLog(logs, response.ok ? 'info' : 'error', `http-webhook response status: ${response.status}`);
-
-    if (!response.ok) {
-      return {
-        status: 'failed',
-        error: `http-webhook request failed (${response.status}): ${rawText || response.statusText}`,
-        logs,
-      };
-    }
-
-    const immediateStatus = normalizeRunStatus(parsed?.status);
-    if (immediateStatus && isTerminalStatus(immediateStatus)) {
-      return {
-        status: immediateStatus,
-        output: typeof parsed?.output === 'string' ? parsed.output : rawText,
-        error: typeof parsed?.error === 'string' ? parsed.error : undefined,
-        logs,
-        metrics: {
-          adapter: 'http-webhook',
-          httpStatus: response.status,
-        },
-      };
-    }
-
-    const pollUrl = resolveUrl(parsed?.pollUrl, input.context?.webhook_status_url, process.env.WORKGRAPH_DISPATCH_WEBHOOK_STATUS_URL);
-    if (!pollUrl) {
-      return {
-        status: 'succeeded',
-        output: rawText || 'http-webhook acknowledged run successfully.',
-        logs,
-        metrics: {
-          adapter: 'http-webhook',
-          httpStatus: response.status,
-        },
-      };
-    }
-
-    const pollMs = clampInt(readNumber(input.context?.webhook_poll_ms), DEFAULT_POLL_MS, 200, 30_000);
-    const maxWaitMs = clampInt(readNumber(input.context?.webhook_max_wait_ms), DEFAULT_MAX_WAIT_MS, 1000, 15 * 60_000);
-    const startedAt = Date.now();
-    pushLog(logs, 'info', `http-webhook polling status from ${pollUrl}`);
-
-    while (Date.now() - startedAt < maxWaitMs) {
-      if (input.isCancelled?.()) {
-        pushLog(logs, 'warn', 'http-webhook run cancelled while polling');
-        return {
-          status: 'cancelled',
-          output: 'http-webhook polling cancelled by dispatcher.',
-          logs,
-        };
-      }
-
-      const pollResponse = await fetch(pollUrl, {
-        method: 'GET',
-        headers: {
-          ...headers,
-        },
-      });
-      const pollText = await pollResponse.text();
-      const pollJson = safeParseJson(pollText);
-      const pollStatus = normalizeRunStatus(pollJson?.status);
-      pushLog(logs, 'info', `poll status=${pollResponse.status} run_status=${pollStatus ?? 'unknown'}`);
-
-      if (pollStatus && isTerminalStatus(pollStatus)) {
-        return {
-          status: pollStatus,
-          output: typeof pollJson?.output === 'string' ? pollJson.output : pollText,
-          error: typeof pollJson?.error === 'string' ? pollJson.error : undefined,
-          logs,
-          metrics: {
-            adapter: 'http-webhook',
-            pollUrl,
-            pollHttpStatus: pollResponse.status,
-            elapsedMs: Date.now() - startedAt,
-          },
-        };
-      }
-
-      await sleep(pollMs);
-    }
-
-    return {
-      status: 'failed',
-      error: `http-webhook polling exceeded timeout (${maxWaitMs}ms) for run ${input.runId}.`,
-      logs,
-    };
-  }
-}
-
-function pushLog(target: DispatchAdapterLogEntry[], level: DispatchAdapterLogEntry['level'], message: string): void {
-  target.push({
-    ts: new Date().toISOString(),
-    level,
-    message,
-  });
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function resolveUrl(...values: unknown[]): string | undefined {
-  for (const value of values) {
-    const parsed = readString(value);
-    if (!parsed) continue;
-    try {
-      const url = new URL(parsed);
-      if (url.protocol === 'http:' || url.protocol === 'https:') {
-        return url.toString();
-      }
-    } catch {
-      continue;
-    }
-  }
-  return undefined;
-}
-
-function extractHeaders(input: unknown): Record {
-  if (!input || typeof input !== 'object' || Array.isArray(input)) return {};
-  const record = input as Record;
-  const out: Record = {};
-  for (const [key, value] of Object.entries(record)) {
-    if (!key || value === undefined || value === null) continue;
-    out[key.toLowerCase()] = String(value);
-  }
-  return out;
-}
-
-function safeParseJson(value: string): Record | null {
-  if (!value || !value.trim()) return null;
-  try {
-    const parsed = JSON.parse(value) as unknown;
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
-    return parsed as Record;
-  } catch {
-    return null;
-  }
-}
-
-function normalizeRunStatus(value: unknown): DispatchAdapterRunStatus['status'] | undefined {
-  const normalized = String(value ?? '').toLowerCase();
-  if (normalized === 'queued' || normalized === 'running' || normalized === 'succeeded' || normalized === 'failed' || normalized === 'cancelled') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function isTerminalStatus(status: DispatchAdapterRunStatus['status']): boolean {
-  return status === 'succeeded' || status === 'failed' || status === 'cancelled';
-}
-
-function readNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function clampInt(value: number | undefined, fallback: number, min: number, max: number): number {
-  const raw = typeof value === 'number' ? Math.trunc(value) : fallback;
-  return Math.min(max, Math.max(min, raw));
-}
-
-function sleep(ms: number): Promise {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
diff --git a/packages/adapter-http-webhook/src/index.ts b/packages/adapter-http-webhook/src/index.ts
deleted file mode 100644
index ddec7b5..0000000
--- a/packages/adapter-http-webhook/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './adapter.js';
diff --git a/packages/adapter-http-webhook/tsconfig.json b/packages/adapter-http-webhook/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/adapter-http-webhook/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/adapter-shell-worker/package.json b/packages/adapter-shell-worker/package.json
deleted file mode 100644
index 8f302cf..0000000
--- a/packages/adapter-shell-worker/package.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "name": "@versatly/workgraph-adapter-shell-worker",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-adapter-cursor-cloud": "workspace:*",
-    "@versatly/workgraph-runtime-adapter-core": "workspace:*"
-  }
-}
diff --git a/packages/adapter-shell-worker/src/adapter.ts b/packages/adapter-shell-worker/src/adapter.ts
deleted file mode 100644
index 62146a2..0000000
--- a/packages/adapter-shell-worker/src/adapter.ts
+++ /dev/null
@@ -1,259 +0,0 @@
-import { spawn } from 'node:child_process';
-import { CursorCloudAdapter } from '../../adapter-cursor-cloud/src/adapter.js';
-import type {
-  DispatchAdapter,
-  DispatchAdapterCreateInput,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterLogEntry,
-  DispatchAdapterRunStatus,
-} from '@versatly/workgraph-runtime-adapter-core';
-
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-const MAX_CAPTURE_CHARS = 12000;
-
-export class ShellWorkerAdapter implements DispatchAdapter {
-  name = 'shell-worker';
-  private readonly fallback = new CursorCloudAdapter();
-
-  async create(_input: DispatchAdapterCreateInput): Promise {
-    return { runId: 'shell-worker-managed', status: 'queued' };
-  }
-
-  async status(runId: string): Promise {
-    return { runId, status: 'running' };
-  }
-
-  async followup(runId: string, _actor: string, _input: string): Promise {
-    return { runId, status: 'running' };
-  }
-
-  async stop(runId: string, _actor: string): Promise {
-    return { runId, status: 'cancelled' };
-  }
-
-  async logs(_runId: string): Promise {
-    return [];
-  }
-
-  async execute(input: DispatchAdapterExecutionInput): Promise {
-    const command = readString(input.context?.shell_command);
-    if (!command) {
-      return this.fallback.execute(input);
-    }
-
-    const shellCwd = readString(input.context?.shell_cwd) ?? input.workspacePath;
-    const timeoutMs = clampInt(readNumber(input.context?.shell_timeout_ms), DEFAULT_TIMEOUT_MS, 1000, 60 * 60 * 1000);
-    const shellEnv = readEnv(input.context?.shell_env);
-    const logs: DispatchAdapterLogEntry[] = [];
-    const startedAt = Date.now();
-    const outputParts: string[] = [];
-    const errorParts: string[] = [];
-
-    pushLog(logs, 'info', `shell-worker starting command: ${command}`);
-    pushLog(logs, 'info', `shell-worker cwd: ${shellCwd}`);
-
-    const result = await runShellCommand({
-      command,
-      cwd: shellCwd,
-      timeoutMs,
-      env: shellEnv,
-      isCancelled: input.isCancelled,
-      onStdout: (chunk) => {
-        outputParts.push(chunk);
-        pushLog(logs, 'info', `[stdout] ${chunk.trimEnd()}`);
-      },
-      onStderr: (chunk) => {
-        errorParts.push(chunk);
-        pushLog(logs, 'warn', `[stderr] ${chunk.trimEnd()}`);
-      },
-    });
-
-    const elapsedMs = Date.now() - startedAt;
-    const stdout = truncateText(outputParts.join(''), MAX_CAPTURE_CHARS);
-    const stderr = truncateText(errorParts.join(''), MAX_CAPTURE_CHARS);
-
-    if (result.cancelled) {
-      pushLog(logs, 'warn', `shell-worker command cancelled after ${elapsedMs}ms`);
-      return {
-        status: 'cancelled',
-        output: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, true),
-        logs,
-      };
-    }
-
-    if (result.timedOut) {
-      pushLog(logs, 'error', `shell-worker command timed out after ${elapsedMs}ms`);
-      return {
-        status: 'failed',
-        error: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
-        logs,
-      };
-    }
-
-    if (result.exitCode !== 0) {
-      pushLog(logs, 'error', `shell-worker command failed with exit code ${result.exitCode}`);
-      return {
-        status: 'failed',
-        error: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
-        logs,
-      };
-    }
-
-    pushLog(logs, 'info', `shell-worker command succeeded in ${elapsedMs}ms`);
-    return {
-      status: 'succeeded',
-      output: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
-      logs,
-      metrics: {
-        elapsedMs,
-        exitCode: result.exitCode,
-        adapter: 'shell-worker',
-      },
-    };
-  }
-}
-
-interface RunShellCommandOptions {
-  command: string;
-  cwd: string;
-  timeoutMs: number;
-  env: Record;
-  isCancelled?: () => boolean;
-  onStdout: (chunk: string) => void;
-  onStderr: (chunk: string) => void;
-}
-
-interface RunShellCommandResult {
-  exitCode: number;
-  timedOut: boolean;
-  cancelled: boolean;
-}
-
-async function runShellCommand(options: RunShellCommandOptions): Promise {
-  return new Promise((resolve) => {
-    const child = spawn(options.command, {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      shell: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let resolved = false;
-    let timedOut = false;
-    let cancelled = false;
-    const timeoutHandle = setTimeout(() => {
-      timedOut = true;
-      child.kill('SIGTERM');
-      setTimeout(() => child.kill('SIGKILL'), 1500).unref();
-    }, options.timeoutMs);
-
-    const cancelWatcher = setInterval(() => {
-      if (options.isCancelled?.()) {
-        cancelled = true;
-        child.kill('SIGTERM');
-      }
-    }, 200);
-    cancelWatcher.unref();
-
-    child.stdout.on('data', (chunk: Buffer) => {
-      options.onStdout(chunk.toString('utf-8'));
-    });
-    child.stderr.on('data', (chunk: Buffer) => {
-      options.onStderr(chunk.toString('utf-8'));
-    });
-
-    child.on('close', (code) => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeoutHandle);
-      clearInterval(cancelWatcher);
-      resolve({
-        exitCode: typeof code === 'number' ? code : 1,
-        timedOut,
-        cancelled,
-      });
-    });
-
-    child.on('error', () => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeoutHandle);
-      clearInterval(cancelWatcher);
-      resolve({
-        exitCode: 1,
-        timedOut,
-        cancelled,
-      });
-    });
-  });
-}
-
-function pushLog(target: DispatchAdapterLogEntry[], level: DispatchAdapterLogEntry['level'], message: string): void {
-  target.push({
-    ts: new Date().toISOString(),
-    level,
-    message,
-  });
-}
-
-function readEnv(value: unknown): Record {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  const input = value as Record;
-  const result: Record = {};
-  for (const [key, raw] of Object.entries(input)) {
-    if (!key) continue;
-    if (raw === undefined || raw === null) continue;
-    result[key] = String(raw);
-  }
-  return result;
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function readNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function clampInt(value: number | undefined, fallback: number, min: number, max: number): number {
-  const raw = typeof value === 'number' ? Math.trunc(value) : fallback;
-  return Math.min(max, Math.max(min, raw));
-}
-
-function truncateText(value: string, limit: number): string {
-  if (value.length <= limit) return value;
-  return `${value.slice(0, limit)}\n...[truncated]`;
-}
-
-function formatShellOutput(
-  command: string,
-  exitCode: number,
-  stdout: string,
-  stderr: string,
-  elapsedMs: number,
-  cancelled: boolean,
-): string {
-  const lines = [
-    'Shell worker execution summary',
-    `Command: ${command}`,
-    `Exit code: ${exitCode}`,
-    `Elapsed ms: ${elapsedMs}`,
-    `Cancelled: ${cancelled ? 'yes' : 'no'}`,
-    '',
-    'STDOUT:',
-    stdout || '(empty)',
-    '',
-    'STDERR:',
-    stderr || '(empty)',
-  ];
-  return lines.join('\n');
-}
diff --git a/packages/adapter-shell-worker/src/index.ts b/packages/adapter-shell-worker/src/index.ts
deleted file mode 100644
index ddec7b5..0000000
--- a/packages/adapter-shell-worker/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './adapter.js';
diff --git a/packages/adapter-shell-worker/tsconfig.json b/packages/adapter-shell-worker/tsconfig.json
deleted file mode 100644
index 92d3d69..0000000
--- a/packages/adapter-shell-worker/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": [
-    "src/**/*",
-    "../adapter-cursor-cloud/src/**/*"
-  ]
-}
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 8ad2153..4320691 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -12,8 +12,6 @@
   "main": "src/index.ts",
   "types": "src/index.ts",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "@versatly/workgraph-control-api": "workspace:*",
     "@versatly/workgraph-kernel": "workspace:*",
     "@versatly/workgraph-mcp-server": "workspace:*",
     "commander": "^12.1.0"
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
index 722cab1..1fd09ef 100644
--- a/packages/cli/src/cli.ts
+++ b/packages/cli/src/cli.ts
@@ -1,2996 +1,1204 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { Command } from 'commander';
 import * as workgraph from '@versatly/workgraph-kernel';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import { startWorkgraphServer, waitForShutdown } from '@versatly/workgraph-control-api';
-import { registerAdapterCommands } from './cli/commands/adapter.js';
-import { registerAutonomyCommands } from './cli/commands/autonomy.js';
-import { registerCapabilityCommands } from './cli/commands/capability.js';
+import { startWorkgraphMcpHttpServer } from '@versatly/workgraph-mcp-server';
 import { registerConversationCommands } from './cli/commands/conversation.js';
-import { registerCursorCommands } from './cli/commands/cursor.js';
-import { registerDispatchCommands } from './cli/commands/dispatch.js';
 import { registerMcpCommands } from './cli/commands/mcp.js';
-import { registerMissionCommands } from './cli/commands/mission.js';
-import { registerSafetyCommands } from './cli/commands/safety.js';
-import { registerPortabilityCommands } from './cli/commands/portability.js';
-import { registerFederationCommands } from './cli/commands/federation.js';
-import { registerWebhookCommands } from './cli/commands/webhook.js';
-import { registerTriggerCommands } from './cli/commands/trigger.js';
 import {
   addWorkspaceOption,
   csv,
-  installNamedIntegration,
   parseNonNegativeIntOption,
-  parsePortOption,
   parsePositiveIntOption,
   parsePositiveIntegerOption,
-  parsePositiveNumberOption,
   parseSetPairs,
-  renderInstalledIntegrationResult,
-  resolveInitTargetPath,
-  resolveApiKey,
-  resolveApiUrl,
+  parsePortOption,
   resolveWorkspacePath,
+  resolveInitTargetPath,
   runCommand,
-  type JsonCapableOptions,
   wantsJson,
 } from './cli/core.js';
-import { WorkgraphRemoteClient } from './remote-client.js';
-
-const DEFAULT_ACTOR =
-  process.env.WORKGRAPH_AGENT ||
-  process.env.USER ||
-  'anonymous';
-
-type PrimitiveRecord = {
-  path: string;
-  type: string;
-  fields: Record;
-};
-
-registerDefaultDispatchAdaptersIntoKernelRegistry();
-
-const CLI_VERSION = (() => {
-  try {
-    const pkgUrl = new URL('../package.json', import.meta.url);
-    const pkg = JSON.parse(fs.readFileSync(pkgUrl, 'utf-8')) as { version?: string };
-    return pkg.version ?? '0.0.0';
-  } catch {
-    return '0.0.0';
-  }
-})();
+
+const CLI_VERSION = '3.2.2';
+const DEFAULT_ACTOR = process.env.WORKGRAPH_ACTOR?.trim() || 'agent';
 
 const program = new Command();
+
 program
   .name('workgraph')
-  .description('Agent-first workgraph workspace for multi-agent collaboration.')
-  .version(CLI_VERSION);
-
-program.showHelpAfterError();
+  .description('Context graph, thread collaboration, MCP exposure, and actor registration.')
+  .version(CLI_VERSION)
+  .showHelpAfterError();
 
 addWorkspaceOption(
   program
     .command('init [path]')
-    .description('Initialize or repair a workgraph workspace starter kit')
-    .option('-n, --name ', 'Workspace name')
-    .option('--no-type-dirs', 'Do not pre-create built-in type directories')
-    .option('--no-bases', 'Do not generate .base files from primitive registry')
-    .option('--no-readme', 'Do not create README.md/QUICKSTART.md')
-    .option('--json', 'Emit structured JSON output')
+    .description('Initialize a workgraph workspace')
+    .option('--name ', 'Workspace name')
+    .option('--no-readme', 'Skip README/QUICKSTART generation')
+    .option('--no-bases', 'Skip base file generation')
+    .option('--json', 'Emit structured JSON output'),
 ).action((targetPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveInitTargetPath(targetPath, opts);
-      const result = workgraph.workspace.initWorkspace(workspacePath, {
-        name: opts.name,
-        createTypeDirs: opts.typeDirs,
-        createBases: opts.bases,
-        createReadme: opts.readme,
-      });
-      return result;
-    },
-    (result) => {
-      const roleSeeded = result.starterKit.roles.created.length + result.starterKit.roles.existing.length;
-      const policySeeded = result.starterKit.policies.created.length + result.starterKit.policies.existing.length;
-      const gateSeeded = result.starterKit.gates.created.length + result.starterKit.gates.existing.length;
-      const spaceSeeded = result.starterKit.spaces.created.length + result.starterKit.spaces.existing.length;
-      return [
-        `${result.alreadyInitialized ? 'Updated' : 'Initialized'} workgraph workspace: ${result.workspacePath}`,
-        `Seeded types: ${result.seededTypes.join(', ')}`,
-        `Generated .base files: ${result.generatedBases.length}`,
-        `Config: ${result.configPath}`,
-        `Server config: ${result.serverConfigPath}`,
-        `Starter kit primitives: roles=${roleSeeded} policies=${policySeeded} gates=${gateSeeded} spaces=${spaceSeeded}`,
-        `Bootstrap trust token (${result.bootstrapTrustTokenPath}): ${result.bootstrapTrustToken}`,
-        ...(result.quickstartPath ? [`Quickstart: ${result.quickstartPath}`] : []),
-        '',
-        'Next steps:',
-        `1) Start server: workgraph serve -w "${result.workspacePath}"`,
-        `2) Preferred registration flow: workgraph agent request agent-1 -w "${result.workspacePath}" --role roles/admin.md`,
-        `   Approve request: workgraph agent review agent-1 -w "${result.workspacePath}" --decision approved --actor admin-approver`,
-        `   Bootstrap fallback: workgraph agent register agent-1 -w "${result.workspacePath}" --token ${result.bootstrapTrustToken}`,
-        `3) Create first thread: workgraph thread create "First coordinated task" -w "${result.workspacePath}" --goal "Validate onboarding flow" --actor agent-1`,
-      ];
-    }
-  )
+    () => workgraph.workspace.initWorkspace(resolveInitTargetPath(targetPath, opts), {
+      name: opts.name,
+      createReadme: opts.readme,
+      createBases: opts.bases,
+    }),
+    (result) => [
+      `Initialized workspace: ${result.workspacePath}`,
+      `Bootstrap trust token path: ${result.bootstrapTrustTokenPath}`,
+      `Server config: ${result.serverConfigPath}`,
+    ],
+  ),
 );
 
-// ============================================================================
-// thread
-// ============================================================================
-
 const threadCmd = program
   .command('thread')
-  .description('Coordinate work through claimable threads');
+  .description('Coordinate work through collaborative threads');
 
 addWorkspaceOption(
   threadCmd
     .command('create ')
-    .description('Create a new thread')
-    .requiredOption('-g, --goal <goal>', 'What success looks like')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('-p, --priority <level>', 'urgent | high | medium | low', 'medium')
-    .option('--deps <paths>', 'Comma-separated dependency thread paths')
-    .option('--parent <path>', 'Parent thread path')
-    .option('--space <spaceRef>', 'Optional space ref (e.g. spaces/backend.md)')
-    .option('--context <refs>', 'Comma-separated workspace doc refs for context')
+    .description('Create a thread')
+    .requiredOption('--goal <text>', 'Thread goal')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--priority <level>', 'urgent|high|medium|low', 'medium')
+    .option('--deps <refs>', 'Comma-separated dependency thread refs')
+    .option('--parent <ref>', 'Parent thread ref')
+    .option('--space <ref>', 'Space ref')
+    .option('--context-refs <refs>', 'Comma-separated context refs')
     .option('--tags <tags>', 'Comma-separated tags')
-    .option('--json', 'Emit structured JSON output')
-).action((title, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ thread: PrimitiveRecord }>('workgraph_thread_create', {
-          title,
-          goal: opts.goal,
-          actor: opts.actor,
-          priority: opts.priority,
-          deps: csv(opts.deps),
-          parent: opts.parent,
-          space: opts.space,
-          context_refs: csv(opts.context),
-          tags: csv(opts.tags),
-        })),
-      (result) => [
-        `Created thread: ${result.thread.path}`,
-        `Status: ${String(result.thread.fields.status)}`,
-        `Priority: ${String(result.thread.fields.priority)}`,
-      ],
-    );
-  }
-  return runCommand(
+    .option('--json', 'Emit structured JSON output'),
+).action((title, opts) =>
+  runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.createThread(workspacePath, title, opts.goal, opts.actor, {
-          priority: opts.priority,
-          deps: csv(opts.deps),
-          parent: opts.parent,
-          space: opts.space,
-          context_refs: csv(opts.context),
-          tags: csv(opts.tags),
-        }),
-      };
-    },
+    () => workgraph.thread.createThread(resolveWorkspacePath(opts), title, opts.goal, opts.actor, {
+      priority: normalizePriority(opts.priority),
+      deps: csv(opts.deps),
+      parent: opts.parent,
+      space: opts.space,
+      context_refs: csv(opts.contextRefs),
+      tags: csv(opts.tags),
+    }),
     (result) => [
-      `Created thread: ${result.thread.path}`,
-      `Status: ${String(result.thread.fields.status)}`,
-      `Priority: ${String(result.thread.fields.priority)}`,
+      `Created thread: ${result.path}`,
+      `Status: ${String(result.fields.status)}`,
+      `Priority: ${String(result.fields.priority)}`,
     ],
-  );
-});
+  ),
+);
 
 addWorkspaceOption(
   threadCmd
     .command('list')
-    .description('List threads (optionally by state/ready status)')
-    .option('-s, --status <status>', 'open | active | blocked | done | cancelled')
-    .option('--space <spaceRef>', 'Filter threads by space ref')
-    .option('--ready', 'Only include threads ready to be claimed now')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ threads: Array<PrimitiveRecord & { ready: boolean }>; count: number }>(
-          'workgraph_thread_list',
-          {
-            status: opts.status,
-            readyOnly: !!opts.ready,
-            space: opts.space,
-          },
-        )),
-      (result) => {
-        if (result.threads.length === 0) return ['No threads found.'];
-        return [
-          ...result.threads.map((t) => {
-            const status = String(t.fields.status);
-            const owner = t.fields.owner ? ` (${String(t.fields.owner)})` : '';
-            const ready = t.ready ? ' ready' : '';
-            return `[${status}]${ready} ${String(t.fields.title)}${owner} -> ${t.path}`;
-          }),
-          `${result.count} thread(s)`,
-        ];
-      },
-    );
-  }
-  return runCommand(
+    .description('List threads')
+    .option('--status <status>', 'Filter by status')
+    .option('--space <ref>', 'Filter by space')
+    .option('--ready', 'Only show ready threads')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
+  runCommand(
     opts,
     () => {
       const workspacePath = resolveWorkspacePath(opts);
       let threads = opts.space
         ? workgraph.store.threadsInSpace(workspacePath, opts.space)
         : workgraph.store.list(workspacePath, 'thread');
-      const readySet = new Set(
-        (opts.space
-          ? workgraph.thread.listReadyThreadsInSpace(workspacePath, opts.space)
-          : workgraph.thread.listReadyThreads(workspacePath))
-          .map(t => t.path)
-      );
-      if (opts.status) threads = threads.filter(t => t.fields.status === opts.status);
-      if (opts.ready) threads = threads.filter(t => readySet.has(t.path));
-      const enriched = threads.map(t => ({
-        ...t,
-        ready: readySet.has(t.path),
-      }));
-      return { threads: enriched, count: enriched.length };
+      if (opts.status) {
+        threads = threads.filter((entry) => String(entry.fields.status) === opts.status);
+      }
+      if (opts.ready) {
+        const readySet = new Set(
+          (opts.space
+            ? workgraph.thread.listReadyThreadsInSpace(workspacePath, opts.space)
+            : workgraph.thread.listReadyThreads(workspacePath)).map((entry) => entry.path),
+        );
+        threads = threads.filter((entry) => readySet.has(entry.path));
+      }
+      return { threads, count: threads.length };
     },
     (result) => {
       if (result.threads.length === 0) return ['No threads found.'];
       return [
-        ...result.threads.map((t) => {
-          const status = String(t.fields.status);
-          const owner = t.fields.owner ? ` (${String(t.fields.owner)})` : '';
-          const ready = t.ready ? ' ready' : '';
-          return `[${status}]${ready} ${String(t.fields.title)}${owner} -> ${t.path}`;
-        }),
+        ...result.threads.map((entry) =>
+          `[${String(entry.fields.status)}] ${String(entry.fields.priority)} ${String(entry.fields.title)} -> ${entry.path}`),
         `${result.count} thread(s)`,
       ];
     },
-  );
-});
+  ),
+);
 
 addWorkspaceOption(
   threadCmd
     .command('next')
-    .description('Pick the next ready thread, optionally claim it')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--space <spaceRef>', 'Restrict scheduling to one space')
-    .option('--claim', 'Immediately claim the next ready thread')
-    .option('--fail-on-empty', 'Exit non-zero if no ready thread exists')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, async (client) => {
-        const readyResult = await client.callTool<{ threads: PrimitiveRecord[] }>(
-          'workgraph_thread_list',
-          {
-            readyOnly: true,
-            space: opts.space,
-          },
-        );
-        const nextThread = readyResult.threads[0];
-        if (!nextThread) {
-          if (opts.failOnEmpty) {
-            throw new Error('No ready threads available.');
-          }
-          return { thread: null, claimed: false };
-        }
-        if (!opts.claim) {
-          return { thread: nextThread, claimed: false };
-        }
-        const claimedResult = await client.callTool<{ thread: PrimitiveRecord }>(
-          'workgraph_thread_claim',
-          {
-            threadPath: nextThread.path,
-            actor: opts.actor,
-          },
-        );
-        return {
-          thread: claimedResult.thread,
-          claimed: true,
-        };
-      }),
-      (result) => {
-        if (!result.thread) return ['No ready thread available.'];
-        return [
-          `${result.claimed ? 'Claimed' : 'Selected'} thread: ${result.thread.path}`,
-          `Title: ${String(result.thread.fields.title)}`,
-          ...(result.thread.fields.space ? [`Space: ${String(result.thread.fields.space)}`] : []),
-        ];
-      },
-    );
-  }
-  return runCommand(
+    .description('Show or claim the next ready thread')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--space <ref>', 'Limit to one space')
+    .option('--claim', 'Claim the next ready thread')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
+  runCommand(
     opts,
     () => {
       const workspacePath = resolveWorkspacePath(opts);
-      const thread = opts.claim
-        ? (opts.space
+      if (opts.claim) {
+        return {
+          thread: opts.space
             ? workgraph.thread.claimNextReadyInSpace(workspacePath, opts.actor, opts.space)
-            : workgraph.thread.claimNextReady(workspacePath, opts.actor))
-        : (opts.space
-            ? workgraph.thread.pickNextReadyThreadInSpace(workspacePath, opts.space)
-            : workgraph.thread.pickNextReadyThread(workspacePath));
-      if (!thread && opts.failOnEmpty) {
-        throw new Error('No ready threads available.');
+            : workgraph.thread.claimNextReady(workspacePath, opts.actor),
+        };
       }
       return {
-        thread,
-        claimed: !!opts.claim && !!thread,
+        thread: opts.space
+          ? workgraph.thread.pickNextReadyThreadInSpace(workspacePath, opts.space)
+          : workgraph.thread.pickNextReadyThread(workspacePath),
       };
     },
-    (result) => {
-      if (!result.thread) return ['No ready thread available.'];
-      return [
-        `${result.claimed ? 'Claimed' : 'Selected'} thread: ${result.thread.path}`,
-        `Title: ${String(result.thread.fields.title)}`,
-        ...(result.thread.fields.space ? [`Space: ${String(result.thread.fields.space)}`] : []),
-      ];
-    },
-  );
-});
+    (result) => result.thread
+      ? [
+          `Thread: ${result.thread.path}`,
+          `Title: ${String(result.thread.fields.title)}`,
+          `Priority: ${String(result.thread.fields.priority)}`,
+        ]
+      : ['No ready thread found.'],
+  ),
+);
 
 addWorkspaceOption(
   threadCmd
     .command('show <threadPath>')
-    .description('Show thread details and ledger history')
-    .option('--json', 'Emit structured JSON output')
+    .description('Show one thread and its ledger history')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
     () => {
       const workspacePath = resolveWorkspacePath(opts);
-      const thread = workgraph.store.read(workspacePath, threadPath);
+      const thread = workgraph.store.read(workspacePath, normalizePath(threadPath));
       if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-      const history = workgraph.ledger.historyOf(workspacePath, threadPath);
-      return { thread, history };
+      return {
+        thread,
+        history: workgraph.ledger.historyOf(workspacePath, thread.path),
+      };
     },
     (result) => [
-      `${String(result.thread.fields.title)} (${result.thread.path})`,
-      `Status: ${String(result.thread.fields.status)} Owner: ${String(result.thread.fields.owner ?? 'unclaimed')}`,
-      `History entries: ${result.history.length}`,
-    ]
-  )
+      `Thread: ${result.thread.path}`,
+      `Status: ${String(result.thread.fields.status)}`,
+      `Owner: ${String(result.thread.fields.owner ?? 'none')}`,
+      `Ledger entries: ${result.history.length}`,
+    ],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('participants <threadPath>')
-    .description('List thread participants and roles')
-    .option('--json', 'Emit structured JSON output')
+    .description('List thread participants')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const participants = workgraph.thread.listThreadParticipants(workspacePath, threadPath);
-      return { threadPath, participants, count: participants.length };
-    },
-    (result) => {
-      if (result.participants.length === 0) {
-        return [`No participants recorded for ${result.threadPath}.`];
-      }
-      return [
-        `Participants for ${result.threadPath}:`,
-        ...result.participants.map((participant) =>
-          `- ${participant.actor} [${participant.role}] joined=${participant.joined_at}`),
-      ];
-    },
-  )
+    () => ({
+      participants: workgraph.thread.listThreadParticipants(resolveWorkspacePath(opts), normalizePath(threadPath)),
+    }),
+    (result) => result.participants.length > 0
+      ? result.participants.map((entry) => `${entry.actor} (${entry.role})`)
+      : ['No participants recorded.'],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('invite <threadPath>')
-    .description('Invite or update a participant role on a thread')
-    .requiredOption('--participant <name>', 'Participant actor name')
-    .option('--role <role>', 'owner | contributor | reviewer | observer', 'contributor')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
+    .description('Invite another participant onto a thread')
+    .requiredOption('--participant <name>', 'Participant actor')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--role <role>', 'owner|contributor|reviewer|observer', 'contributor')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.inviteThreadParticipant(
-          workspacePath,
-          threadPath,
-          opts.actor,
-          opts.participant,
-          opts.role,
-        ),
-      };
-    },
-    (result) => [`Invited participant on: ${result.thread.path}`],
-  )
+    () => workgraph.thread.inviteThreadParticipant(
+      resolveWorkspacePath(opts),
+      normalizePath(threadPath),
+      opts.actor,
+      opts.participant,
+      normalizeParticipantRole(opts.role),
+    ),
+    (result) => [`Updated participants for ${result.path}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('join <threadPath>')
-    .description('Join a thread as participant')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--role <role>', 'contributor | reviewer | observer', 'contributor')
-    .option('--json', 'Emit structured JSON output')
+    .description('Join a thread as a participant')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--role <role>', 'contributor|reviewer|observer', 'contributor')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.joinThread(workspacePath, threadPath, opts.actor, opts.role),
-      };
-    },
-    (result) => [`Joined thread: ${result.thread.path}`],
-  )
+    () => workgraph.thread.joinThread(
+      resolveWorkspacePath(opts),
+      normalizePath(threadPath),
+      opts.actor,
+      normalizeParticipantRole(opts.role),
+    ),
+    (result) => [`Joined ${result.path} as ${opts.actor}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('leave <threadPath>')
-    .description('Leave a thread (or remove another participant if authorized)')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--participant <name>', 'Participant actor to remove (defaults to --actor)')
-    .option('--json', 'Emit structured JSON output')
+    .description('Leave a thread or remove another participant')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--participant <name>', 'Optional participant to remove')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.leaveThread(workspacePath, threadPath, opts.actor, opts.participant),
-      };
-    },
-    (result) => [`Updated participants on: ${result.thread.path}`],
-  )
+    () => workgraph.thread.leaveThread(
+      resolveWorkspacePath(opts),
+      normalizePath(threadPath),
+      opts.actor,
+      opts.participant,
+    ),
+    (result) => [`Updated participants for ${result.path}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('claim <threadPath>')
-    .description('Claim a thread for this agent')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--lease-ttl-minutes <n>', 'Claim lease TTL in minutes', '30')
-    .option('--json', 'Emit structured JSON output')
-).action((threadPath, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ thread: PrimitiveRecord }>('workgraph_thread_claim', {
-          threadPath,
-          actor: opts.actor,
-        })),
-      (result) => [`Claimed: ${result.thread.path}`, `Owner: ${String(result.thread.fields.owner)}`],
-    );
-  }
-  return runCommand(
+    .description('Claim a thread')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--lease-ttl-minutes <n>', 'Lease TTL minutes')
+    .option('--json', 'Emit structured JSON output'),
+).action((threadPath, opts) =>
+  runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.claim(workspacePath, threadPath, opts.actor, {
-          leaseTtlMinutes: Number.parseFloat(String(opts.leaseTtlMinutes)),
-        }),
-      };
-    },
-    (result) => [`Claimed: ${result.thread.path}`, `Owner: ${String(result.thread.fields.owner)}`],
-  );
-});
+    () => workgraph.thread.claim(resolveWorkspacePath(opts), normalizePath(threadPath), opts.actor, {
+      leaseTtlMinutes: opts.leaseTtlMinutes ? parsePositiveIntOption(opts.leaseTtlMinutes, 'lease-ttl-minutes') : undefined,
+    }),
+    (result) => [`Claimed ${result.path} as ${opts.actor}.`],
+  ),
+);
 
 addWorkspaceOption(
   threadCmd
     .command('release <threadPath>')
-    .description('Release a claimed thread back to open')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--reason <reason>', 'Why you are releasing')
-    .option('--json', 'Emit structured JSON output')
+    .description('Release a claimed thread')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--reason <text>', 'Release reason')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return { thread: workgraph.thread.release(workspacePath, threadPath, opts.actor, opts.reason) };
-    },
-    (result) => [`Released: ${result.thread.path}`, `Status: ${String(result.thread.fields.status)}`]
-  )
+    () => workgraph.thread.release(resolveWorkspacePath(opts), normalizePath(threadPath), opts.actor, opts.reason),
+    (result) => [`Released ${result.path} as ${opts.actor}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('done <threadPath>')
     .description('Mark a thread done')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('-o, --output <text>', 'Output/result summary')
-    .option('--evidence <items>', 'Comma-separated evidence values (url/path/reply/thread refs)')
-    .option('--json', 'Emit structured JSON output')
-).action((threadPath, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ thread: PrimitiveRecord }>('workgraph_thread_done', {
-          threadPath,
-          actor: opts.actor,
-          output: opts.output,
-          evidence: csv(opts.evidence),
-        })),
-      (result) => [`Done: ${result.thread.path}`],
-    );
-  }
-  return runCommand(
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--output <text>', 'Completion output')
+    .option('--evidence <items>', 'Comma-separated evidence items')
+    .option('--json', 'Emit structured JSON output'),
+).action((threadPath, opts) =>
+  runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.done(workspacePath, threadPath, opts.actor, opts.output, {
-          evidence: csv(opts.evidence),
-        }),
-      };
-    },
-    (result) => [`Done: ${result.thread.path}`],
-  );
-});
+    () => workgraph.thread.done(resolveWorkspacePath(opts), normalizePath(threadPath), opts.actor, opts.output, {
+      evidence: csv(opts.evidence),
+    }),
+    (result) => [`Completed ${result.path} as ${opts.actor}.`],
+  ),
+);
 
 addWorkspaceOption(
   threadCmd
     .command('reopen <threadPath>')
-    .description('Reopen a done/cancelled thread via compensating ledger op')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--reason <reason>', 'Why the thread is being reopened')
-    .option('--json', 'Emit structured JSON output')
+    .description('Reopen a done or cancelled thread')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--reason <text>', 'Reopen reason')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return { thread: workgraph.thread.reopen(workspacePath, threadPath, opts.actor, opts.reason) };
-    },
-    (result) => [`Reopened: ${result.thread.path}`, `Status: ${String(result.thread.fields.status)}`]
-  )
+    () => workgraph.thread.reopen(resolveWorkspacePath(opts), normalizePath(threadPath), opts.actor, opts.reason),
+    (result) => [`Reopened ${result.path} as ${opts.actor}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('block <threadPath>')
-    .description('Mark a thread blocked')
-    .requiredOption('-b, --blocked-by <dep>', 'Dependency blocking this thread')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--reason <reason>', 'Why it is blocked')
-    .option('--json', 'Emit structured JSON output')
+    .description('Block a thread')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--blocked-by <ref>', 'Blocking dependency', 'external/manual')
+    .option('--reason <text>', 'Blocking reason')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        thread: workgraph.thread.block(workspacePath, threadPath, opts.actor, opts.blockedBy, opts.reason),
-      };
-    },
-    (result) => [`Blocked: ${result.thread.path}`]
-  )
+    () => workgraph.thread.block(
+      resolveWorkspacePath(opts),
+      normalizePath(threadPath),
+      opts.actor,
+      opts.blockedBy,
+      opts.reason,
+    ),
+    (result) => [`Blocked ${result.path} as ${opts.actor}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('unblock <threadPath>')
     .description('Unblock a thread')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return { thread: workgraph.thread.unblock(workspacePath, threadPath, opts.actor) };
-    },
-    (result) => [`Unblocked: ${result.thread.path}`]
-  )
+    () => workgraph.thread.unblock(resolveWorkspacePath(opts), normalizePath(threadPath), opts.actor),
+    (result) => [`Unblocked ${result.path} as ${opts.actor}.`],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('heartbeat [threadPath]')
-    .description('Refresh thread claim lease heartbeat (one thread or all active claims for actor)')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--ttl-minutes <n>', 'Lease TTL in minutes', '30')
-    .option('--json', 'Emit structured JSON output')
+    .description('Refresh one or more claim heartbeats')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--ttl-minutes <n>', 'Lease TTL minutes')
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.thread.heartbeatClaim(
-        workspacePath,
-        opts.actor,
-        threadPath,
-        {
-          ttlMinutes: Number.parseFloat(String(opts.ttlMinutes)),
-        },
-      );
-    },
+    () => workgraph.thread.heartbeatClaim(resolveWorkspacePath(opts), opts.actor, threadPath ? normalizePath(threadPath) : undefined, {
+      ttlMinutes: opts.ttlMinutes ? parsePositiveIntOption(opts.ttlMinutes, 'ttl-minutes') : undefined,
+    }),
     (result) => [
-      `Heartbeat actor: ${result.actor}`,
-      `Touched leases: ${result.touched.length}`,
-      ...(result.touched.length > 0
-        ? result.touched.map((entry) => `- ${entry.threadPath} expires=${entry.expiresAt}`)
-        : []),
-      ...(result.skipped.length > 0
-        ? result.skipped.map((entry) => `SKIP ${entry.threadPath}: ${entry.reason}`)
-        : []),
+      `Touched: ${result.touched.length}`,
+      `Skipped: ${result.skipped.length}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('reap-stale')
-    .description('Reopen/release stale claimed threads whose leases expired')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--limit <n>', 'Max stale leases to reap this run')
-    .option('--json', 'Emit structured JSON output')
+    .description('Reap stale claims')
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--limit <n>', 'Maximum claims to reap')
+    .option('--json', 'Emit structured JSON output'),
 ).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.thread.reapStaleClaims(workspacePath, opts.actor, {
-        limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-      });
-    },
+    () => workgraph.thread.reapStaleClaims(resolveWorkspacePath(opts), opts.actor, {
+      limit: opts.limit ? parsePositiveIntOption(opts.limit, 'limit') : undefined,
+    }),
     (result) => [
-      `Reaper actor: ${result.actor}`,
-      `Scanned stale leases: ${result.scanned}`,
+      `Scanned: ${result.scanned}`,
       `Reaped: ${result.reaped.length}`,
-      ...(result.reaped.length > 0
-        ? result.reaped.map((entry) => `- ${entry.threadPath} (prev=${entry.previousOwner})`)
-        : []),
-      ...(result.skipped.length > 0
-        ? result.skipped.map((entry) => `SKIP ${entry.threadPath}: ${entry.reason}`)
-        : []),
+      `Skipped: ${result.skipped.length}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('leases')
-    .description('List claim leases and staleness state')
-    .option('--json', 'Emit structured JSON output')
+    .description('List claim lease status')
+    .option('--json', 'Emit structured JSON output'),
 ).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const leases = workgraph.thread.listClaimLeaseStatus(workspacePath);
-      return { leases, count: leases.length };
-    },
-    (result) => result.leases.map((lease) =>
-      `${lease.stale ? 'STALE' : 'LIVE'} ${lease.owner} -> ${lease.target} expires=${lease.expiresAt}`)
-  )
+    () => ({ leases: workgraph.thread.listClaimLeaseStatus(resolveWorkspacePath(opts)) }),
+    (result) => result.leases.length > 0
+      ? result.leases.map((lease) => `${lease.target} owner=${lease.owner} stale=${lease.stale}`)
+      : ['No claim leases found.'],
+  ),
 );
 
 addWorkspaceOption(
   threadCmd
     .command('decompose <threadPath>')
-    .description('Break a thread into sub-threads')
-    .requiredOption('--sub <specs...>', 'Sub-thread specs as "title|goal"')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
+    .description('Create child threads under one parent thread')
+    .requiredOption('--subthread <title::goal...>', 'Repeatable child thread spec', collectSubthreadSpecs, [])
+    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
+    .option('--json', 'Emit structured JSON output'),
 ).action((threadPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const subthreads = opts.sub.map((spec: string) => {
-        const [title, ...goalParts] = spec.split('|');
-        const goal = goalParts.join('|').trim() || title.trim();
-        return { title: title.trim(), goal };
-      });
-      return { children: workgraph.thread.decompose(workspacePath, threadPath, subthreads, opts.actor) };
-    },
-    (result) => [`Created ${result.children.length} sub-thread(s).`]
-  )
+    () => ({
+      threads: workgraph.thread.decompose(resolveWorkspacePath(opts), normalizePath(threadPath), opts.subthread, opts.actor),
+    }),
+    (result) => result.threads.map((entry) => `Created child thread: ${entry.path}`),
+  ),
 );
 
-// ============================================================================
-// agent presence
-// ============================================================================
-
 const agentCmd = program
   .command('agent')
-  .description('Track agent presence heartbeats');
+  .description('Manage actor registration, credentials, and presence');
 
 addWorkspaceOption(
   agentCmd
     .command('heartbeat <name>')
-    .description('Create/update an agent presence heartbeat')
-    .option('-a, --actor <name>', 'Actor writing the heartbeat', DEFAULT_ACTOR)
-    .option('--status <status>', 'online | busy | offline', 'online')
-    .option('--current-task <threadRef>', 'Current task/thread slug for this agent')
-    .option('--capabilities <items>', 'Comma-separated capability tags')
-    .option('--json', 'Emit structured JSON output')
-).action((name, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ presence: PrimitiveRecord }>('workgraph_agent_heartbeat', {
-          name,
-          actor: opts.actor,
-          status: normalizeAgentPresenceStatus(opts.status),
-          currentTask: opts.currentTask,
-          capabilities: csv(opts.capabilities),
-        })),
-      (result) => [
-        `Heartbeat: ${String(result.presence.fields.name)} [${String(result.presence.fields.status)}]`,
-        `Last seen: ${String(result.presence.fields.last_seen)}`,
-        `Current task: ${String(result.presence.fields.current_task ?? 'none')}`,
-      ],
-    );
-  }
-  return runCommand(
+    .description('Write an actor presence heartbeat')
+    .option('-a, --actor <actor>', 'Actor performing the update', DEFAULT_ACTOR)
+    .option('--status <status>', 'online|busy|offline', 'online')
+    .option('--current-task <text>', 'Current task')
+    .option('--capabilities <items>', 'Comma-separated capabilities')
+    .option('--json', 'Emit structured JSON output'),
+).action((name, opts) =>
+  runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        presence: workgraph.agent.heartbeat(workspacePath, name, {
-          actor: opts.actor,
-          status: normalizeAgentPresenceStatus(opts.status),
-          currentTask: opts.currentTask,
-          capabilities: csv(opts.capabilities),
-        }),
-      };
-    },
-    (result) => [
-      `Heartbeat: ${String(result.presence.fields.name)} [${String(result.presence.fields.status)}]`,
-      `Last seen: ${String(result.presence.fields.last_seen)}`,
-      `Current task: ${String(result.presence.fields.current_task ?? 'none')}`,
-    ],
-  );
-});
+    () => workgraph.agent.heartbeat(resolveWorkspacePath(opts), name, {
+      actor: opts.actor,
+      status: normalizePresenceStatus(opts.status),
+      currentTask: opts.currentTask,
+      capabilities: csv(opts.capabilities),
+    }),
+    (result) => [`Heartbeated ${String(result.fields.name)} (${String(result.fields.status)}).`],
+  ),
+);
 
 addWorkspaceOption(
   agentCmd
     .command('register <name>')
-    .description('Register an agent using bootstrap token fallback (legacy/hybrid mode)')
-    .option('--token <token>', 'Bootstrap trust token (or WORKGRAPH_TRUST_TOKEN env)')
-    .option('--role <role>', 'Role slug/path override (default from trust token)')
-    .option('--capabilities <items>', 'Comma-separated extra capabilities')
-    .option('--status <status>', 'online | busy | offline', 'online')
-    .option('--current-task <threadRef>', 'Optional current task/thread ref')
-    .option('-a, --actor <name>', 'Actor writing registration artifacts')
-    .option('--json', 'Emit structured JSON output')
-).action((name, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<ReturnType<typeof workgraph.agent.registerAgent>>('workgraph_agent_register', {
-          name,
-          token: opts.token,
-          role: opts.role,
-          capabilities: csv(opts.capabilities),
-          status: normalizeAgentPresenceStatus(opts.status),
-          currentTask: opts.currentTask,
-          actor: opts.actor,
-        })),
-      (result) => [
-        `Registered agent: ${result.agentName}`,
-        `Role: ${result.role} (${result.rolePath})`,
-        `Capabilities: ${result.capabilities.join(', ') || 'none'}`,
-        `Presence: ${result.presence.path}`,
-        `Policy party: ${result.policyParty.id}`,
-        `Bootstrap token: ${result.trustTokenPath} [${result.trustTokenStatus}]`,
-        ...(result.credential ? [`Credential: ${result.credential.id} [${result.credential.status}]`] : []),
-        ...(result.apiKey ? [`API key (store securely, shown once): ${result.apiKey}`] : []),
-      ],
-    );
-  }
-  return runCommand(
+    .description('Register an actor using a trust token')
+    .option('-a, --actor <actor>', 'Actor performing the update', DEFAULT_ACTOR)
+    .option('--token <token>', 'Trust token (or WORKGRAPH_TRUST_TOKEN env)')
+    .option('--role <role>', 'Role ref')
+    .option('--capabilities <items>', 'Comma-separated capabilities')
+    .option('--status <status>', 'online|busy|offline', 'online')
+    .option('--current-task <text>', 'Current task')
+    .option('--json', 'Emit structured JSON output'),
+).action((name, opts) =>
+  runCommand(
     opts,
     () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const token = String(opts.token ?? process.env.WORKGRAPH_TRUST_TOKEN ?? '').trim();
+      const token = readNonEmptyString(opts.token) ?? process.env.WORKGRAPH_TRUST_TOKEN;
       if (!token) {
         throw new Error('Missing trust token. Provide --token or set WORKGRAPH_TRUST_TOKEN.');
       }
-      return workgraph.agent.registerAgent(workspacePath, name, {
+      return workgraph.agent.registerAgent(resolveWorkspacePath(opts), name, {
         token,
+        actor: opts.actor,
         role: opts.role,
         capabilities: csv(opts.capabilities),
-        status: normalizeAgentPresenceStatus(opts.status),
+        status: normalizePresenceStatus(opts.status),
         currentTask: opts.currentTask,
-        actor: opts.actor,
       });
     },
     (result) => [
-      `Registered agent: ${result.agentName}`,
-      `Role: ${result.role} (${result.rolePath})`,
-      `Capabilities: ${result.capabilities.join(', ') || 'none'}`,
+      `Registered actor: ${result.agentName}`,
+      `Role: ${result.role}`,
       `Presence: ${result.presence.path}`,
-      `Policy party: ${result.policyParty.id}`,
-      `Bootstrap token: ${result.trustTokenPath} [${result.trustTokenStatus}]`,
-      ...(result.credential ? [`Credential: ${result.credential.id} [${result.credential.status}]`] : []),
-      ...(result.apiKey ? [`API key (store securely, shown once): ${result.apiKey}`] : []),
     ],
-  );
-});
+  ),
+);
 
 addWorkspaceOption(
   agentCmd
     .command('request <name>')
-    .description('Submit an approval-based agent registration request')
-    .option('--role <role>', 'Requested role slug/path (default: roles/contributor.md)')
-    .option('--capabilities <items>', 'Comma-separated requested extra capabilities')
-    .option('-a, --actor <name>', 'Actor submitting the request')
-    .option('--note <text>', 'Optional request note')
-    .option('--json', 'Emit structured JSON output')
+    .description('Submit an actor registration request')
+    .option('-a, --actor <actor>', 'Actor performing the update', DEFAULT_ACTOR)
+    .option('--role <role>', 'Requested role ref')
+    .option('--capabilities <items>', 'Comma-separated capabilities')
+    .option('--note <text>', 'Request note')
+    .option('--json', 'Emit structured JSON output'),
 ).action((name, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.agent.submitRegistrationRequest(workspacePath, name, {
-        role: opts.role,
-        capabilities: csv(opts.capabilities),
-        actor: opts.actor,
-        note: opts.note,
-      });
-    },
+    () => workgraph.agent.submitRegistrationRequest(resolveWorkspacePath(opts), name, {
+      actor: opts.actor,
+      role: opts.role,
+      capabilities: csv(opts.capabilities),
+      note: opts.note,
+    }),
     (result) => [
-      `Submitted registration request for ${result.agentName}`,
-      `Request: ${result.request.path}`,
+      `Submitted request: ${result.request.path}`,
       `Requested role: ${result.requestedRolePath}`,
-      `Requested capabilities: ${result.requestedCapabilities.join(', ') || 'none'}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
   agentCmd
     .command('review <requestRef>')
-    .description('Approve or reject a pending registration request')
-    .requiredOption('--decision <decision>', 'approved | rejected')
-    .option('-a, --actor <name>', 'Reviewer actor', DEFAULT_ACTOR)
-    .option('--role <role>', 'Approved role slug/path (for approved decisions)')
-    .option('--capabilities <items>', 'Comma-separated approved extra capabilities')
-    .option('--scopes <items>', 'Comma-separated credential scopes (defaults to approved capabilities)')
-    .option('--expires-at <isoDate>', 'Optional credential expiry ISO date')
-    .option('--note <text>', 'Optional review note')
-    .option('--json', 'Emit structured JSON output')
+    .description('Approve or reject a registration request')
+    .requiredOption('--decision <decision>', 'approved|rejected')
+    .option('-a, --actor <actor>', 'Reviewer actor', DEFAULT_ACTOR)
+    .option('--role <role>', 'Approved role ref')
+    .option('--capabilities <items>', 'Comma-separated capabilities')
+    .option('--scopes <items>', 'Comma-separated credential scopes')
+    .option('--expires-at <iso>', 'Credential expiry')
+    .option('--note <text>', 'Review note')
+    .option('--json', 'Emit structured JSON output'),
 ).action((requestRef, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const decision = String(opts.decision ?? '').trim().toLowerCase();
-      if (decision !== 'approved' && decision !== 'rejected') {
-        throw new Error('Invalid --decision value. Expected approved|rejected.');
-      }
-      return workgraph.agent.reviewRegistrationRequest(
-        workspacePath,
-        requestRef,
-        opts.actor,
-        decision,
-        {
-          role: opts.role,
-          capabilities: csv(opts.capabilities),
-          scopes: csv(opts.scopes),
-          expiresAt: opts.expiresAt,
-          note: opts.note,
-        },
-      );
-    },
+    () => workgraph.agent.reviewRegistrationRequest(
+      resolveWorkspacePath(opts),
+      requestRef,
+      opts.actor,
+      normalizeRegistrationDecision(opts.decision),
+      {
+        role: opts.role,
+        capabilities: csv(opts.capabilities),
+        scopes: csv(opts.scopes),
+        expiresAt: opts.expiresAt,
+        note: opts.note,
+      },
+    ),
     (result) => [
       `Reviewed request: ${result.request.path}`,
       `Decision: ${result.decision}`,
-      `Approval record: ${result.approval.path}`,
-      ...(result.policyParty
-        ? [`Policy party: ${result.policyParty.id} (${result.policyParty.roles.join(', ')})`]
-        : []),
-      ...(result.credential ? [`Credential: ${result.credential.id} [${result.credential.status}]`] : []),
-      ...(result.apiKey ? [`API key (store securely, shown once): ${result.apiKey}`] : []),
+      `Approval: ${result.approval.path}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
   agentCmd
     .command('credential-list')
-    .description('List issued agent credentials')
-    .option('--actor <name>', 'Filter by actor id')
-    .option('--json', 'Emit structured JSON output')
+    .description('List actor credentials')
+    .option('--actor-filter <name>', 'Optional actor filter')
+    .option('--json', 'Emit structured JSON output'),
 ).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const credentials = workgraph.agent.listAgentCredentials(workspacePath, opts.actor);
-      return {
-        credentials,
-        count: credentials.length,
-      };
-    },
-    (result) => {
-      if (result.credentials.length === 0) return ['No credentials found.'];
-      return [
-        ...result.credentials.map((credential) =>
-          `${credential.id} actor=${credential.actor} status=${credential.status} scopes=${credential.scopes.join(', ') || 'none'}`
-        ),
-        `${result.count} credential(s)`,
-      ];
-    },
-  )
+    () => ({
+      credentials: workgraph.agent.listAgentCredentials(resolveWorkspacePath(opts), opts.actorFilter),
+    }),
+    (result) => result.credentials.length > 0
+      ? result.credentials.map((entry) => `${entry.id} actor=${entry.actor} status=${entry.status}`)
+      : ['No credentials found.'],
+  ),
 );
 
 addWorkspaceOption(
   agentCmd
     .command('credential-revoke <credentialId>')
-    .description('Revoke an issued credential')
-    .option('-a, --actor <name>', 'Actor revoking the credential', DEFAULT_ACTOR)
-    .option('--reason <text>', 'Optional revocation reason')
-    .option('--json', 'Emit structured JSON output')
+    .description('Revoke an actor credential')
+    .option('-a, --actor <actor>', 'Actor performing the update', DEFAULT_ACTOR)
+    .option('--reason <text>', 'Revocation reason')
+    .option('--json', 'Emit structured JSON output'),
 ).action((credentialId, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        credential: workgraph.agent.revokeAgentCredential(
-          workspacePath,
-          credentialId,
-          opts.actor,
-          opts.reason,
-        ),
-      };
-    },
-    (result) => [
-      `Revoked credential: ${result.credential.id}`,
-      `Actor: ${result.credential.actor}`,
-      `Status: ${result.credential.status}`,
-    ],
-  )
+    () => workgraph.agent.revokeAgentCredential(resolveWorkspacePath(opts), credentialId, opts.actor, opts.reason),
+    (result) => [`Revoked credential ${result.id} for ${result.actor}.`],
+  ),
 );
 
 addWorkspaceOption(
   agentCmd
     .command('list')
-    .description('List known agent presence entries')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ agents: PrimitiveRecord[]; count: number }>('workgraph_agent_list', {})),
-      (result) => {
-        if (result.agents.length === 0) return ['No agent presence entries found.'];
-        return [
-          ...result.agents.map((entry) => {
-            const name = String(entry.fields.name ?? entry.path);
-            const status = String(entry.fields.status ?? 'unknown');
-            const task = String(entry.fields.current_task ?? 'none');
-            const lastSeen = String(entry.fields.last_seen ?? 'unknown');
-            return `${name} [${status}] task=${task} last_seen=${lastSeen}`;
-          }),
-          `${result.count} agent(s)`,
-        ];
-      },
-    );
-  }
-  return runCommand(
+    .description('List actor presence entries')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
+  runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const agents = workgraph.agent.list(workspacePath);
-      return {
-        agents,
-        count: agents.length,
-      };
-    },
-    (result) => {
-      if (result.agents.length === 0) return ['No agent presence entries found.'];
-      return [
-        ...result.agents.map((entry) => {
-          const name = String(entry.fields.name ?? entry.path);
-          const status = String(entry.fields.status ?? 'unknown');
-          const task = String(entry.fields.current_task ?? 'none');
-          const lastSeen = String(entry.fields.last_seen ?? 'unknown');
-          return `${name} [${status}] task=${task} last_seen=${lastSeen}`;
-        }),
-        `${result.count} agent(s)`,
-      ];
-    },
-  );
-});
-
-// ============================================================================
-// primitive
-// ============================================================================
+    () => ({ agents: workgraph.agent.list(resolveWorkspacePath(opts)) }),
+    (result) => result.agents.length > 0
+      ? result.agents.map((entry) => `${String(entry.fields.name)} (${String(entry.fields.status)}) -> ${entry.path}`)
+      : ['No actors found.'],
+  ),
+);
 
 const primitiveCmd = program
   .command('primitive')
-  .description('Manage primitive type definitions and instances');
+  .description('Manage primitive schemas and instances');
 
 addWorkspaceOption(
   primitiveCmd
     .command('define <name>')
     .description('Define a new primitive type')
-    .requiredOption('-d, --description <desc>', 'Type description')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--fields <specs...>', 'Field definitions as "name:type"')
-    .option('--dir <directory>', 'Storage directory override')
-    .option('--json', 'Emit structured JSON output')
+    .requiredOption('--description <text>', 'Type description')
+    .option('-a, --actor <actor>', 'Actor', DEFAULT_ACTOR)
+    .option('--directory <dir>', 'Storage directory')
+    .option('--field <name:type>', 'Repeatable field definition', collectFieldSpecs, [])
+    .option('--json', 'Emit structured JSON output'),
 ).action((name, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const fields: Record<string, workgraph.FieldDefinition> = {};
-      for (const spec of opts.fields ?? []) {
-        const [fieldName, fieldType = 'string'] = String(spec).split(':');
-        fields[fieldName.trim()] = { type: fieldType.trim() as workgraph.FieldDefinition['type'] };
-      }
-      const type = workgraph.registry.defineType(
-        workspacePath,
-        name,
-        opts.description,
-        fields,
-        opts.actor,
-        opts.dir
-      );
-      workgraph.bases.syncPrimitiveRegistryManifest(workspacePath);
-      const baseResult = workgraph.bases.generateBasesFromPrimitiveRegistry(workspacePath, {
-        includeNonCanonical: true,
-      });
-      return {
-        type,
-        basesGenerated: baseResult.generated.length,
-      };
-    },
+    () => workgraph.registry.defineType(
+      resolveWorkspacePath(opts),
+      name,
+      opts.description,
+      parseFieldDefinitions(opts.field),
+      opts.actor,
+      opts.directory,
+    ),
     (result) => [
-      `Defined type: ${result.type.name}`,
-      `Directory: ${result.type.directory}/`,
-      `Bases generated: ${result.basesGenerated}`,
-    ]
-  )
+      `Defined primitive type: ${result.name}`,
+      `Directory: ${result.directory}`,
+    ],
+  ),
 );
 
-registerPrimitiveSchemaCommand('schema', 'Show supported fields for a primitive type');
-registerPrimitiveSchemaCommand('fields', 'Alias for schema');
-
-// ============================================================================
-// bases
-// ============================================================================
-
-const basesCmd = program
-  .command('bases')
-  .description('Generate Obsidian .base files from primitive-registry.yaml');
-
 addWorkspaceOption(
-  basesCmd
-    .command('sync-registry')
-    .description('Sync .workgraph/primitive-registry.yaml from active registry')
-    .option('--json', 'Emit structured JSON output')
+  primitiveCmd
+    .command('list')
+    .description('List registered primitive types')
+    .option('--json', 'Emit structured JSON output'),
 ).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const manifest = workgraph.bases.syncPrimitiveRegistryManifest(workspacePath);
-      return {
-        primitiveCount: manifest.primitives.length,
-        manifestPath: '.workgraph/primitive-registry.yaml',
-      };
-    },
-    (result) => [
-      `Synced primitive registry manifest: ${result.manifestPath}`,
-      `Primitives: ${result.primitiveCount}`,
-    ]
-  )
+    () => ({ types: workgraph.registry.listTypes(resolveWorkspacePath(opts)) }),
+    (result) => result.types.map((type) => `${type.name} -> ${type.directory}`),
+  ),
 );
 
-addWorkspaceOption(
-  basesCmd
-    .command('generate')
-    .description('Generate .base files by reading primitive-registry.yaml')
-    .option('--all', 'Include non-canonical primitives')
-    .option('--refresh-registry', 'Refresh primitive-registry.yaml before generation')
-    .option('--output-dir <path>', 'Output directory for .base files (default: .workgraph/bases)')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      if (opts.refreshRegistry) {
-        workgraph.bases.syncPrimitiveRegistryManifest(workspacePath);
-      }
-      return workgraph.bases.generateBasesFromPrimitiveRegistry(workspacePath, {
-        includeNonCanonical: !!opts.all,
-        outputDirectory: opts.outputDir,
-      });
-    },
-    (result) => [
-      `Generated ${result.generated.length} .base file(s)`,
-      `Directory: ${result.outputDirectory}`,
-    ]
-  )
-);
-
-addWorkspaceOption(
-  primitiveCmd
-    .command('list')
-    .description('List primitive types')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const types = workgraph.registry.listTypes(workspacePath);
-      return { types, count: types.length };
-    },
-    (result) => result.types.map(t => `${t.name} (${t.directory}/) ${t.builtIn ? '[built-in]' : ''}`)
-  )
-);
-
-function registerPrimitiveSchemaCommand(commandName: string, description: string): void {
-  addWorkspaceOption(
-    primitiveCmd
-      .command(`${commandName} <typeName>`)
-      .description(description)
-      .option('--json', 'Emit structured JSON output')
-  ).action((typeName, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const typeDef = workgraph.registry.getType(workspacePath, typeName);
-        if (!typeDef) {
-          throw new Error(`Unknown primitive type "${typeName}". Use \`workgraph primitive list\` to inspect available types.`);
-        }
-        const fields = Object.entries(typeDef.fields).map(([name, definition]) => ({
-          name,
-          type: definition.type,
-          required: definition.required === true,
-          default: definition.default,
-          enum: definition.enum ?? [],
-          description: definition.description ?? '',
-          template: definition.template ?? undefined,
-          pattern: definition.pattern ?? undefined,
-          refTypes: definition.refTypes ?? [],
-        }));
-        return {
-          type: typeDef.name,
-          description: typeDef.description,
-          directory: typeDef.directory,
-          builtIn: typeDef.builtIn,
-          fields,
-        };
-      },
-      (result) => [
-        `Type: ${result.type}`,
-        `Directory: ${result.directory}/`,
-        `Built-in: ${result.builtIn}`,
-        ...result.fields.map((field) =>
-          `- ${field.name}: ${field.type}${field.required ? ' (required)' : ''}${field.description ? ` — ${field.description}` : ''}`),
-      ],
-    )
-  );
-}
-
 addWorkspaceOption(
   primitiveCmd
     .command('create <type> <title>')
-    .description('Create an instance of any primitive type')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--set <fields...>', 'Set fields as "key=value"')
-    .option('--body <text>', 'Markdown body content', '')
-    .option('--json', 'Emit structured JSON output')
+    .description('Create a primitive instance')
+    .option('-a, --actor <actor>', 'Actor', DEFAULT_ACTOR)
+    .option('--body <markdown>', 'Markdown body')
+    .option('--set <key=value>', 'Repeatable field assignment', collectSetPairs, [])
+    .option('--json', 'Emit structured JSON output'),
 ).action((type, title, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const fields: Record<string, unknown> = { title, ...parseSetPairs(opts.set ?? []) };
-      return {
-        instance: workgraph.store.create(workspacePath, type, fields, opts.body, opts.actor),
-      };
-    },
-    (result) => [`Created ${result.instance.type}: ${result.instance.path}`]
-  )
+    () => workgraph.store.create(
+      resolveWorkspacePath(opts),
+      type,
+      {
+        title,
+        ...mergeSetPairs(opts.set),
+      },
+      opts.body ?? '',
+      opts.actor,
+    ),
+    (result) => [`Created primitive: ${result.path}`],
+  ),
 );
 
 addWorkspaceOption(
   primitiveCmd
     .command('update <path>')
-    .description('Update an existing primitive instance')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--set <fields...>', 'Set fields as "key=value"')
+    .description('Update a primitive instance')
+    .option('-a, --actor <actor>', 'Actor', DEFAULT_ACTOR)
+    .option('--body <markdown>', 'Replace markdown body')
+    .option('--set <key=value>', 'Repeatable field assignment', collectSetPairs, [])
     .option('--etag <etag>', 'Expected etag for optimistic concurrency')
-    .option('--body <text>', 'Replace markdown body content')
-    .option('--body-file <path>', 'Read markdown body content from file')
-    .option('--json', 'Emit structured JSON output')
+    .option('--json', 'Emit structured JSON output'),
 ).action((targetPath, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const updates = parseSetPairs(opts.set ?? []);
-      let body: string | undefined = opts.body;
-      if (opts.bodyFile) {
-        body = fs.readFileSync(path.resolve(opts.bodyFile), 'utf-8');
-      }
-      return {
-        instance: workgraph.store.update(workspacePath, targetPath, updates, body, opts.actor, {
-          expectedEtag: opts.etag,
-        }),
-      };
-    },
-    (result) => [`Updated ${result.instance.type}: ${result.instance.path}`]
-  )
-);
-
-// ============================================================================
-// skill
-// ============================================================================
-
-const skillCmd = program
-  .command('skill')
-  .description('Manage native skill primitives in shared workgraph vaults');
-
-addWorkspaceOption(
-  skillCmd
-    .command('write <title>')
-    .description('Create or update a skill primitive')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--owner <name>', 'Skill owner')
-    .option('--skill-version <semver>', 'Skill version')
-    .option('--status <status>', 'draft | proposed | active | deprecated | archived')
-    .option('--distribution <mode>', 'Distribution mode', 'tailscale-shared-vault')
-    .option('--tailscale-path <path>', 'Shared Tailscale workspace path')
-    .option('--reviewers <list>', 'Comma-separated reviewer names')
-    .option('--depends-on <list>', 'Comma-separated skill dependencies (slug/path)')
-    .option('--expected-updated-at <iso>', 'Optimistic concurrency guard for updates')
-    .option('--tags <list>', 'Comma-separated tags')
-    .option('--body <text>', 'Skill markdown content')
-    .option('--body-file <path>', 'Read markdown content from file')
-    .option('--json', 'Emit structured JSON output')
-).action((title, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      let body = opts.body ?? '';
-      if (opts.bodyFile) {
-        const absBodyFile = path.resolve(opts.bodyFile);
-        body = fs.readFileSync(absBodyFile, 'utf-8');
-      }
-      const instance = workgraph.skill.writeSkill(
-        workspacePath,
-        title,
-        body,
-        opts.actor,
-        {
-          owner: opts.owner,
-          version: opts.skillVersion,
-          status: opts.status,
-          distribution: opts.distribution,
-          tailscalePath: opts.tailscalePath,
-          reviewers: csv(opts.reviewers),
-          dependsOn: csv(opts.dependsOn),
-          expectedUpdatedAt: opts.expectedUpdatedAt,
-          tags: csv(opts.tags),
-        }
-      );
-      workgraph.bases.syncPrimitiveRegistryManifest(workspacePath);
-      workgraph.bases.generateBasesFromPrimitiveRegistry(workspacePath, { includeNonCanonical: true });
-      return { skill: instance };
-    },
-    (result) => [
-      `Wrote skill: ${result.skill.path}`,
-      `Status: ${String(result.skill.fields.status)} Version: ${String(result.skill.fields.version)}`,
-    ]
-  )
-);
-
-addWorkspaceOption(
-  skillCmd
-    .command('load <skillRef>')
-    .description('Load one skill primitive by slug or path')
-    .option('--json', 'Emit structured JSON output')
-).action((skillRef, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return { skill: workgraph.skill.loadSkill(workspacePath, skillRef) };
-    },
-    (result) => [
-      `Skill: ${String(result.skill.fields.title)}`,
-      `Path: ${result.skill.path}`,
-      `Status: ${String(result.skill.fields.status)}`,
-    ]
-  )
-);
-
-addWorkspaceOption(
-  skillCmd
-    .command('list')
-    .description('List skills')
-    .option('--status <status>', 'Filter by status')
-    .option('--updated-since <iso>', 'Filter by updated timestamp (ISO-8601)')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const skills = workgraph.skill.listSkills(workspacePath, {
-        status: opts.status,
-        updatedSince: opts.updatedSince,
-      });
-      return { skills, count: skills.length };
-    },
-    (result) => result.skills.map((skill) =>
-      `${String(skill.fields.title)} [${String(skill.fields.status)}] -> ${skill.path}`)
-  )
-);
-
-addWorkspaceOption(
-  skillCmd
-    .command('history <skillRef>')
-    .description('Show ledger history entries for one skill')
-    .option('--limit <n>', 'Limit number of returned entries')
-    .option('--json', 'Emit structured JSON output')
-).action((skillRef, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        entries: workgraph.skill.skillHistory(workspacePath, skillRef, {
-          limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-        }),
-      };
-    },
-    (result) => result.entries.map((entry) => `${entry.ts} ${entry.op} ${entry.actor}`),
-  )
-);
-
-addWorkspaceOption(
-  skillCmd
-    .command('diff <skillRef>')
-    .description('Show latest field-change summary for one skill')
-    .option('--json', 'Emit structured JSON output')
-).action((skillRef, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.skill.skillDiff(workspacePath, skillRef);
-    },
-    (result) => [
-      `Skill: ${result.path}`,
-      `Latest: ${result.latestEntryTs ?? 'none'}`,
-      `Previous: ${result.previousEntryTs ?? 'none'}`,
-      `Changed fields: ${result.changedFields.join(', ') || 'none'}`,
-    ],
-  )
-);
-
-addWorkspaceOption(
-  skillCmd
-    .command('propose <skillRef>')
-    .description('Move a skill into proposed state and open review thread')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--proposal-thread <path>', 'Explicit proposal thread path')
-    .option('--no-create-thread', 'Do not create a proposal thread automatically')
-    .option('--space <spaceRef>', 'Space for created proposal thread')
-    .option('--reviewers <list>', 'Comma-separated reviewers')
-    .option('--json', 'Emit structured JSON output')
-).action((skillRef, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        skill: workgraph.skill.proposeSkill(workspacePath, skillRef, opts.actor, {
-          proposalThread: opts.proposalThread,
-          createThreadIfMissing: opts.createThread,
-          space: opts.space,
-          reviewers: csv(opts.reviewers),
-        }),
-      };
-    },
-    (result) => [
-      `Proposed skill: ${result.skill.path}`,
-      `Proposal thread: ${String(result.skill.fields.proposal_thread ?? 'none')}`,
-    ]
-  )
-);
-
-addWorkspaceOption(
-  skillCmd
-    .command('promote <skillRef>')
-    .description('Promote a proposed/draft skill to active')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--skill-version <semver>', 'Explicit promoted version')
-    .option('--json', 'Emit structured JSON output')
-).action((skillRef, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        skill: workgraph.skill.promoteSkill(workspacePath, skillRef, opts.actor, {
-          version: opts.skillVersion,
-        }),
-      };
-    },
-    (result) => [
-      `Promoted skill: ${result.skill.path}`,
-      `Status: ${String(result.skill.fields.status)} Version: ${String(result.skill.fields.version)}`,
-    ]
-  )
-);
-
-// ============================================================================
-// integration
-// ============================================================================
-
-const integrationCmd = program
-  .command('integration')
-  .description('Manage optional third-party integrations');
-
-addWorkspaceOption(
-  integrationCmd
-    .command('list')
-    .description('List supported optional integrations')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => ({
-      integrations: workgraph.integration.listIntegrations(),
-    }),
-    (result) => result.integrations.map((integration) =>
-      `${integration.id} (${integration.defaultTitle}) -> ${integration.defaultSourceUrl}`)
-  )
-);
-
-addWorkspaceOption(
-  integrationCmd
-    .command('install <integrationName>')
-    .description('Install an optional integration into this workspace')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--owner <name>', 'Skill owner override')
-    .option('--title <title>', 'Skill title to store in workgraph')
-    .option('--source-url <url>', 'Source URL override for integration content')
-    .option('--force', 'Overwrite an existing imported integration skill')
-    .option('--json', 'Emit structured JSON output')
-).action((integrationName, opts) =>
-  runCommand(
-    opts,
-    () => installNamedIntegration(resolveWorkspacePath(opts), integrationName, opts),
-    renderInstalledIntegrationResult,
-  )
-);
-
-addWorkspaceOption(
-  integrationCmd
-    .command('clawdapus')
-    .description('Import Clawdapus SKILL.md into this workspace')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--owner <name>', 'Skill owner override')
-    .option('--title <title>', 'Skill title to store in workgraph', 'clawdapus')
-    .option(
-      '--source-url <url>',
-      'Source URL for Clawdapus SKILL.md',
-      workgraph.clawdapus.DEFAULT_CLAWDAPUS_SKILL_URL,
-    )
-    .option('--force', 'Overwrite an existing imported Clawdapus skill')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => installNamedIntegration(resolveWorkspacePath(opts), 'clawdapus', opts),
-    renderInstalledIntegrationResult,
-  )
-);
-
-// ============================================================================
-// ledger
-// ============================================================================
-
-const ledgerCmd = program
-  .command('ledger')
-  .description('Inspect the append-only workgraph ledger');
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('show')
-    .description('Show recent ledger entries')
-    .option('-n, --count <n>', 'Number of entries', '20')
-    .option('--actor <name>', 'Filter by actor')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const count = Number.parseInt(String(opts.count), 10);
-      const safeCount = Number.isNaN(count) ? 20 : count;
-      let entries = workgraph.ledger.recent(workspacePath, safeCount);
-      if (opts.actor) entries = entries.filter(e => e.actor === opts.actor);
-      return { entries, count: entries.length };
-    },
-    (result) => result.entries.map(e => `${e.ts} ${e.op} ${e.actor} ${e.target}`)
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('history <targetPath>')
-    .description('Show full history of a target path')
-    .option('--json', 'Emit structured JSON output')
-).action((targetPath, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const entries = workgraph.ledger.historyOf(workspacePath, targetPath);
-      return { target: targetPath, entries, count: entries.length };
-    },
-    (result) => result.entries.map(e => `${e.ts} ${e.op} ${e.actor}`)
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('claims')
-    .description('Show active claims')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const claimsMap = workgraph.ledger.allClaims(workspacePath);
-      const claims = [...claimsMap.entries()].map(([target, owner]) => ({ target, owner }));
-      return { claims, count: claims.length };
-    },
-    (result) => result.claims.map(c => `${c.owner} -> ${c.target}`)
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('query')
-    .description('Query ledger with structured filters')
-    .option('--actor <name>', 'Filter by actor')
-    .option('--op <operation>', 'Filter by operation')
-    .option('--type <primitiveType>', 'Filter by primitive type')
-    .option('--target <path>', 'Filter by exact target path')
-    .option('--target-includes <text>', 'Filter by target substring')
-    .option('--since <iso>', 'Filter entries on/after ISO timestamp')
-    .option('--until <iso>', 'Filter entries on/before ISO timestamp')
-    .option('--limit <n>', 'Limit number of results')
-    .option('--offset <n>', 'Offset into result set')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        entries: workgraph.ledger.query(workspacePath, {
-          actor: opts.actor,
-          op: opts.op,
-          type: opts.type,
-          target: opts.target,
-          targetIncludes: opts.targetIncludes,
-          since: opts.since,
-          until: opts.until,
-          limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-          offset: opts.offset ? Number.parseInt(String(opts.offset), 10) : undefined,
-        }),
-      };
-    },
-    (result) => result.entries.map((entry) => `${entry.ts} ${entry.op} ${entry.actor} ${entry.target}`)
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('blame <targetPath>')
-    .description('Show actor attribution summary for one target')
-    .option('--json', 'Emit structured JSON output')
-).action((targetPath, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.ledger.blame(workspacePath, targetPath);
-    },
-    (result) => [
-      `Target: ${result.target}`,
-      `Entries: ${result.totalEntries}`,
-      ...result.actors.map((actor) => `${actor.actor}: ${actor.count} change(s)`),
-    ]
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('verify')
-    .description('Verify tamper-evident ledger hash-chain integrity')
-    .option('--strict', 'Treat missing hash fields as verification failures')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.ledger.verifyHashChain(workspacePath, { strict: !!opts.strict });
-    },
-    (result) => [
-      `Hash-chain valid: ${result.ok}`,
-      `Entries: ${result.entries}`,
-      `Last hash: ${result.lastHash}`,
-      ...(result.issues.length > 0 ? result.issues.map((issue) => `ISSUE: ${issue}`) : []),
-      ...(result.warnings.length > 0 ? result.warnings.map((warning) => `WARN: ${warning}`) : []),
-    ]
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('reconcile')
-    .description('Audit thread files against ledger claims, leases, and dependency wiring')
-    .option('--fail-on-issues', 'Exit non-zero when issues are found')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const report = workgraph.threadAudit.reconcileThreadState(workspacePath);
-      if (opts.failOnIssues && !report.ok) {
-        throw new Error(`Ledger reconcile found ${report.issues.length} issue(s).`);
-      }
-      return report;
-    },
-    (result) => [
-      `Reconcile ok: ${result.ok}`,
-      `Threads: ${result.totalThreads} Claims: ${result.totalClaims} Leases: ${result.totalLeases}`,
-      ...(result.issues.length > 0
-        ? result.issues.map((issue) => `${issue.kind}: ${issue.path} — ${issue.message}`)
-        : ['No reconcile issues found.']),
-    ]
-  )
-);
-
-addWorkspaceOption(
-  ledgerCmd
-    .command('seal')
-    .description('Rebuild ledger index + hash-chain state from ledger.jsonl')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const index = workgraph.ledger.rebuildIndex(workspacePath);
-      const chain = workgraph.ledger.rebuildHashChainState(workspacePath);
-      return {
-        indexClaims: Object.keys(index.claims).length,
-        chainCount: chain.count,
-        chainLastHash: chain.lastHash,
-      };
-    },
-    (result) => [
-      `Rebuilt ledger index claims: ${result.indexClaims}`,
-      `Rebuilt chain entries: ${result.chainCount}`,
-    ]
-  )
-);
-
-// ============================================================================
-// diagnostics / developer experience
-// ============================================================================
-
-addWorkspaceOption(
-  program
-    .command('doctor')
-    .description('Diagnose vault health, warnings, and repairable issues')
-    .option('--fix', 'Auto-repair safe issues (orphan links, stale claims/runs)')
-    .option('--stale-after-minutes <n>', 'Threshold for stale claims/runs in minutes', '60')
-    .option('-a, --actor <name>', 'Actor used for --fix mutations', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const staleAfterMinutes = Number.parseInt(String(opts.staleAfterMinutes), 10);
-      const safeStaleAfterMinutes = Number.isNaN(staleAfterMinutes) ? 60 : Math.max(1, staleAfterMinutes);
-      return workgraph.diagnostics.diagnoseVaultHealth(workspacePath, {
-        fix: !!opts.fix,
-        actor: opts.actor,
-        staleAfterMs: safeStaleAfterMinutes * 60 * 1000,
-      });
-    },
-    (result) => workgraph.diagnostics.renderDoctorReport(result),
-  )
-);
-
-addWorkspaceOption(
-  program
-    .command('replay')
-    .description('Replay ledger events chronologically with typed filters')
-    .option('--type <type>', 'create | update | transition')
-    .option('--actor <name>', 'Filter by actor')
-    .option('--primitive <ref>', 'Filter by primitive path/type substring')
-    .option('--since <iso>', 'Filter events on/after ISO timestamp')
-    .option('--until <iso>', 'Filter events on/before ISO timestamp')
-    .option('--no-color', 'Disable colorized output')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.diagnostics.replayLedger(workspacePath, {
-        type: opts.type,
-        actor: opts.actor,
-        primitive: opts.primitive,
-        since: opts.since,
-        until: opts.until,
-      });
-    },
-    (result) => workgraph.diagnostics.renderReplayText(result, {
-      color: opts.color !== false && !wantsJson(opts),
-    }),
-  )
-);
-
-addWorkspaceOption(
-  program
-    .command('viz')
-    .description('Render an ASCII wiki-link graph of primitives in this vault')
-    .option('--focus <slugOrPath>', 'Center the graph on a specific node')
-    .option('--depth <n>', 'Traversal depth from each root', '2')
-    .option('--top <n>', 'When large, show top N most-connected roots', '10')
-    .option('--no-color', 'Disable colorized output')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const parsedDepth = Number.parseInt(String(opts.depth), 10);
-      const parsedTop = Number.parseInt(String(opts.top), 10);
-      return workgraph.diagnostics.visualizeVaultGraph(workspacePath, {
-        focus: opts.focus,
-        depth: Number.isNaN(parsedDepth) ? 2 : Math.max(1, parsedDepth),
-        top: Number.isNaN(parsedTop) ? 10 : Math.max(1, parsedTop),
-        color: opts.color !== false && !wantsJson(opts),
-      });
-    },
-    (result) => [
-      ...result.rendered.split('\n'),
-      '',
-      `Nodes: ${result.nodeCount}`,
-      `Edges: ${result.edgeCount}`,
-      ...(result.focus ? [`Focus: ${result.focus}`] : []),
-    ],
-  )
-);
-
-addWorkspaceOption(
-  program
-    .command('stats')
-    .description('Show detailed vault statistics and graph/ledger health metrics')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.diagnostics.computeVaultStats(workspacePath);
-    },
-    (result) => workgraph.diagnostics.renderStatsReport(result),
-  )
-);
-
-addWorkspaceOption(
-  program
-    .command('changelog')
-    .description('Generate a human-readable changelog from ledger events')
-    .requiredOption('--since <date>', 'Include entries on/after this date (ISO-8601)')
-    .option('--until <date>', 'Include entries on/before this date (ISO-8601)')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.diagnostics.generateLedgerChangelog(workspacePath, {
-        since: opts.since,
-        until: opts.until,
-      });
-    },
-    (result) => workgraph.diagnostics.renderChangelogText(result),
-  )
-);
-
-addWorkspaceOption(
-  program
-    .command('command-center')
-    .description('Generate a markdown command center from workgraph state')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('-o, --output <path>', 'Output markdown path', 'Command Center.md')
-    .option('-n, --recent <count>', 'Recent ledger entries to include', '15')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const parsedRecent = Number.parseInt(String(opts.recent), 10);
-      const safeRecent = Number.isNaN(parsedRecent) ? 15 : parsedRecent;
-      return workgraph.commandCenter.generateCommandCenter(workspacePath, {
-        actor: opts.actor,
-        outputPath: opts.output,
-        recentCount: safeRecent,
-      });
-    },
-    (result) => [
-      `Generated command center: ${result.outputPath}`,
-      `Threads: total=${result.stats.totalThreads} open=${result.stats.openThreads} active=${result.stats.activeThreads} blocked=${result.stats.blockedThreads}`,
-      `Claims: ${result.stats.activeClaims} Recent events: ${result.stats.recentEvents}`,
-    ]
-  )
-);
-
-// ============================================================================
-// orientation
-// ============================================================================
-
-addWorkspaceOption(
-  program
-    .command('status')
-    .description('Show workspace situational status snapshot')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<ReturnType<typeof workgraph.orientation.statusSnapshot>>('workgraph_status', {})),
-      (result) => [
-        `Threads: total=${result.threads.total} open=${result.threads.open} active=${result.threads.active} blocked=${result.threads.blocked} done=${result.threads.done}`,
-        `Ready threads: ${result.threads.ready} Active claims: ${result.claims.active}`,
-        `Primitive types: ${Object.keys(result.primitives.byType).length}`,
-      ],
-    );
-  }
-  return runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.orientation.statusSnapshot(workspacePath);
-    },
-    (result) => [
-      `Threads: total=${result.threads.total} open=${result.threads.open} active=${result.threads.active} blocked=${result.threads.blocked} done=${result.threads.done}`,
-      `Ready threads: ${result.threads.ready} Active claims: ${result.claims.active}`,
-      `Primitive types: ${Object.keys(result.primitives.byType).length}`,
-    ],
-  );
-});
-
-addWorkspaceOption(
-  program
-    .command('brief')
-    .description('Show actor-centric operational brief')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--recent <count>', 'Recent activity count', '12')
-    .option('--next <count>', 'Next ready threads to include', '5')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<ReturnType<typeof workgraph.orientation.brief>>('workgraph_brief', {
-          actor: opts.actor,
-          recentCount: Number.parseInt(String(opts.recent), 10),
-          nextCount: Number.parseInt(String(opts.next), 10),
-        })),
-      (result) => [
-        `Brief for ${result.actor}`,
-        `My claims: ${result.myClaims.length}`,
-        `Blocked threads: ${result.blockedThreads.length}`,
-        `Next ready: ${result.nextReadyThreads.map((item) => item.path).join(', ') || 'none'}`,
-      ],
-    );
-  }
-  return runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.orientation.brief(workspacePath, opts.actor, {
-        recentCount: Number.parseInt(String(opts.recent), 10),
-        nextCount: Number.parseInt(String(opts.next), 10),
-      });
-    },
-    (result) => [
-      `Brief for ${result.actor}`,
-      `My claims: ${result.myClaims.length}`,
-      `Blocked threads: ${result.blockedThreads.length}`,
-      `Next ready: ${result.nextReadyThreads.map((item) => item.path).join(', ') || 'none'}`,
-    ],
-  );
-});
-
-addWorkspaceOption(
-  program
-    .command('checkpoint <summary>')
-    .description('Create a checkpoint primitive for hand-off continuity')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--next <items>', 'Comma-separated next actions')
-    .option('--blocked <items>', 'Comma-separated blockers')
-    .option('--tags <items>', 'Comma-separated tags')
-    .option('--json', 'Emit structured JSON output')
-).action((summary, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ checkpoint: PrimitiveRecord }>('workgraph_checkpoint_create', {
-          actor: opts.actor,
-          summary,
-          next: csv(opts.next),
-          blocked: csv(opts.blocked),
-          tags: csv(opts.tags),
-        })),
-      (result) => [`Created checkpoint: ${result.checkpoint.path}`],
-    );
-  }
-  return runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        checkpoint: workgraph.orientation.checkpoint(workspacePath, opts.actor, summary, {
-          next: csv(opts.next),
-          blocked: csv(opts.blocked),
-          tags: csv(opts.tags),
-        }),
-      };
-    },
-    (result) => [`Created checkpoint: ${result.checkpoint.path}`],
-  );
-});
-
-addWorkspaceOption(
-  program
-    .command('intake <observation>')
-    .description('Capture intake observation as lightweight checkpoint note')
-    .option('-a, --actor <name>', 'Agent name', DEFAULT_ACTOR)
-    .option('--tags <items>', 'Comma-separated tags')
-    .option('--json', 'Emit structured JSON output')
-).action((observation, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        intake: workgraph.orientation.intake(workspacePath, opts.actor, observation, {
-          tags: csv(opts.tags),
-        }),
-      };
-    },
-    (result) => [`Captured intake: ${result.intake.path}`],
-  )
-);
-
-// ============================================================================
-// lenses
-// ============================================================================
-
-const lensCmd = program
-  .command('lens')
-  .description('Generate deterministic context lenses for situational awareness');
-
-addWorkspaceOption(
-  lensCmd
-    .command('list')
-    .description('List built-in context lenses')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ lenses: Array<{ id: string; description: string }> }>('workgraph_lens_list', {})),
-      (result) => result.lenses.map((lens) => `lens://${lens.id} - ${lens.description}`),
-    );
-  }
-  return runCommand(
-    opts,
-    () => ({
-      lenses: workgraph.lens.listContextLenses(),
-    }),
-    (result) => result.lenses.map((lens) => `lens://${lens.id} - ${lens.description}`),
-  );
-});
-
-addWorkspaceOption(
-  lensCmd
-    .command('show <lensId>')
-    .description('Generate one context lens snapshot')
-    .option('-a, --actor <name>', 'Actor identity for actor-scoped lenses', DEFAULT_ACTOR)
-    .option('--lookback-hours <hours>', 'Lookback window in hours', '24')
-    .option('--stale-hours <hours>', 'Stale threshold in hours', '24')
-    .option('--limit <n>', 'Maximum items per section', '10')
-    .option('-o, --output <path>', 'Write lens markdown to workspace-relative output path')
-    .option('--json', 'Emit structured JSON output')
-).action((lensId, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) => client.callTool<
-      workgraph.WorkgraphLensResult | workgraph.WorkgraphMaterializedLensResult
-      >('workgraph_lens_show', {
-        lensId,
-        actor: opts.actor,
-        lookbackHours: parsePositiveNumberOption(opts.lookbackHours, 'lookback-hours'),
-        staleHours: parsePositiveNumberOption(opts.staleHours, 'stale-hours'),
-        limit: parsePositiveIntegerOption(opts.limit, 'limit'),
-        outputPath: opts.output,
-      })),
-      (result) => {
-        const metricSummary = Object.entries(result.metrics)
-          .map(([metric, value]) => `${metric}=${value}`)
-          .join(' ');
-        const sectionSummary = result.sections
-          .map((section) => `${section.id}:${section.items.length}`)
-          .join(' ');
-        const lines = [
-          `Lens: ${result.lens}`,
-          `Generated: ${result.generatedAt}`,
-          ...(result.actor ? [`Actor: ${result.actor}`] : []),
-          `Metrics: ${metricSummary || 'none'}`,
-          `Sections: ${sectionSummary || 'none'}`,
-        ];
-        if (isMaterializedLensResult(result)) {
-          lines.push(`Saved markdown: ${result.outputPath}`);
-          return lines;
-        }
-        return [...lines, '', ...result.markdown.split('\n')];
-      },
-    );
-  }
-  return runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const lensOptions = {
-        actor: opts.actor,
-        lookbackHours: parsePositiveNumberOption(opts.lookbackHours, 'lookback-hours'),
-        staleHours: parsePositiveNumberOption(opts.staleHours, 'stale-hours'),
-        limit: parsePositiveIntegerOption(opts.limit, 'limit'),
-      };
-      if (opts.output) {
-        return workgraph.lens.materializeContextLens(workspacePath, lensId, {
-          ...lensOptions,
-          outputPath: opts.output,
-        });
-      }
-      return workgraph.lens.generateContextLens(workspacePath, lensId, lensOptions);
-    },
-    (result) => {
-      const metricSummary = Object.entries(result.metrics)
-        .map(([metric, value]) => `${metric}=${value}`)
-        .join(' ');
-      const sectionSummary = result.sections
-        .map((section) => `${section.id}:${section.items.length}`)
-        .join(' ');
-      const lines = [
-        `Lens: ${result.lens}`,
-        `Generated: ${result.generatedAt}`,
-        ...(result.actor ? [`Actor: ${result.actor}`] : []),
-        `Metrics: ${metricSummary || 'none'}`,
-        `Sections: ${sectionSummary || 'none'}`,
-      ];
-      if (isMaterializedLensResult(result)) {
-        lines.push(`Saved markdown: ${result.outputPath}`);
-        return lines;
-      }
-      return [...lines, '', ...result.markdown.split('\n')];
-    },
-  );
-});
-
-// ============================================================================
-// query/search
-// ============================================================================
-
-addWorkspaceOption(
-  program
-    .command('query')
-    .description('Query primitive instances with multi-field filters')
-    .option('--type <type>', 'Primitive type')
-    .option('--status <status>', 'Status value')
-    .option('--owner <owner>', 'Owner/actor value')
-    .option('--tag <tag>', 'Tag filter')
-    .option('--text <text>', 'Full-text contains filter')
-    .option('--path-includes <text>', 'Path substring filter')
-    .option('--updated-after <iso>', 'Updated at or after')
-    .option('--updated-before <iso>', 'Updated at or before')
-    .option('--created-after <iso>', 'Created at or after')
-    .option('--created-before <iso>', 'Created at or before')
-    .option('--limit <n>', 'Result limit')
-    .option('--offset <n>', 'Result offset')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{ results: PrimitiveRecord[]; count: number }>('workgraph_query', {
-          type: opts.type,
-          status: opts.status,
-          owner: opts.owner,
-          tag: opts.tag,
-          text: opts.text,
-          pathIncludes: opts.pathIncludes,
-          updatedAfter: opts.updatedAfter,
-          updatedBefore: opts.updatedBefore,
-          createdAfter: opts.createdAfter,
-          createdBefore: opts.createdBefore,
-          limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-          offset: opts.offset ? Number.parseInt(String(opts.offset), 10) : undefined,
-        })),
-      (result) => result.results.map((item) => `${item.type} ${item.path}`),
-    );
-  }
-  return runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const results = workgraph.query.queryPrimitives(workspacePath, {
-        type: opts.type,
-        status: opts.status,
-        owner: opts.owner,
-        tag: opts.tag,
-        text: opts.text,
-        pathIncludes: opts.pathIncludes,
-        updatedAfter: opts.updatedAfter,
-        updatedBefore: opts.updatedBefore,
-        createdAfter: opts.createdAfter,
-        createdBefore: opts.createdBefore,
-        limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-        offset: opts.offset ? Number.parseInt(String(opts.offset), 10) : undefined,
-      });
-      return { results, count: results.length };
-    },
-    (result) => result.results.map((item) => `${item.type} ${item.path}`),
-  );
-});
-
-addWorkspaceOption(
-  program
-    .command('search <text>')
-    .description('Keyword search across markdown body/frontmatter with optional QMD-compatible mode')
-    .option('--type <type>', 'Limit to primitive type')
-    .option('--mode <mode>', 'auto | core | qmd', 'auto')
-    .option('--limit <n>', 'Result limit')
-    .option('--json', 'Emit structured JSON output')
-).action((text, opts) => {
-  if (isRemoteMode(opts)) {
-    return runCommand(
-      opts,
-      () => withRemoteClient(opts, (client) =>
-        client.callTool<{
-          mode: string;
-          fallbackReason?: string;
-          results: PrimitiveRecord[];
-          count: number;
-        }>('workgraph_search', {
-          text,
-          mode: opts.mode,
-          type: opts.type,
-          limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-        })),
-      (result) => [
-        `Mode: ${result.mode}`,
-        ...(result.fallbackReason ? [`Note: ${result.fallbackReason}`] : []),
-        ...result.results.map((item) => `${item.type} ${item.path}`),
-      ],
-    );
-  }
-  return runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const result = workgraph.searchQmdAdapter.search(workspacePath, text, {
-        mode: opts.mode,
-        type: opts.type,
-        limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-      });
-      return {
-        ...result,
-        count: result.results.length,
-      };
-    },
-    (result) => [
-      `Mode: ${result.mode}`,
-      ...(result.fallbackReason ? [`Note: ${result.fallbackReason}`] : []),
-      ...result.results.map((item) => `${item.type} ${item.path}`),
-    ],
-  );
-});
-
-// ============================================================================
-// board/graph
-// ============================================================================
-
-const boardCmd = program
-  .command('board')
-  .description('Generate and sync Obsidian Kanban board views');
-
-addWorkspaceOption(
-  boardCmd
-    .command('generate')
-    .description('Generate Obsidian Kanban board markdown from thread states')
-    .option('-o, --output <path>', 'Output board path', 'ops/Workgraph Board.md')
-    .option('--include-cancelled', 'Include cancelled lane')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.board.generateKanbanBoard(workspacePath, {
-        outputPath: opts.output,
-        includeCancelled: !!opts.includeCancelled,
-      });
-    },
-    (result) => [
-      `Generated board: ${result.outputPath}`,
-      `Backlog=${result.counts.backlog} InProgress=${result.counts.inProgress} Blocked=${result.counts.blocked} Done=${result.counts.done}`,
-    ],
-  )
-);
-
-addWorkspaceOption(
-  boardCmd
-    .command('sync')
-    .description('Sync existing board markdown from current thread states')
-    .option('-o, --output <path>', 'Output board path', 'ops/Workgraph Board.md')
-    .option('--include-cancelled', 'Include cancelled lane')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.board.syncKanbanBoard(workspacePath, {
-        outputPath: opts.output,
-        includeCancelled: !!opts.includeCancelled,
-      });
-    },
-    (result) => [
-      `Synced board: ${result.outputPath}`,
-      `Backlog=${result.counts.backlog} InProgress=${result.counts.inProgress} Blocked=${result.counts.blocked} Done=${result.counts.done}`,
-    ],
-  )
-);
-
-const graphCmd = program
-  .command('graph')
-  .description('Wiki-link graph indexing and hygiene');
-
-addWorkspaceOption(
-  graphCmd
-    .command('index')
-    .description('Build wiki-link graph index')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.refreshWikiLinkGraphIndex(workspacePath);
-    },
-    (result) => [
-      `Nodes: ${result.nodes.length}`,
-      `Edges: ${result.edges.length}`,
-      `Broken links: ${result.brokenLinks.length}`,
-    ],
-  )
-);
-
-addWorkspaceOption(
-  graphCmd
-    .command('hygiene')
-    .description('Generate graph hygiene report (orphans, broken links, hubs)')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.graphHygieneReport(workspacePath);
-    },
-    (result) => [
-      `Nodes=${result.nodeCount} Edges=${result.edgeCount}`,
-      `Orphans=${result.orphanCount} BrokenLinks=${result.brokenLinkCount}`,
-      `Top hub: ${result.hubs[0]?.node ?? 'none'}`,
-    ],
-  )
-);
-
-addWorkspaceOption(
-  graphCmd
-    .command('neighborhood <slug>')
-    .description('Find connected primitives within N wiki-link hops')
-    .option('--depth <n>', 'Traversal depth (default: 2)', '2')
-    .option('--refresh', 'Refresh graph index before querying')
-    .option('--json', 'Emit structured JSON output')
-).action((slug, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.graphNeighborhoodQuery(workspacePath, slug, {
-        depth: parseNonNegativeIntOption(opts.depth, 'depth'),
-        refresh: !!opts.refresh,
-      });
-    },
-    (result) => [
-      `Center: ${result.center.path} (${result.center.exists ? 'exists' : 'missing'})`,
-      `Depth: ${result.depth}`,
-      `Connected nodes: ${result.connectedNodes.length}`,
-      `Edges in neighborhood: ${result.edges.length}`,
-    ],
-  )
+    () => workgraph.store.update(
+      resolveWorkspacePath(opts),
+      normalizePath(targetPath),
+      mergeSetPairs(opts.set),
+      opts.body,
+      opts.actor,
+      {
+        expectedEtag: opts.etag,
+      },
+    ),
+    (result) => [`Updated primitive: ${result.path}`],
+  ),
 );
 
 addWorkspaceOption(
-  graphCmd
-    .command('impact <slug>')
-    .description('Analyze reverse-link impact for a primitive')
-    .option('--refresh', 'Refresh graph index before querying')
-    .option('--json', 'Emit structured JSON output')
-).action((slug, opts) =>
+  program
+    .command('status')
+    .description('Show workspace status')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.graphImpactAnalysis(workspacePath, slug, {
-        refresh: !!opts.refresh,
-      });
-    },
+    () => workgraph.orientation.statusSnapshot(resolveWorkspacePath(opts)),
     (result) => [
-      `Target: ${result.target.path} (${result.target.exists ? 'exists' : 'missing'})`,
-      `Total references: ${result.totalReferences}`,
-      ...result.groups.map((group) => `${group.type}: ${group.referenceCount}`),
+      `Threads: total=${result.threads.total} open=${result.threads.open} active=${result.threads.active} blocked=${result.threads.blocked} done=${result.threads.done}`,
+      `Claims: ${result.claims.active}`,
+      `Primitives: ${result.primitives.total}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
-  graphCmd
-    .command('context <slug>')
-    .description('Assemble token-budgeted markdown context from graph neighborhood')
-    .option('--budget <tokens>', 'Approx token budget (chars/4)', '2000')
-    .option('--refresh', 'Refresh graph index before querying')
-    .option('--json', 'Emit structured JSON output')
-).action((slug, opts) =>
+  program
+    .command('brief')
+    .description('Show actor-centric collaboration brief')
+    .option('-a, --actor <actor>', 'Actor', DEFAULT_ACTOR)
+    .option('--recent-count <n>', 'Recent activity count')
+    .option('--next-count <n>', 'Next thread count')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.graphContextAssembly(workspacePath, slug, {
-        budgetTokens: parsePositiveIntOption(opts.budget, 'budget'),
-        refresh: !!opts.refresh,
-      });
-    },
+    () => workgraph.orientation.brief(resolveWorkspacePath(opts), opts.actor, {
+      recentCount: opts.recentCount ? parsePositiveIntOption(opts.recentCount, 'recent-count') : undefined,
+      nextCount: opts.nextCount ? parsePositiveIntOption(opts.nextCount, 'next-count') : undefined,
+    }),
     (result) => [
-      `Center: ${result.center.path}`,
-      `Budget: ${result.budgetTokens} tokens`,
-      `Used: ${result.usedTokens} tokens`,
-      `Sections: ${result.sections.length}`,
-      '',
-      result.markdown,
+      `Actor: ${result.actor}`,
+      `Claims: ${result.myClaims.length}`,
+      `Blocked: ${result.blockedThreads.length}`,
+      `Next ready: ${result.nextReadyThreads.length}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
-  graphCmd
-    .command('edges <slug>')
-    .description('Show typed incoming/outgoing edges for one primitive')
-    .option('--refresh', 'Refresh graph index before querying')
-    .option('--json', 'Emit structured JSON output')
-).action((slug, opts) =>
+  program
+    .command('query')
+    .description('Query primitives')
+    .option('--type <type>', 'Primitive type')
+    .option('--status <status>', 'Status filter')
+    .option('--owner <owner>', 'Owner filter')
+    .option('--tag <tag>', 'Tag filter')
+    .option('--text <text>', 'Text filter')
+    .option('--path-includes <text>', 'Path substring filter')
+    .option('--updated-after <iso>', 'Updated after')
+    .option('--updated-before <iso>', 'Updated before')
+    .option('--created-after <iso>', 'Created after')
+    .option('--created-before <iso>', 'Created before')
+    .option('--limit <n>', 'Limit')
+    .option('--offset <n>', 'Offset')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
   runCommand(
     opts,
     () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.graphTypedEdges(workspacePath, slug, {
-        refresh: !!opts.refresh,
+      const results = workgraph.query.queryPrimitives(resolveWorkspacePath(opts), {
+        type: opts.type,
+        status: opts.status,
+        owner: opts.owner,
+        tag: opts.tag,
+        text: opts.text,
+        pathIncludes: opts.pathIncludes,
+        updatedAfter: opts.updatedAfter,
+        updatedBefore: opts.updatedBefore,
+        createdAfter: opts.createdAfter,
+        createdBefore: opts.createdBefore,
+        limit: opts.limit ? parsePositiveIntOption(opts.limit, 'limit') : undefined,
+        offset: opts.offset ? parseNonNegativeIntOption(opts.offset, 'offset') : undefined,
       });
+      return { results, count: results.length };
     },
-    (result) => [
-      `Node: ${result.node.path} (${result.node.exists ? 'exists' : 'missing'})`,
-      `Outgoing edges: ${result.outgoing.length}`,
-      `Incoming edges: ${result.incoming.length}`,
-      ...result.outgoing.map((edge) => `OUT ${edge.type} ${edge.from} -> ${edge.to}`),
-      ...result.incoming.map((edge) => `IN  ${edge.type} ${edge.from} -> ${edge.to}`),
-    ],
-  )
+    (result) => result.results.length > 0
+      ? [
+          ...result.results.map((entry) => `${entry.type} ${entry.path}`),
+          `${result.count} primitive(s)`,
+        ]
+      : ['No primitives matched the query.'],
+  ),
 );
 
 addWorkspaceOption(
-  graphCmd
-    .command('export <slug>')
-    .description('Export a markdown subgraph directory around a center primitive')
-    .option('--depth <n>', 'Traversal depth (default: 2)', '2')
-    .option('--format <format>', 'Export format (default: md)', 'md')
-    .option('--output-dir <path>', 'Output directory (default under .workgraph/graph-exports)')
-    .option('--refresh', 'Refresh graph index before querying')
-    .option('--json', 'Emit structured JSON output')
-).action((slug, opts) =>
+  program
+    .command('search <text>')
+    .description('Keyword search primitive content')
+    .option('--type <type>', 'Primitive type')
+    .option('--limit <n>', 'Limit')
+    .option('--json', 'Emit structured JSON output'),
+).action((text, opts) =>
   runCommand(
     opts,
     () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const format = String(opts.format ?? 'md').trim().toLowerCase();
-      if (format !== 'md') {
-        throw new Error(`Invalid --format "${opts.format}". Supported formats: md.`);
-      }
-      return workgraph.graph.graphExportSubgraph(workspacePath, slug, {
-        depth: parseNonNegativeIntOption(opts.depth, 'depth'),
-        format,
-        outputDir: opts.outputDir,
-        refresh: !!opts.refresh,
+      const results = workgraph.query.keywordSearch(resolveWorkspacePath(opts), text, {
+        type: opts.type,
+        limit: opts.limit ? parsePositiveIntOption(opts.limit, 'limit') : undefined,
       });
+      return { query: text, results, count: results.length };
     },
-    (result) => [
-      `Exported subgraph: ${result.outputDirectory}`,
-      `Center: ${result.center.path}`,
-      `Depth: ${result.depth}`,
-      `Nodes: ${result.exportedNodes.length}`,
-      `Edges: ${result.exportedEdgeCount}`,
-      `Manifest: ${result.manifestPath}`,
-    ],
-  )
+    (result) => result.results.length > 0
+      ? [
+          ...result.results.map((entry) => `${entry.type} ${entry.path}`),
+          `${result.count} result(s)`,
+        ]
+      : ['No search results found.'],
+  ),
 );
 
+const lensCmd = program
+  .command('lens')
+  .description('Generate context lenses');
+
 addWorkspaceOption(
-  graphCmd
-    .command('neighbors <nodePath>')
-    .description('Query incoming/outgoing wiki-link neighbors for one node')
-    .option('--refresh', 'Refresh graph index before querying')
-    .option('--json', 'Emit structured JSON output')
-).action((nodePath, opts) =>
+  lensCmd
+    .command('list')
+    .description('List built-in lenses')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.graph.graphNeighborhood(workspacePath, nodePath, {
-        refresh: !!opts.refresh,
-      });
-    },
-    (result) => [
-      `Node: ${result.node} (${result.exists ? 'exists' : 'missing'})`,
-      `Outgoing: ${result.outgoing.length}`,
-      `Incoming: ${result.incoming.length}`,
-    ],
-  )
+    () => ({ lenses: workgraph.lens.listContextLenses() }),
+    (result) => result.lenses.map((entry) => `${entry.id}: ${entry.description}`),
+  ),
 );
 
-// ============================================================================
-// policy
-// ============================================================================
-
-const policyCmd = program
-  .command('policy')
-  .description('Manage policy parties and capabilities');
-
-const policyPartyCmd = policyCmd
-  .command('party')
-  .description('Manage registered policy parties');
-
 addWorkspaceOption(
-  policyPartyCmd
-    .command('upsert <id>')
-    .description('Create or update a policy party')
-    .option('--roles <roles>', 'Comma-separated roles')
-    .option('--capabilities <caps>', 'Comma-separated capabilities')
-    .option('--json', 'Emit structured JSON output')
-).action((id, opts) =>
+  lensCmd
+    .command('show <lensId>')
+    .description('Generate or materialize one lens')
+    .option('-a, --actor <actor>', 'Actor', DEFAULT_ACTOR)
+    .option('--lookback-hours <n>', 'Lookback hours')
+    .option('--stale-hours <n>', 'Stale hours')
+    .option('--limit <n>', 'Item limit')
+    .option('--output <path>', 'Write markdown to a file')
+    .option('--json', 'Emit structured JSON output'),
+).action((lensId, opts) =>
   runCommand(
     opts,
     () => {
       const workspacePath = resolveWorkspacePath(opts);
-      return {
-        party: workgraph.policy.upsertParty(workspacePath, id, {
-          roles: csv(opts.roles),
-          capabilities: csv(opts.capabilities),
-        }),
+      const sharedOptions = {
+        actor: opts.actor,
+        lookbackHours: opts.lookbackHours ? parsePositiveIntOption(opts.lookbackHours, 'lookback-hours') : undefined,
+        staleHours: opts.staleHours ? parsePositiveIntOption(opts.staleHours, 'stale-hours') : undefined,
+        limit: opts.limit ? parsePositiveIntOption(opts.limit, 'limit') : undefined,
       };
+      if (opts.output) {
+        return workgraph.lens.materializeContextLens(workspacePath, lensId, {
+          ...sharedOptions,
+          outputPath: opts.output,
+        });
+      }
+      return workgraph.lens.generateContextLens(workspacePath, lensId, sharedOptions);
     },
-    (result) => [`Upserted policy party: ${result.party.id}`],
-  )
+    (result) => [
+      `Lens: ${result.lens}`,
+      `Sections: ${result.sections.length}`,
+      ...('outputPath' in result ? [`Output: ${result.outputPath}`] : []),
+    ],
+  ),
 );
 
+const graphCmd = program
+  .command('graph')
+  .description('Inspect context graph structure');
+
 addWorkspaceOption(
-  policyPartyCmd
-    .command('get <id>')
-    .description('Get one policy party')
-    .option('--json', 'Emit structured JSON output')
-).action((id, opts) =>
+  graphCmd
+    .command('index')
+    .description('Refresh wiki-link graph index')
+    .option('--json', 'Emit structured JSON output'),
+).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const party = workgraph.policy.getParty(workspacePath, id);
-      if (!party) throw new Error(`Policy party not found: ${id}`);
-      return { party };
-    },
-    (result) => [`${result.party.id} roles=${result.party.roles.join(',')}`],
-  )
+    () => workgraph.graph.refreshWikiLinkGraphIndex(resolveWorkspacePath(opts)),
+    (result) => [`Indexed ${result.nodes.length} nodes and ${result.edges.length} edges.`],
+  ),
 );
 
 addWorkspaceOption(
-  policyPartyCmd
-    .command('list')
-    .description('List policy parties')
-    .option('--json', 'Emit structured JSON output')
+  graphCmd
+    .command('hygiene')
+    .description('Report graph hygiene metrics')
+    .option('--json', 'Emit structured JSON output'),
 ).action((opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const registry = workgraph.policy.loadPolicyRegistry(workspacePath);
-      return {
-        parties: Object.values(registry.parties),
-      };
-    },
-    (result) => result.parties.map((party) => `${party.id} [${party.roles.join(', ')}]`),
-  )
+    () => workgraph.graph.graphHygieneReport(resolveWorkspacePath(opts)),
+    (result) => [
+      `Nodes: ${result.nodeCount}`,
+      `Edges: ${result.edgeCount}`,
+      `Broken links: ${result.brokenLinkCount}`,
+      `Orphans: ${result.orphanCount}`,
+    ],
+  ),
 );
 
-// ============================================================================
-// gate
-// ============================================================================
-
-const gateCmd = program
-  .command('gate')
-  .description('Evaluate thread quality gates before claim');
-
 addWorkspaceOption(
-  gateCmd
-    .command('check <threadRef>')
-    .description('Check policy-gate status for one thread')
-    .option('--json', 'Emit structured JSON output')
-).action((threadRef, opts) =>
+  graphCmd
+    .command('neighborhood <nodeRef>')
+    .description('Show graph neighborhood for one primitive')
+    .option('--depth <n>', 'Neighborhood depth', '2')
+    .option('--refresh', 'Rebuild index before query')
+    .option('--json', 'Emit structured JSON output'),
+).action((nodeRef, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.gate.checkThreadGates(workspacePath, threadRef);
-    },
-    (result) => {
-      const header = [`Gate check for ${result.threadPath}: ${result.allowed ? 'PASSED' : 'FAILED'}`];
-      if (result.gates.length === 0) {
-        return [...header, 'No gates configured.'];
-      }
-      const details = result.gates.map((gate) => {
-        const failingRules = gate.rules.filter((rule) => !rule.ok);
-        const gateLabel = gate.gatePath ?? gate.gateRef;
-        if (failingRules.length === 0) {
-          return `[pass] ${gateLabel}`;
-        }
-        return `[fail] ${gateLabel} :: ${failingRules.map((rule) => rule.message).join('; ')}`;
-      });
-      return [...header, ...details];
-    },
-  )
+    () => workgraph.graph.graphNeighborhoodQuery(resolveWorkspacePath(opts), nodeRef, {
+      depth: parseNonNegativeIntOption(opts.depth, 'depth'),
+      refresh: !!opts.refresh,
+    }),
+    (result) => [
+      `Center: ${result.center.path}`,
+      `Connected nodes: ${result.connectedNodes.length}`,
+      `Edges: ${result.edges.length}`,
+    ],
+  ),
 );
 
-// ============================================================================
-// dispatch
-// ============================================================================
-
-registerAdapterCommands(program, DEFAULT_ACTOR);
-registerDispatchCommands(program, DEFAULT_ACTOR);
-registerCursorCommands(program, DEFAULT_ACTOR);
-
-// ============================================================================
-// trigger
-// ============================================================================
-
-registerTriggerCommands(program, DEFAULT_ACTOR);
-registerWebhookCommands(program, DEFAULT_ACTOR);
-
-// ============================================================================
-// conversation + plan-step
-// ============================================================================
-
-registerConversationCommands(program, DEFAULT_ACTOR);
-
-// ============================================================================
-// safety
-// ============================================================================
-
-registerSafetyCommands(program, DEFAULT_ACTOR);
-registerPortabilityCommands(program);
-registerFederationCommands(program, threadCmd, DEFAULT_ACTOR);
-registerCapabilityCommands(program, DEFAULT_ACTOR);
-registerMissionCommands(program, DEFAULT_ACTOR);
-
-// ============================================================================
-// onboarding
-// ============================================================================
-
 addWorkspaceOption(
-  program
-    .command('onboard')
-    .description('Guided agent-first workspace setup and starter artifacts')
-    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
-    .option('--spaces <list>', 'Comma-separated space names')
-    .option('--no-demo-threads', 'Skip starter onboarding threads')
-    .option('--json', 'Emit structured JSON output')
-).action((opts) =>
+  graphCmd
+    .command('impact <nodeRef>')
+    .description('Show inbound references to one primitive')
+    .option('--refresh', 'Rebuild index before query')
+    .option('--json', 'Emit structured JSON output'),
+).action((nodeRef, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return workgraph.onboard.onboardWorkspace(workspacePath, {
-        actor: opts.actor,
-        spaces: csv(opts.spaces),
-        createDemoThreads: opts.demoThreads,
-      });
-    },
+    () => workgraph.graph.graphImpactAnalysis(resolveWorkspacePath(opts), nodeRef, {
+      refresh: !!opts.refresh,
+    }),
     (result) => [
-      `Onboarded actor: ${result.actor}`,
-      `Spaces created: ${result.spacesCreated.length}`,
-      `Threads created: ${result.threadsCreated.length}`,
-      `Board: ${result.boardPath}`,
-      `Command center: ${result.commandCenterPath}`,
-      `Onboarding primitive: ${result.onboardingPath}`,
+      `Target: ${result.target.path}`,
+      `References: ${result.totalReferences}`,
+      `Groups: ${result.groups.length}`,
     ],
-  )
+  ),
 );
 
-const onboardingCmd = program
-  .command('onboarding')
-  .description('Manage onboarding primitive lifecycle');
-
 addWorkspaceOption(
-  onboardingCmd
-    .command('show <onboardingPath>')
-    .description('Show one onboarding primitive')
-    .option('--json', 'Emit structured JSON output')
-).action((onboardingPath, opts) =>
+  graphCmd
+    .command('context <nodeRef>')
+    .description('Assemble a context bundle around one primitive')
+    .option('--budget <tokens>', 'Token budget', '2000')
+    .option('--refresh', 'Rebuild index before query')
+    .option('--json', 'Emit structured JSON output'),
+).action((nodeRef, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const onboarding = workgraph.store.read(workspacePath, onboardingPath);
-      if (!onboarding) throw new Error(`Onboarding primitive not found: ${onboardingPath}`);
-      if (onboarding.type !== 'onboarding') throw new Error(`Target is not onboarding primitive: ${onboardingPath}`);
-      return { onboarding };
-    },
+    () => workgraph.graph.graphContextAssembly(resolveWorkspacePath(opts), nodeRef, {
+      budgetTokens: parsePositiveIntegerOption(opts.budget, 'budget'),
+      refresh: !!opts.refresh,
+    }),
     (result) => [
-      `Onboarding: ${result.onboarding.path}`,
-      `Status: ${String(result.onboarding.fields.status)}`,
-      `Actor: ${String(result.onboarding.fields.actor)}`,
+      `Center: ${result.center.path}`,
+      `Used tokens: ${result.usedTokens}/${result.budgetTokens}`,
+      `Sections: ${result.sections.length}`,
     ],
-  )
+  ),
 );
 
 addWorkspaceOption(
-  onboardingCmd
-    .command('update <onboardingPath>')
-    .description('Update onboarding lifecycle status')
-    .requiredOption('--status <status>', 'active|paused|completed')
-    .option('-a, --actor <name>', 'Actor', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
-).action((onboardingPath, opts) =>
+  graphCmd
+    .command('edges <nodeRef>')
+    .description('Inspect typed edges for one primitive')
+    .option('--refresh', 'Rebuild index before query')
+    .option('--json', 'Emit structured JSON output'),
+).action((nodeRef, opts) =>
   runCommand(
     opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      return {
-        onboarding: workgraph.onboard.updateOnboardingStatus(
-          workspacePath,
-          onboardingPath,
-          normalizeOnboardingStatus(opts.status),
-          opts.actor,
-        ),
-      };
-    },
-    (result) => [`Updated onboarding: ${result.onboarding.path} [${String(result.onboarding.fields.status)}]`],
-  )
+    () => workgraph.graph.graphTypedEdges(resolveWorkspacePath(opts), nodeRef, {
+      refresh: !!opts.refresh,
+    }),
+    (result) => [
+      `Node: ${result.node.path}`,
+      `Outgoing: ${result.outgoing.length}`,
+      `Incoming: ${result.incoming.length}`,
+    ],
+  ),
 );
 
-// ============================================================================
-// autonomy
-// ============================================================================
-
-registerAutonomyCommands(program, DEFAULT_ACTOR);
-
-// ============================================================================
-// remote/api diagnostics
-// ============================================================================
-
-program
-  .command('remote')
-  .description('Remote/API mode diagnostics')
-  .command('test')
-  .description('Ping MCP HTTP endpoint and list available tools')
-  .option('--api-url <url>', 'Workgraph MCP HTTP endpoint URL (or WORKGRAPH_API_URL env)')
-  .option('--api-key <token>', 'Agent credential API key (or WORKGRAPH_API_KEY env)')
-  .option('--json', 'Emit structured JSON output')
-  .action((opts) =>
-    runCommand(
-      opts,
-      () => withRemoteClient(opts, async (client) => {
-        const tools = await client.listTools();
-        const status = await client.callTool<ReturnType<typeof workgraph.orientation.statusSnapshot>>(
-          'workgraph_status',
-          {},
-        );
-        return {
-          apiUrl: resolveApiUrl(opts),
-          ok: true,
-          toolCount: tools.length,
-          tools: tools.map((tool) => tool.name).sort((left, right) => left.localeCompare(right)),
-          status,
-        };
-      }),
-      (result) => [
-        `Connected to: ${result.apiUrl}`,
-        `MCP tools available: ${result.toolCount}`,
-        `Threads: total=${result.status.threads.total} ready=${result.status.threads.ready} active=${result.status.threads.active}`,
-        `Claims: active=${result.status.claims.active}`,
-      ],
-    ),
-  );
+addWorkspaceOption(
+  graphCmd
+    .command('export <nodeRef>')
+    .description('Export a subgraph to markdown files')
+    .option('--depth <n>', 'Neighborhood depth', '2')
+    .option('--output-dir <path>', 'Output directory')
+    .option('--refresh', 'Rebuild index before query')
+    .option('--json', 'Emit structured JSON output'),
+).action((nodeRef, opts) =>
+  runCommand(
+    opts,
+    () => workgraph.graph.graphExportSubgraph(resolveWorkspacePath(opts), nodeRef, {
+      depth: parseNonNegativeIntOption(opts.depth, 'depth'),
+      outputDir: opts.outputDir,
+      refresh: !!opts.refresh,
+    }),
+    (result) => [
+      `Exported nodes: ${result.exportedNodes.length}`,
+      `Output directory: ${result.outputDirectory}`,
+      `Manifest: ${result.manifestPath}`,
+    ],
+  ),
+);
 
-// ============================================================================
-// serve (http server)
-// ============================================================================
+registerConversationCommands(program, DEFAULT_ACTOR);
+registerMcpCommands(program, DEFAULT_ACTOR);
 
 addWorkspaceOption(
   program
     .command('serve')
-    .description('Serve Workgraph HTTP MCP server + REST API')
-    .option('--port <port>', 'HTTP port (defaults to server config or 8787)')
-    .option('--host <host>', 'Bind host (defaults to server config or 0.0.0.0)')
-    .option('--token <token>', 'Optional bearer token for MCP + REST auth')
-    .option('-a, --actor <name>', 'Default actor for thread mutations'),
+    .description('Serve the MCP HTTP endpoint for this workspace')
+    .option('-a, --actor <name>', 'Default actor for MCP writes', DEFAULT_ACTOR)
+    .option('--read-only', 'Disable MCP write tools')
+    .option('--port <port>', 'HTTP port')
+    .option('--host <host>', 'Bind host')
+    .option('--endpoint-path <path>', 'MCP endpoint path')
+    .option('--token <token>', 'Bearer token for HTTP access')
+    .option('--json', 'Emit structured JSON output'),
 ).action(async (opts) => {
   const workspacePath = resolveWorkspacePath(opts);
   const serverConfig = workgraph.serverConfig.loadServerConfig(workspacePath);
-  const port = opts.port !== undefined
-    ? parsePortOption(opts.port)
-    : (serverConfig?.port ?? 8787);
-  const host = opts.host
-    ? String(opts.host)
-    : (serverConfig?.host ?? '0.0.0.0');
-  const defaultActor = opts.actor
-    ? String(opts.actor)
-    : (serverConfig?.defaultActor ?? DEFAULT_ACTOR);
-  const endpointPath = serverConfig?.endpointPath;
-  const bearerToken = opts.token
-    ? String(opts.token)
-    : serverConfig?.bearerToken;
-  const handle = await startWorkgraphServer({
+  const handle = await startWorkgraphMcpHttpServer({
     workspacePath,
-    host,
-    port,
-    endpointPath,
-    bearerToken,
-    defaultActor,
-  });
-  console.log(`Server URL: ${handle.baseUrl}`);
-  console.log(`MCP endpoint: ${handle.url}`);
-  console.log(`Health: ${handle.healthUrl}`);
-  console.log(`Status API: ${handle.baseUrl}/api/status`);
-  console.log(`Webhook endpoint template: ${handle.webhookGatewayUrlTemplate}`);
-  await waitForShutdown(handle, {
-    onSignal: (signal) => {
-      console.error(`Received ${signal}; shutting down...`);
-    },
-    onClosed: () => {
-      console.error('Server stopped.');
-    },
+    defaultActor: opts.actor,
+    readOnly: !!opts.readOnly,
+    host: opts.host ?? serverConfig?.host ?? '127.0.0.1',
+    port: opts.port ? parsePortOption(opts.port) : serverConfig?.port,
+    endpointPath: opts.endpointPath ?? serverConfig?.endpointPath,
+    bearerToken: readNonEmptyString(opts.token) ?? serverConfig?.bearerToken,
   });
-});
 
-// ============================================================================
-// mcp
-// ============================================================================
-
-registerMcpCommands(program, DEFAULT_ACTOR);
+  if (wantsJson(opts)) {
+    console.log(JSON.stringify({
+      ok: true,
+      data: {
+        host: handle.host,
+        port: handle.port,
+        endpointPath: handle.endpointPath,
+        healthUrl: handle.healthUrl,
+        url: handle.url,
+      },
+    }, null, 2));
+  } else {
+    console.log(`Serving MCP HTTP on ${handle.url}`);
+    console.log(`Health: ${handle.healthUrl}`);
+  }
 
-// ============================================================================
-// swarm
-// ============================================================================
+  await waitForShutdown(handle.close);
+});
 
-const swarmCmd = program
-  .command('swarm')
-  .description('Decompose goals into tasks and orchestrate agent swarms');
+program.parseAsync(process.argv).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
 
-addWorkspaceOption(
-  swarmCmd
-    .command('deploy <planFile>')
-    .description('Deploy a swarm plan (JSON) into the workspace as threads')
-    .option('-a, --actor <name>', 'Actor name', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
-).action((planFile, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const workspacePath = resolveWorkspacePath(opts);
-      const planPath = path.resolve(planFile);
-      const planData = JSON.parse(fs.readFileSync(planPath, 'utf-8'));
-      return workgraph.swarm.deployPlan(workspacePath, planData, opts.actor);
-    },
-    (result) => [
-      `Swarm deployed: ${result.spaceSlug}`,
-      `Threads: ${result.threadPaths.length}`,
-      `Status: ${result.status}`,
-    ],
-  )
-);
+function normalizePriority(value: string): 'urgent' | 'high' | 'medium' | 'low' {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'urgent' || normalized === 'high' || normalized === 'medium' || normalized === 'low') {
+    return normalized;
+  }
+  throw new Error(`Invalid priority "${value}". Expected urgent|high|medium|low.`);
+}
 
-addWorkspaceOption(
-  swarmCmd
-    .command('status <spaceSlug>')
-    .description('Show swarm progress')
-    .option('--json', 'Emit structured JSON output')
-).action((spaceSlug, opts) =>
-  runCommand(
-    opts,
-    () => workgraph.swarm.getSwarmStatus(resolveWorkspacePath(opts), spaceSlug),
-    (result) => [
-      `Swarm: ${result.deployment.spaceSlug} [${result.deployment.status}]`,
-      `Progress: ${result.done}/${result.total} (${result.percentComplete}%)`,
-      `Claimed: ${result.claimed} | Open: ${result.open} | Blocked: ${result.blocked}`,
-      `Ready to claim: ${result.readyToClaim}`,
-    ],
-  )
-);
+function normalizePresenceStatus(value: string): 'online' | 'busy' | 'offline' {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'online' || normalized === 'busy' || normalized === 'offline') {
+    return normalized;
+  }
+  throw new Error(`Invalid status "${value}". Expected online|busy|offline.`);
+}
 
-addWorkspaceOption(
-  swarmCmd
-    .command('claim <spaceSlug>')
-    .description('Claim the next available task in a swarm')
-    .option('-a, --actor <name>', 'Worker agent name', DEFAULT_ACTOR)
-    .option('--json', 'Emit structured JSON output')
-).action((spaceSlug, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const result = workgraph.swarm.workerClaim(resolveWorkspacePath(opts), spaceSlug, opts.actor);
-      if (!result) return { claimed: false, message: 'No tasks available' };
-      return { claimed: true, path: result.path, title: result.fields.title };
-    },
-    (result) => result.claimed
-      ? [`Claimed: ${result.path} — ${result.title}`]
-      : ['No tasks available to claim'],
-  )
-);
+function normalizeParticipantRole(value: string): 'owner' | 'contributor' | 'reviewer' | 'observer' {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'owner' || normalized === 'contributor' || normalized === 'reviewer' || normalized === 'observer') {
+    return normalized;
+  }
+  throw new Error(`Invalid role "${value}". Expected owner|contributor|reviewer|observer.`);
+}
 
-addWorkspaceOption(
-  swarmCmd
-    .command('complete <threadPath>')
-    .description('Mark a swarm task as done with result')
-    .option('-a, --actor <name>', 'Worker agent name', DEFAULT_ACTOR)
-    .requiredOption('--result <text>', 'Result text (or @file to read from file)')
-    .option('--json', 'Emit structured JSON output')
-).action((threadPath, opts) =>
-  runCommand(
-    opts,
-    () => {
-      let resultText = opts.result;
-      if (resultText.startsWith('@')) {
-        resultText = fs.readFileSync(resultText.slice(1), 'utf-8');
-      }
-      return workgraph.swarm.workerComplete(resolveWorkspacePath(opts), threadPath, opts.actor, resultText);
-    },
-    (result) => [`Completed: ${result.path}`],
-  )
-);
+function normalizeRegistrationDecision(value: string): 'approved' | 'rejected' {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'approved' || normalized === 'rejected') {
+    return normalized;
+  }
+  throw new Error(`Invalid decision "${value}". Expected approved|rejected.`);
+}
 
-addWorkspaceOption(
-  swarmCmd
-    .command('synthesize <spaceSlug>')
-    .description('Merge all completed task results into a single document')
-    .option('-o, --output <file>', 'Output file path')
-    .option('--json', 'Emit structured JSON output')
-).action((spaceSlug, opts) =>
-  runCommand(
-    opts,
-    () => {
-      const result = workgraph.swarm.synthesize(resolveWorkspacePath(opts), spaceSlug);
-      if (opts.output) {
-        fs.writeFileSync(path.resolve(opts.output), result.markdown);
-      }
-      return result;
-    },
-    (result) => [
-      `Synthesized: ${result.completedCount}/${result.totalCount} tasks`,
-      opts.output ? `Written to: ${opts.output}` : result.markdown,
-    ],
-  )
-);
+function normalizePath(value: string): string {
+  const trimmed = String(value).trim().replace(/\\/g, '/').replace(/^\.\//, '');
+  return trimmed.endsWith('.md') ? trimmed : `${trimmed}.md`;
+}
 
-await program.parseAsync();
+function collectSetPairs(value: string, existing: string[]): string[] {
+  existing.push(value);
+  return existing;
+}
 
-function isRemoteMode(opts: JsonCapableOptions): boolean {
-  return !!resolveApiUrl(opts);
+function mergeSetPairs(values: string[]): Record<string, unknown> {
+  return values.reduce<Record<string, unknown>>((acc, entry) => {
+    Object.assign(acc, parseSetPairs([entry]));
+    return acc;
+  }, {});
 }
 
-async function withRemoteClient<T>(
-  opts: JsonCapableOptions,
-  action: (client: WorkgraphRemoteClient) => Promise<T>,
-): Promise<T> {
-  const apiUrl = resolveApiUrl(opts);
-  if (!apiUrl) {
-    throw new Error('Remote API mode requires --api-url or WORKGRAPH_API_URL.');
-  }
-  const client = await WorkgraphRemoteClient.connect({
-    apiUrl,
-    apiKey: resolveApiKey(opts),
-    version: CLI_VERSION,
-  });
-  try {
-    return await action(client);
-  } finally {
-    await client.close();
-  }
+function collectFieldSpecs(value: string, existing: string[]): string[] {
+  existing.push(value);
+  return existing;
 }
 
-function isMaterializedLensResult(
-  value: workgraph.WorkgraphLensResult | workgraph.WorkgraphMaterializedLensResult,
-): value is workgraph.WorkgraphMaterializedLensResult {
-  return typeof (value as workgraph.WorkgraphMaterializedLensResult).outputPath === 'string';
+function parseFieldDefinitions(values: string[]): Record<string, workgraph.FieldDefinition> {
+  const fields: Record<string, workgraph.FieldDefinition> = {};
+  for (const value of values) {
+    const [namePart, typePart] = String(value).split(':');
+    const name = readNonEmptyString(namePart);
+    const type = readNonEmptyString(typePart);
+    if (!name || !type) {
+      throw new Error(`Invalid field definition "${value}". Expected name:type.`);
+    }
+    fields[name] = {
+      type: parseFieldType(type),
+    };
+  }
+  return fields;
 }
 
-function normalizeAgentPresenceStatus(status: string): 'online' | 'busy' | 'offline' {
-  const normalized = String(status).toLowerCase();
-  if (normalized === 'online' || normalized === 'busy' || normalized === 'offline') {
+function parseFieldType(value: string): workgraph.FieldDefinition['type'] {
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === 'string' ||
+    normalized === 'number' ||
+    normalized === 'boolean' ||
+    normalized === 'list' ||
+    normalized === 'date' ||
+    normalized === 'ref' ||
+    normalized === 'any'
+  ) {
     return normalized;
   }
-  throw new Error(`Invalid agent status "${status}". Expected online|busy|offline.`);
+  throw new Error(`Invalid field type "${value}". Expected string|number|boolean|list|date|ref|any.`);
 }
 
-function normalizeOnboardingStatus(status: string): 'active' | 'paused' | 'completed' {
-  const normalized = String(status).toLowerCase();
-  if (normalized === 'active' || normalized === 'paused' || normalized === 'completed') {
-    return normalized;
+function collectSubthreadSpecs(
+  value: string,
+  existing: Array<{ title: string; goal: string; deps?: string[] }>,
+): Array<{ title: string; goal: string; deps?: string[] }> {
+  const [title, goal, deps] = String(value).split('::');
+  if (!readNonEmptyString(title) || !readNonEmptyString(goal)) {
+    throw new Error(`Invalid subthread spec "${value}". Expected title::goal[::dep1,dep2].`);
   }
-  throw new Error(`Invalid onboarding status "${status}". Expected active|paused|completed.`);
+  existing.push({
+    title: title.trim(),
+    goal: goal.trim(),
+    ...(readNonEmptyString(deps) ? { deps: deps.split(',').map((entry) => entry.trim()).filter(Boolean) } : {}),
+  });
+  return existing;
+}
+
+async function waitForShutdown(close: () => Promise<void>): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    let closing = false;
+    const stop = async () => {
+      if (closing) return;
+      closing = true;
+      cleanup();
+      try {
+        await close();
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    };
+    const onSigint = () => { void stop(); };
+    const onSigterm = () => { void stop(); };
+    const cleanup = () => {
+      process.off('SIGINT', onSigint);
+      process.off('SIGTERM', onSigterm);
+    };
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+  });
+}
+
+function readNonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
 }
diff --git a/packages/cli/src/cli/commands/adapter.ts b/packages/cli/src/cli/commands/adapter.ts
deleted file mode 100644
index d359382..0000000
--- a/packages/cli/src/cli/commands/adapter.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerAdapterCommands(program: Command, defaultActor: string): void {
-  const adapterCmd = program
-    .command('adapter')
-    .description('Inspect and exercise dispatch adapter integrations');
-
-  addWorkspaceOption(
-    adapterCmd
-      .command('list')
-      .description('List available runtime dispatch adapters')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const adapters = workgraph.runtimeAdapterRegistry.listDispatchAdapters();
-        return {
-          adapters,
-          count: adapters.length,
-        };
-      },
-      (result) => {
-        if (result.adapters.length === 0) return ['No dispatch adapters registered.'];
-        return [
-          ...result.adapters.map((name) => name),
-          `${result.count} adapter(s)`,
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    adapterCmd
-      .command('test <adapter>')
-      .description('Run contract smoke test against one adapter')
-      .option('-a, --actor <name>', 'Actor identity', defaultActor)
-      .option('--objective <text>', 'Objective text for create/execute probes', 'Adapter smoke test')
-      .option('--context <json>', 'JSON object passed as adapter context')
-      .option('--execute', 'Invoke execute() after lifecycle checks')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((adapterName, opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const knownAdapters = workgraph.runtimeAdapterRegistry.listDispatchAdapters();
-        let adapter: workgraph.DispatchAdapter;
-        try {
-          adapter = workgraph.runtimeAdapterRegistry.resolveDispatchAdapter(adapterName);
-        } catch {
-          throw new Error(`Unknown adapter "${adapterName}". Registered adapters: ${knownAdapters.join(', ') || 'none'}.`);
-        }
-
-        const context = parseContextOption(opts.context);
-        const created = await adapter.create({
-          actor: opts.actor,
-          objective: opts.objective,
-          ...(context ? { context } : {}),
-        });
-        const status = await adapter.status(created.runId);
-        const followup = await adapter.followup(created.runId, opts.actor, 'adapter smoke follow-up');
-        const logs = await adapter.logs(created.runId);
-        const stopped = await adapter.stop(created.runId, opts.actor);
-
-        const execution = opts.execute
-          ? await runExecuteProbe(adapterName, adapter, {
-            workspacePath: resolveWorkspacePath(opts),
-            runId: created.runId,
-            actor: opts.actor,
-            objective: opts.objective,
-            ...(context ? { context } : {}),
-          })
-          : undefined;
-
-        return {
-          adapter: adapter.name,
-          created,
-          status,
-          followup,
-          stopped,
-          logsCount: logs.length,
-          ...(execution ? { execution } : {}),
-        };
-      },
-      (result) => [
-        `Adapter: ${result.adapter}`,
-        `Create: ${result.created.status} (${result.created.runId})`,
-        `Status: ${result.status.status}`,
-        `Follow-up: ${result.followup.status}`,
-        `Stop: ${result.stopped.status}`,
-        `Logs read: ${result.logsCount}`,
-        ...(result.execution
-          ? [
-            `Execute: ${result.execution.status}`,
-            ...(result.execution.output ? [`Execute output: ${result.execution.output}`] : []),
-            ...(result.execution.error ? [`Execute error: ${result.execution.error}`] : []),
-          ]
-          : []),
-      ],
-    ),
-  );
-}
-
-async function runExecuteProbe(
-  adapterName: string,
-  adapter: workgraph.DispatchAdapter,
-  input: {
-    workspacePath: string;
-    runId: string;
-    actor: string;
-    objective: string;
-    context?: Record<string, unknown>;
-  },
-) {
-  if (!adapter.execute) {
-    throw new Error(`Adapter "${adapterName}" does not implement execute(). Remove --execute or choose another adapter.`);
-  }
-  return adapter.execute(input);
-}
-
-function parseContextOption(rawValue: unknown): Record<string, unknown> | undefined {
-  if (rawValue === undefined || rawValue === null || String(rawValue).trim().length === 0) {
-    return undefined;
-  }
-  const parsed = JSON.parse(String(rawValue)) as unknown;
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error('Invalid --context value. Expected a JSON object.');
-  }
-  return parsed as Record<string, unknown>;
-}
diff --git a/packages/cli/src/cli/commands/autonomy.ts b/packages/cli/src/cli/commands/autonomy.ts
deleted file mode 100644
index 0ccc5e7..0000000
--- a/packages/cli/src/cli/commands/autonomy.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-import path from 'node:path';
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerAutonomyCommands(program: Command, defaultActor: string): void {
-  const autonomyCmd = program
-    .command('autonomy')
-    .description('Run long-lived autonomous collaboration loops');
-
-  addWorkspaceOption(
-    autonomyCmd
-      .command('run')
-      .description('Run autonomy cycles (trigger engine + ready-thread execution)')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--adapter <name>', 'Dispatch adapter name', 'cursor-cloud')
-      .option('--agents <actors>', 'Comma-separated autonomous worker identities')
-      .option('--watch', 'Run continuously instead of stopping when idle')
-      .option('--poll-ms <ms>', 'Cycle poll interval', '2000')
-      .option('--max-cycles <n>', 'Maximum cycles before exit')
-      .option('--max-idle-cycles <n>', 'Idle cycles before exit in non-watch mode', '2')
-      .option('--max-steps <n>', 'Maximum adapter scheduler steps', '200')
-      .option('--step-delay-ms <ms>', 'Adapter scheduler delay', '25')
-      .option('--space <spaceRef>', 'Restrict autonomy to one space')
-      .option('--heartbeat-file <path>', 'Write daemon heartbeat JSON to this path')
-      .option('--no-execute-triggers', 'Disable trigger engine actions')
-      .option('--no-execute-ready-threads', 'Disable ready-thread dispatch execution')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.autonomy.runAutonomyLoop(workspacePath, {
-          actor: opts.actor,
-          adapter: opts.adapter,
-          agents: csv(opts.agents),
-          watch: !!opts.watch,
-          pollMs: Number.parseInt(String(opts.pollMs), 10),
-          maxCycles: opts.maxCycles ? Number.parseInt(String(opts.maxCycles), 10) : undefined,
-          maxIdleCycles: Number.parseInt(String(opts.maxIdleCycles), 10),
-          maxSteps: Number.parseInt(String(opts.maxSteps), 10),
-          stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
-          space: opts.space,
-          heartbeatFile: opts.heartbeatFile,
-          executeTriggers: opts.executeTriggers,
-          executeReadyThreads: opts.executeReadyThreads,
-        });
-      },
-      (result) => [
-        `Cycles: ${result.cycles.length}`,
-        `Final ready threads: ${result.finalReadyThreads}`,
-        `Final drift status: ${result.finalDriftOk ? 'ok' : 'issues'}`,
-        ...result.cycles.map((cycle) =>
-          `Cycle ${cycle.cycle}: ready=${cycle.readyThreads} trigger_actions=${cycle.triggerActions} run=${cycle.runStatus ?? 'none'} drift_issues=${cycle.driftIssues}`,
-        ),
-      ],
-    ),
-  );
-
-  const autonomyDaemonCmd = autonomyCmd
-    .command('daemon')
-    .description('Manage autonomy process lifecycle (pid + heartbeat + logs)');
-
-  addWorkspaceOption(
-    autonomyDaemonCmd
-      .command('start')
-      .description('Start autonomy in detached daemon mode')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--adapter <name>', 'Dispatch adapter name', 'cursor-cloud')
-      .option('--agents <actors>', 'Comma-separated autonomous worker identities')
-      .option('--poll-ms <ms>', 'Cycle poll interval', '2000')
-      .option('--max-cycles <n>', 'Maximum cycles before daemon exits')
-      .option('--max-steps <n>', 'Maximum adapter scheduler steps', '200')
-      .option('--step-delay-ms <ms>', 'Adapter scheduler delay', '25')
-      .option('--space <spaceRef>', 'Restrict autonomy to one space')
-      .option('--log-path <path>', 'Daemon log file path (workspace-relative)')
-      .option('--heartbeat-path <path>', 'Heartbeat file path (workspace-relative)')
-      .option('--no-execute-triggers', 'Disable trigger engine actions')
-      .option('--no-execute-ready-threads', 'Disable ready-thread dispatch execution')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.autonomyDaemon.startAutonomyDaemon(workspacePath, {
-          cliEntrypointPath: process.argv[1] ?? path.resolve('bin/workgraph.js'),
-          actor: opts.actor,
-          adapter: opts.adapter,
-          agents: csv(opts.agents),
-          pollMs: Number.parseInt(String(opts.pollMs), 10),
-          maxCycles: opts.maxCycles ? Number.parseInt(String(opts.maxCycles), 10) : undefined,
-          maxSteps: Number.parseInt(String(opts.maxSteps), 10),
-          stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
-          space: opts.space,
-          logPath: opts.logPath,
-          heartbeatPath: opts.heartbeatPath,
-          executeTriggers: opts.executeTriggers,
-          executeReadyThreads: opts.executeReadyThreads,
-        });
-      },
-      (result) => [
-        `Daemon running: ${result.running}`,
-        ...(result.pid ? [`PID: ${result.pid}`] : []),
-        `PID file: ${result.pidPath}`,
-        `Heartbeat: ${result.heartbeatPath}`,
-        `Log: ${result.logPath}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    autonomyDaemonCmd
-      .command('status')
-      .description('Show autonomy daemon status')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.autonomyDaemon.readAutonomyDaemonStatus(workspacePath);
-      },
-      (result) => [
-        `Daemon running: ${result.running}`,
-        ...(result.pid ? [`PID: ${result.pid}`] : []),
-        ...(result.heartbeat ? [`Last heartbeat: ${result.heartbeat.ts}`] : ['Last heartbeat: none']),
-        `PID file: ${result.pidPath}`,
-        `Heartbeat: ${result.heartbeatPath}`,
-        `Log: ${result.logPath}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    autonomyDaemonCmd
-      .command('stop')
-      .description('Stop autonomy daemon by PID')
-      .option('--signal <signal>', 'Signal for graceful stop', 'SIGTERM')
-      .option('--timeout-ms <ms>', 'Graceful wait timeout', '5000')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.autonomyDaemon.stopAutonomyDaemon(workspacePath, {
-          signal: String(opts.signal) as NodeJS.Signals,
-          timeoutMs: Number.parseInt(String(opts.timeoutMs), 10),
-        });
-      },
-      (result) => [
-        `Stopped: ${result.stopped}`,
-        `Previously running: ${result.previouslyRunning}`,
-        ...(result.pid ? [`PID: ${result.pid}`] : []),
-        `Daemon running now: ${result.status.running}`,
-      ],
-    ),
-  );
-}
diff --git a/packages/cli/src/cli/commands/capability.ts b/packages/cli/src/cli/commands/capability.ts
deleted file mode 100644
index 7c352fe..0000000
--- a/packages/cli/src/cli/commands/capability.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerCapabilityCommands(program: Command, defaultActor: string): void {
-  const capabilityCmd = program
-    .command('capability')
-    .description('Inspect agent capability registry and thread requirement matching');
-
-  addWorkspaceOption(
-    capabilityCmd
-      .command('list')
-      .description('List known capabilities and owning agents')
-      .option('--agent <name>', 'Filter to one agent')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const registry = workgraph.capability.buildAgentCapabilityRegistry(workspacePath);
-        const agentFilter = normalizeToken(opts.agent);
-        const agents = agentFilter
-          ? registry.agents.filter((entry) => entry.agentName === agentFilter)
-          : registry.agents;
-        const capabilities = agentFilter
-          ? registry.capabilities.filter((entry) => entry.agents.includes(agentFilter))
-          : registry.capabilities;
-        return {
-          generatedAt: registry.generatedAt,
-          agents,
-          capabilities,
-          agentCount: agents.length,
-          capabilityCount: capabilities.length,
-        };
-      },
-      (result) => {
-        if (result.agents.length === 0) return ['No agent capabilities found.'];
-        return [
-          `Agents: ${result.agentCount}`,
-          `Capabilities: ${result.capabilityCount}`,
-          ...result.agents.map((entry) =>
-            `${entry.agentName} caps=${entry.capabilities.length} skills=${entry.skills.length} adapters=${entry.adapters.length}`),
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    capabilityCmd
-      .command('search <query>')
-      .description('Search capabilities by token or agent identifier')
-      .option('--agent <name>', 'Filter search results by one agent')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((query, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const agentFilter = normalizeToken(opts.agent);
-        const results = workgraph.capability.searchCapabilityRegistry(workspacePath, query)
-          .filter((entry) => !agentFilter || entry.agents.includes(agentFilter));
-        return {
-          query: String(query),
-          agent: agentFilter || undefined,
-          results,
-          count: results.length,
-        };
-      },
-      (result) => {
-        if (result.results.length === 0) return [`No capabilities matched "${result.query}".`];
-        return [
-          ...result.results.map((entry) => `${entry.capability} <- ${entry.agents.join(', ')}`),
-          `${result.count} capability match(es)`,
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    capabilityCmd
-      .command('match <threadRef>')
-      .description('Match one thread against an agent capability profile')
-      .option('-a, --agent <name>', 'Agent identity', defaultActor)
-      .option('--capabilities <items>', 'Comma-separated extra capabilities')
-      .option('--skills <items>', 'Comma-separated extra skills')
-      .option('--adapters <items>', 'Comma-separated extra adapters')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((threadRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const normalizedAgent = normalizeToken(opts.agent ?? defaultActor);
-        if (!normalizedAgent) {
-          throw new Error('Agent name is required. Provide --agent.');
-        }
-        const threadInstance = workgraph.capability.resolveThreadInstance(workspacePath, threadRef);
-        if (!threadInstance || threadInstance.type !== 'thread') {
-          throw new Error(`Thread not found: ${threadRef}`);
-        }
-
-        const resolved = workgraph.capability.resolveAgentCapabilityProfile(workspacePath, normalizedAgent);
-        const mergedCapabilities = dedupeStrings([
-          ...resolved.capabilities,
-          ...(csv(opts.capabilities) ?? []).map((item) => normalizeToken(item)),
-        ]);
-        const mergedSkills = dedupeStrings([
-          ...resolved.skills,
-          ...(csv(opts.skills) ?? []).map((item) => normalizeToken(item)),
-        ]);
-        const mergedAdapters = dedupeStrings([
-          ...resolved.adapters,
-          ...(csv(opts.adapters) ?? []).map((item) => normalizeToken(item)),
-        ]);
-        const profile = {
-          ...resolved,
-          capabilities: mergedCapabilities,
-          skills: mergedSkills,
-          adapters: mergedAdapters,
-        };
-        const match = workgraph.capability.matchThreadToCapabilityProfile(threadInstance, profile);
-
-        return {
-          thread: match.thread,
-          profile,
-          requirements: match.requirements,
-          missing: match.missing,
-          matched: match.matched,
-        };
-      },
-      (result) => {
-        const requirementSummary = [
-          `capabilities=${result.requirements.capabilities.join(', ') || 'none'}`,
-          `skills=${result.requirements.skills.join(', ') || 'none'}`,
-          `adapters=${result.requirements.adapters.join(', ') || 'none'}`,
-        ].join(' ');
-        const missingSummary = [
-          `capabilities=${result.missing.capabilities.join(', ') || 'none'}`,
-          `skills=${result.missing.skills.join(', ') || 'none'}`,
-          `adapters=${result.missing.adapters.join(', ') || 'none'}`,
-        ].join(' ');
-        return [
-          `Thread: ${result.thread.path}`,
-          `Agent: ${result.profile.agentName}`,
-          `Matched: ${result.matched}`,
-          `Requirements: ${requirementSummary}`,
-          `Missing: ${missingSummary}`,
-        ];
-      },
-    ),
-  );
-}
-
-function normalizeToken(value: unknown): string {
-  return String(value ?? '')
-    .trim()
-    .toLowerCase();
-}
-
-function dedupeStrings(values: string[]): string[] {
-  return [...new Set(values.filter(Boolean))];
-}
diff --git a/packages/cli/src/cli/commands/cursor.ts b/packages/cli/src/cli/commands/cursor.ts
deleted file mode 100644
index 6dc2c2e..0000000
--- a/packages/cli/src/cli/commands/cursor.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerCursorCommands(program: Command, defaultActor: string): void {
-  const cursorCmd = program
-    .command('cursor')
-    .description('Configure and run Cursor Automations bridge flows');
-
-  addWorkspaceOption(
-    cursorCmd
-      .command('setup')
-      .description('Configure Cursor webhook + dispatch bridge defaults')
-      .option('-a, --actor <name>', 'Dispatch actor for bridged runs', defaultActor)
-      .option('--enabled <bool>', 'Enable bridge (true|false)')
-      .option('--secret <value>', 'Webhook HMAC shared secret')
-      .option('--event-types <patterns>', 'Comma-separated event patterns (supports *)')
-      .option('--adapter <name>', 'Dispatch adapter default')
-      .option('--execute <bool>', 'Execute dispatch run immediately (true|false)')
-      .option('--agents <actors>', 'Comma-separated agent identities')
-      .option('--max-steps <n>', 'Maximum scheduler steps')
-      .option('--step-delay-ms <ms>', 'Delay between scheduler steps')
-      .option('--space <spaceRef>', 'Restrict dispatch to one space')
-      .option('--checkpoint <bool>', 'Create dispatch checkpoint (true|false)')
-      .option('--timeout-ms <ms>', 'Execution timeout in milliseconds')
-      .option('--dispatch-mode <mode>', 'direct|self-assembly')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const config = workgraph.cursorBridge.setupCursorBridge(workspacePath, {
-          actor: opts.actor,
-          enabled: parseOptionalBoolean(opts.enabled, 'enabled'),
-          secret: opts.secret,
-          allowedEventTypes: csv(opts.eventTypes),
-          dispatch: {
-            adapter: opts.adapter,
-            execute: parseOptionalBoolean(opts.execute, 'execute'),
-            agents: csv(opts.agents),
-            maxSteps: parseOptionalInt(opts.maxSteps, 'max-steps'),
-            stepDelayMs: parseOptionalInt(opts.stepDelayMs, 'step-delay-ms'),
-            space: opts.space,
-            createCheckpoint: parseOptionalBoolean(opts.checkpoint, 'checkpoint'),
-            timeoutMs: parseOptionalInt(opts.timeoutMs, 'timeout-ms'),
-            dispatchMode: parseDispatchMode(opts.dispatchMode),
-          },
-        });
-        const status = workgraph.cursorBridge.getCursorBridgeStatus(workspacePath, {
-          recentEventsLimit: 3,
-        });
-        return {
-          config,
-          status,
-        };
-      },
-      (result) => [
-        `Cursor bridge configured: ${result.status.configPath}`,
-        `Enabled: ${result.config.enabled}`,
-        `Webhook secret: ${result.status.webhook.hasSecret ? 'configured' : 'not set'}`,
-        `Allowed events: ${result.config.webhook.allowedEventTypes.join(', ')}`,
-        `Dispatch default: actor=${result.config.dispatch.actor} adapter=${result.config.dispatch.adapter} execute=${result.config.dispatch.execute}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    cursorCmd
-      .command('status')
-      .description('Show Cursor bridge configuration and recent bridge events')
-      .option('--events <n>', 'Number of recent bridge events to show', '5')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.cursorBridge.getCursorBridgeStatus(workspacePath, {
-          recentEventsLimit: parseOptionalInt(opts.events, 'events') ?? 5,
-        });
-      },
-      (result) => [
-        `Configured: ${result.configured}`,
-        `Enabled: ${result.enabled}`,
-        `Provider: ${result.provider}`,
-        `Config path: ${result.configPath}`,
-        `Events path: ${result.eventsPath}`,
-        `Webhook secret: ${result.webhook.hasSecret ? 'configured' : 'not set'}`,
-        `Allowed events: ${result.webhook.allowedEventTypes.join(', ')}`,
-        `Dispatch default: actor=${result.dispatch.actor} adapter=${result.dispatch.adapter} execute=${result.dispatch.execute}`,
-        ...(result.recentEvents.length === 0
-          ? ['Recent events: none']
-          : [
-              'Recent events:',
-              ...result.recentEvents.map((event) =>
-                `- ${event.ts} ${event.eventType} run=${event.runId ?? 'none'} status=${event.runStatus ?? 'none'}${event.error ? ` error=${event.error}` : ''}`),
-            ]),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    cursorCmd
-      .command('dispatch <objective>')
-      .description('Dispatch one Cursor automation event through the bridge')
-      .option('--event-type <type>', 'Cursor event type', 'cursor.automation.manual')
-      .option('--event-id <id>', 'Cursor event id')
-      .option('--actor <name>', 'Override dispatch actor')
-      .option('--adapter <name>', 'Override dispatch adapter')
-      .option('--execute <bool>', 'Execute dispatch run immediately (true|false)')
-      .option('--context <json>', 'JSON object merged into dispatch context')
-      .option('--idempotency-key <key>', 'Override idempotency key')
-      .option('--agents <actors>', 'Comma-separated agent identities')
-      .option('--max-steps <n>', 'Maximum scheduler steps')
-      .option('--step-delay-ms <ms>', 'Delay between scheduler steps')
-      .option('--space <spaceRef>', 'Restrict dispatch to one space')
-      .option('--checkpoint <bool>', 'Create dispatch checkpoint (true|false)')
-      .option('--timeout-ms <ms>', 'Execution timeout in milliseconds')
-      .option('--dispatch-mode <mode>', 'direct|self-assembly')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((objective, opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const result = await workgraph.cursorBridge.dispatchCursorAutomationEvent(workspacePath, {
-          source: 'cli-dispatch',
-          eventType: opts.eventType,
-          eventId: opts.eventId,
-          objective,
-          actor: opts.actor,
-          adapter: opts.adapter,
-          execute: parseOptionalBoolean(opts.execute, 'execute'),
-          context: parseOptionalJsonObject(opts.context, 'context'),
-          idempotencyKey: opts.idempotencyKey,
-          agents: csv(opts.agents),
-          maxSteps: parseOptionalInt(opts.maxSteps, 'max-steps'),
-          stepDelayMs: parseOptionalInt(opts.stepDelayMs, 'step-delay-ms'),
-          space: opts.space,
-          createCheckpoint: parseOptionalBoolean(opts.checkpoint, 'checkpoint'),
-          timeoutMs: parseOptionalInt(opts.timeoutMs, 'timeout-ms'),
-          dispatchMode: parseDispatchMode(opts.dispatchMode),
-        });
-        return result;
-      },
-      (result) => [
-        `Dispatched Cursor event: ${result.event.eventType}`,
-        `Run: ${result.run.id} [${result.run.status}]`,
-        `Adapter: ${result.run.adapter}`,
-        ...(result.run.output ? [`Output: ${result.run.output}`] : []),
-        ...(result.run.error ? [`Error: ${result.run.error}`] : []),
-      ],
-    ),
-  );
-}
-
-function parseOptionalBoolean(value: unknown, optionName: string): boolean | undefined {
-  if (value === undefined) return undefined;
-  if (typeof value === 'boolean') return value;
-  const normalized = String(value).trim().toLowerCase();
-  if (normalized === 'true' || normalized === '1' || normalized === 'yes') return true;
-  if (normalized === 'false' || normalized === '0' || normalized === 'no') return false;
-  throw new Error(`Invalid --${optionName}. Expected true|false.`);
-}
-
-function parseOptionalInt(value: unknown, optionName: string): number | undefined {
-  if (value === undefined) return undefined;
-  const parsed = Number.parseInt(String(value), 10);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Invalid --${optionName}. Expected an integer.`);
-  }
-  return parsed;
-}
-
-function parseDispatchMode(value: unknown): 'direct' | 'self-assembly' | undefined {
-  if (value === undefined) return undefined;
-  const normalized = String(value).trim().toLowerCase();
-  if (!normalized) return undefined;
-  if (normalized === 'direct' || normalized === 'self-assembly') {
-    return normalized;
-  }
-  throw new Error(`Invalid --dispatch-mode "${String(value)}". Expected direct|self-assembly.`);
-}
-
-function parseOptionalJsonObject(value: unknown, optionName: string): Record<string, unknown> | undefined {
-  if (value === undefined) return undefined;
-  const text = String(value).trim();
-  if (!text) return undefined;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new Error(`Invalid --${optionName}. Expected valid JSON.`);
-  }
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error(`Invalid --${optionName}. Expected a JSON object.`);
-  }
-  return parsed as Record<string, unknown>;
-}
diff --git a/packages/cli/src/cli/commands/dispatch.ts b/packages/cli/src/cli/commands/dispatch.ts
deleted file mode 100644
index 44f7182..0000000
--- a/packages/cli/src/cli/commands/dispatch.ts
+++ /dev/null
@@ -1,401 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerDispatchCommands(program: Command, defaultActor: string): void {
-  const dispatchCmd = program
-    .command('dispatch')
-    .description('Programmatic runtime dispatch contract');
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('create <objective>')
-      .description('Create a new run dispatch request')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--adapter <name>', 'Adapter name', 'cursor-cloud')
-      .option('--idempotency-key <key>', 'Idempotency key')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((objective, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: workgraph.dispatch.createRun(workspacePath, {
-            actor: opts.actor,
-            adapter: opts.adapter,
-            objective,
-            idempotencyKey: opts.idempotencyKey,
-          }),
-        };
-      },
-      (result) => [`Run created: ${result.run.id} [${result.run.status}]`],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('claim <threadRef>')
-      .description('Claim a thread after passing quality gates')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((threadRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.dispatch.claimThread(workspacePath, threadRef, opts.actor);
-      },
-      (result) => [
-        `Claimed thread: ${result.thread.path}`,
-        `Gates checked: ${result.gateCheck.gates.length}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('create-execute <objective>')
-      .description('Create and execute a run with autonomous multi-agent coordination')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--adapter <name>', 'Adapter name', 'cursor-cloud')
-      .option('--idempotency-key <key>', 'Idempotency key')
-      .option('--agents <actors>', 'Comma-separated agent identities for autonomous execution')
-      .option('--max-steps <n>', 'Maximum scheduler steps', '200')
-      .option('--step-delay-ms <ms>', 'Delay between scheduling steps', '25')
-      .option('--space <spaceRef>', 'Restrict execution to one space')
-      .option('--no-checkpoint', 'Skip automatic checkpoint generation after execution')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((objective, opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: await workgraph.dispatch.createAndExecuteRun(
-            workspacePath,
-            {
-              actor: opts.actor,
-              adapter: opts.adapter,
-              objective,
-              idempotencyKey: opts.idempotencyKey,
-            },
-            {
-              agents: csv(opts.agents),
-              maxSteps: Number.parseInt(String(opts.maxSteps), 10),
-              stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
-              space: opts.space,
-              createCheckpoint: opts.checkpoint,
-            },
-          ),
-        };
-      },
-      (result) => [
-        `Run executed: ${result.run.id} [${result.run.status}]`,
-        ...(result.run.output ? [`Output: ${result.run.output}`] : []),
-        ...(result.run.error ? [`Error: ${result.run.error}`] : []),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('list')
-      .description('List runs')
-      .option('--status <status>', 'queued|running|succeeded|failed|cancelled')
-      .option('--limit <n>', 'Result limit')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          runs: workgraph.dispatch.listRuns(workspacePath, {
-            status: opts.status,
-            limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : undefined,
-          }),
-        };
-      },
-      (result) => result.runs.map((run) => `${run.id} [${run.status}] ${run.objective}`),
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('status <runId>')
-      .description('Get run status by ID')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: workgraph.dispatch.status(workspacePath, runId),
-        };
-      },
-      (result) => [`${result.run.id} [${result.run.status}]`],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('execute <runId>')
-      .description('Execute a queued/running run via adapter autonomous scheduling')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--agents <actors>', 'Comma-separated agent identities')
-      .option('--max-steps <n>', 'Maximum scheduler steps', '200')
-      .option('--step-delay-ms <ms>', 'Delay between scheduling steps', '25')
-      .option('--space <spaceRef>', 'Restrict execution to one space')
-      .option('--no-checkpoint', 'Skip automatic checkpoint generation after execution')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: await workgraph.dispatch.executeRun(workspacePath, runId, {
-            actor: opts.actor,
-            agents: csv(opts.agents),
-            maxSteps: Number.parseInt(String(opts.maxSteps), 10),
-            stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
-            space: opts.space,
-            createCheckpoint: opts.checkpoint,
-          }),
-        };
-      },
-      (result) => [
-        `Run executed: ${result.run.id} [${result.run.status}]`,
-        ...(result.run.output ? [`Output: ${result.run.output}`] : []),
-        ...(result.run.error ? [`Error: ${result.run.error}`] : []),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('retry <runId>')
-      .description('Retry a failed run by creating a new run attempt')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--adapter <name>', 'Adapter override for retry')
-      .option('--objective <text>', 'Objective override for retry')
-      .option('--no-execute', 'Create retry run but do not execute immediately')
-      .option('--agents <actors>', 'Comma-separated agent identities')
-      .option('--max-steps <n>', 'Maximum scheduler steps', '200')
-      .option('--step-delay-ms <ms>', 'Delay between scheduling steps', '25')
-      .option('--space <spaceRef>', 'Restrict execution to one space')
-      .option('--timeout-ms <ms>', 'Execution timeout in milliseconds')
-      .option('--dispatch-mode <mode>', 'direct|self-assembly')
-      .option('--self-assembly-agent <agent>', 'Agent identity for self-assembly dispatch mode')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: await workgraph.dispatch.retryRun(workspacePath, runId, {
-            actor: opts.actor,
-            adapter: opts.adapter,
-            objective: opts.objective,
-            execute: opts.execute,
-            agents: csv(opts.agents),
-            maxSteps: Number.parseInt(String(opts.maxSteps), 10),
-            stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
-            space: opts.space,
-            timeoutMs: opts.timeoutMs ? Number.parseInt(String(opts.timeoutMs), 10) : undefined,
-            dispatchMode: opts.dispatchMode,
-            selfAssemblyAgent: opts.selfAssemblyAgent,
-          }),
-        };
-      },
-      (result) => [
-        `Retried run: ${result.run.id} [${result.run.status}]`,
-        ...(result.run.context?.retry_of_run_id ? [`Source run: ${String(result.run.context.retry_of_run_id)}`] : []),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('followup <runId> <input>')
-      .description('Send follow-up input to a run')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, input, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: workgraph.dispatch.followup(workspacePath, runId, opts.actor, input),
-        };
-      },
-      (result) => [`Follow-up recorded: ${result.run.id} [${result.run.status}]`],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('stop <runId>')
-      .description('Cancel a run')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: workgraph.dispatch.stop(workspacePath, runId, opts.actor),
-        };
-      },
-      (result) => [`Stopped run: ${result.run.id} [${result.run.status}]`],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('heartbeat <runId>')
-      .description('Heartbeat a running run lease and extend lease_expiry')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--lease-minutes <n>', 'Lease extension in minutes')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          run: workgraph.dispatch.heartbeat(workspacePath, runId, {
-            actor: opts.actor,
-            leaseMinutes: opts.leaseMinutes ? Number.parseInt(String(opts.leaseMinutes), 10) : undefined,
-          }),
-        };
-      },
-      (result) => [
-        `Heartbeated run: ${result.run.id}`,
-        `Lease expires: ${String(result.run.leaseExpires ?? 'none')}`,
-        `Heartbeats: ${(result.run.heartbeats ?? []).length}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('reconcile')
-      .description('Reconcile dispatch leases and externally brokered runs')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--run-id <runId>', 'Optional run id to reconcile one externally brokered run')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.reconciler.reconcileDispatchRuns(workspacePath, opts.actor, {
-          runId: opts.runId,
-        });
-      },
-      (result) => [
-        `Reconciled at: ${result.reconciledAt}`,
-        `Lease-inspected runs: ${result.lease.inspectedRuns}`,
-        `Lease-requeued runs: ${result.lease.requeuedRuns.length}`,
-        ...result.lease.requeuedRuns.map((run) => `- lease requeued ${run.id}`),
-        `External-inspected runs: ${result.external.inspectedRuns}`,
-        `External-reconciled runs: ${result.external.reconciledRuns.length}`,
-        ...result.external.reconciledRuns.map((run) => `- external reconciled ${run.id} [${run.status}]`),
-        ...result.external.failures.map((failure) => `- external reconcile failed ${failure.runId}: ${failure.error}`),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('handoff <runId>')
-      .description('Create a structured run handoff to another agent')
-      .requiredOption('--to <agent>', 'Target agent')
-      .requiredOption('--reason <text>', 'Reason for handoff')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--adapter <name>', 'Adapter override for handoff run')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.dispatch.handoffRun(workspacePath, runId, {
-          actor: opts.actor,
-          to: opts.to,
-          reason: opts.reason,
-          adapter: opts.adapter,
-        });
-      },
-      (result) => [
-        `Handoff created: ${result.handoffRun.id} (from ${result.sourceRun.id})`,
-        `Target agent: ${result.handoffRun.actor}`,
-        `Objective: ${result.handoffRun.objective}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('mark <runId>')
-      .description('Set run status transition explicitly')
-      .requiredOption('--status <status>', 'running|succeeded|failed|cancelled')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--output <text>', 'Optional output payload')
-      .option('--error <text>', 'Optional error payload')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const status = normalizeRunStatus(opts.status);
-        return {
-          run: workgraph.dispatch.markRun(workspacePath, runId, opts.actor, status, {
-            output: opts.output,
-            error: opts.error,
-          }),
-        };
-      },
-      (result) => [`Marked run: ${result.run.id} [${result.run.status}]`],
-    ),
-  );
-
-  addWorkspaceOption(
-    dispatchCmd
-      .command('logs <runId>')
-      .description('Read logs from a run')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((runId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          runId,
-          logs: workgraph.dispatch.logs(workspacePath, runId),
-        };
-      },
-      (result) => result.logs.map((entry) => `${entry.ts} [${entry.level}] ${entry.message}`),
-    ),
-  );
-}
-
-function normalizeRunStatus(status: string): 'running' | 'succeeded' | 'failed' | 'cancelled' {
-  const normalized = String(status).toLowerCase();
-  if (normalized === 'running' || normalized === 'succeeded' || normalized === 'failed' || normalized === 'cancelled') {
-    return normalized;
-  }
-  throw new Error(`Invalid run status "${status}". Expected running|succeeded|failed|cancelled.`);
-}
diff --git a/packages/cli/src/cli/commands/federation.ts b/packages/cli/src/cli/commands/federation.ts
deleted file mode 100644
index be966a5..0000000
--- a/packages/cli/src/cli/commands/federation.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerFederationCommands(program: Command, threadCmd: Command, defaultActor: string): void {
-  const federationCmd = program
-    .command('federation')
-    .description('Manage cross-workspace federation remotes and sync state');
-
-  addWorkspaceOption(
-    federationCmd
-      .command('add <workspaceId> <remoteWorkspacePath>')
-      .description('Add or update a federated remote workspace')
-      .option('--name <name>', 'Friendly display name')
-      .option('--tags <tags>', 'Comma-separated tags')
-      .option('--disabled', 'Store remote as disabled')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((workspaceId, remoteWorkspacePath, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.federation.addRemoteWorkspace(workspacePath, {
-          id: workspaceId,
-          path: remoteWorkspacePath,
-          name: opts.name,
-          enabled: !opts.disabled,
-          tags: csv(opts.tags),
-        });
-      },
-      (result) => [
-        `${result.created ? 'Added' : 'Updated'} federation remote: ${result.remote.id}`,
-        `Path: ${result.remote.path}`,
-        `Enabled: ${result.remote.enabled}`,
-        `Config: ${result.configPath}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    federationCmd
-      .command('remove <workspaceId>')
-      .description('Remove a federated remote workspace')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((workspaceId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.federation.removeRemoteWorkspace(workspacePath, workspaceId);
-      },
-      (result) => result.changed
-        ? [
-            `Removed federation remote: ${result.removed?.id ?? 'unknown'}`,
-            `Config: ${result.configPath}`,
-          ]
-        : [`No federation remote found for id: ${workspaceId}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    federationCmd
-      .command('list')
-      .description('List configured federation remotes')
-      .option('--enabled-only', 'Only show enabled remotes')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const remotes = workgraph.federation.listRemoteWorkspaces(workspacePath, {
-          includeDisabled: !opts.enabledOnly,
-        });
-        return {
-          remotes,
-          count: remotes.length,
-        };
-      },
-      (result) => {
-        if (result.remotes.length === 0) return ['No federation remotes configured.'];
-        return [
-          ...result.remotes.map((remote) =>
-            `${remote.enabled ? '[enabled]' : '[disabled]'} ${remote.id} ${remote.path}`),
-          `${result.count} remote(s)`,
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    federationCmd
-      .command('sync')
-      .description('Sync metadata from federated remote workspaces')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--remote <ids>', 'Comma-separated remote ids to sync')
-      .option('--include-disabled', 'Include disabled remotes')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.federation.syncFederation(workspacePath, opts.actor, {
-          remoteIds: csv(opts.remote),
-          includeDisabled: !!opts.includeDisabled,
-        });
-      },
-      (result) => [
-        `Synced federation at: ${result.syncedAt}`,
-        `Actor: ${result.actor}`,
-        ...result.remotes.map((remote) =>
-          `${remote.id} ${remote.status} threads=${remote.threadCount} open=${remote.openThreadCount}${remote.error ? ` error=${remote.error}` : ''}`),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    threadCmd
-      .command('link <threadRef> <remoteWorkspaceId> <remoteThreadRef>')
-      .description('Link a local thread to a remote federated thread')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((threadRef, remoteWorkspaceId, remoteThreadRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.federation.linkThreadToRemoteWorkspace(
-          workspacePath,
-          threadRef,
-          remoteWorkspaceId,
-          remoteThreadRef,
-          opts.actor,
-        );
-      },
-      (result) => [
-        `${result.created ? 'Linked' : 'Already linked'} thread: ${result.thread.path}`,
-        `Federation link: ${result.link}`,
-      ],
-    ),
-  );
-}
diff --git a/packages/cli/src/cli/commands/mission.ts b/packages/cli/src/cli/commands/mission.ts
deleted file mode 100644
index e619d1d..0000000
--- a/packages/cli/src/cli/commands/mission.ts
+++ /dev/null
@@ -1,318 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerMissionCommands(program: Command, defaultActor: string): void {
-  const missionCmd = program
-    .command('mission')
-    .description('Mission primitive lifecycle and orchestration');
-
-  addWorkspaceOption(
-    missionCmd
-      .command('create <title>')
-      .description('Create a mission in planning state')
-      .requiredOption('--goal <goal>', 'Mission goal statement')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--mid <mid>', 'Mission identifier slug override')
-      .option('--description <text>', 'Mission summary/description')
-      .option('--priority <level>', 'urgent|high|medium|low', 'medium')
-      .option('--owner <name>', 'Mission owner')
-      .option('--project <ref>', 'Project ref (projects/<slug>.md)')
-      .option('--space <ref>', 'Space ref (spaces/<slug>.md)')
-      .option('--constraints <items>', 'Comma-separated mission constraints')
-      .option('--tags <items>', 'Comma-separated tags')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((title, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          mission: workgraph.mission.createMission(workspacePath, title, opts.goal, opts.actor, {
-            mid: opts.mid,
-            description: opts.description,
-            priority: normalizePriority(opts.priority),
-            owner: opts.owner,
-            project: opts.project,
-            space: opts.space,
-            constraints: csv(opts.constraints),
-            tags: csv(opts.tags),
-          }),
-        };
-      },
-      (result) => [
-        `Created mission: ${result.mission.path}`,
-        `Status: ${String(result.mission.fields.status)}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('plan <missionRef>')
-      .description('Plan mission milestones/features and create feature threads')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--goal <goal>', 'Plan goal override')
-      .option('--constraints <items>', 'Comma-separated constraints')
-      .option('--estimated-runs <n>', 'Estimated number of runs')
-      .option('--estimated-cost-usd <n>', 'Estimated USD cost')
-      .option('--append', 'Append milestones instead of replacing')
-      .option('--milestones <json>', 'Milestones JSON payload')
-      .option('--milestones-file <path>', 'Milestones JSON file path')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((missionRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const milestones = readMissionMilestonesInput(opts.milestones, opts.milestonesFile);
-        return {
-          mission: workgraph.mission.planMission(
-            workspacePath,
-            missionRef,
-            {
-              goal: opts.goal,
-              constraints: csv(opts.constraints),
-              estimated_runs: parseOptionalInt(opts.estimatedRuns),
-              estimated_cost_usd: parseOptionalNumber(opts.estimatedCostUsd),
-              replaceMilestones: !opts.append,
-              milestones,
-            },
-            opts.actor,
-          ),
-        };
-      },
-      (result) => [
-        `Planned mission: ${result.mission.path}`,
-        `Milestones: ${Array.isArray(result.mission.fields.milestones) ? result.mission.fields.milestones.length : 0}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('approve <missionRef>')
-      .description('Approve planned mission')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((missionRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          mission: workgraph.mission.approveMission(workspacePath, missionRef, opts.actor),
-        };
-      },
-      (result) => [`Approved mission: ${result.mission.path}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('start <missionRef>')
-      .description('Start mission execution and optionally run one orchestrator cycle')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--no-run-cycle', 'Do not run orchestrator cycle after start')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((missionRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const started = workgraph.mission.startMission(workspacePath, missionRef, opts.actor);
-        const cycle = opts.runCycle === false
-          ? null
-          : workgraph.missionOrchestrator.runMissionOrchestratorCycle(workspacePath, started.path, opts.actor);
-        return { mission: started, cycle };
-      },
-      (result) => [
-        `Started mission: ${result.mission.path}`,
-        ...(result.cycle ? [`Cycle actions: ${result.cycle.actions.length}`] : []),
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('status <missionRef>')
-      .description('Show mission primitive status and milestones')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((missionRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const missionInstance = workgraph.mission.missionStatus(workspacePath, missionRef);
-        const progress = workgraph.mission.missionProgress(workspacePath, missionInstance.path);
-        return { mission: missionInstance, progress };
-      },
-      (result) => [
-        `Mission: ${result.mission.path}`,
-        `Status: ${String(result.mission.fields.status)}`,
-        `Progress: ${result.progress.percentComplete}% (${result.progress.doneFeatures}/${result.progress.totalFeatures} features)`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('progress <missionRef>')
-      .description('Show mission progress metrics only')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((missionRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.mission.missionProgress(workspacePath, missionRef);
-      },
-      (result) => [
-        `Mission ${result.mid}: ${result.status}`,
-        `Milestones: ${result.passedMilestones}/${result.totalMilestones}`,
-        `Features: ${result.doneFeatures}/${result.totalFeatures}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('intervene <missionRef>')
-      .description('Intervene in mission execution (status/priority/skip/append milestones)')
-      .requiredOption('--reason <reason>', 'Intervention reason')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--set-priority <priority>', 'urgent|high|medium|low')
-      .option('--set-status <status>', 'planning|approved|active|validating|completed|failed')
-      .option('--skip-feature <milestoneId:threadPath>', 'Skip one feature in a milestone')
-      .option('--append-milestones <json>', 'Milestones JSON to append')
-      .option('--append-milestones-file <path>', 'Milestones JSON file to append')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((missionRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const skipFeature = parseSkipFeature(opts.skipFeature);
-        const appendMilestones = readMissionMilestonesInput(opts.appendMilestones, opts.appendMilestonesFile, false);
-        return {
-          mission: workgraph.mission.interveneMission(workspacePath, missionRef, {
-            reason: String(opts.reason),
-            setPriority: opts.setPriority ? normalizePriority(opts.setPriority) : undefined,
-            setStatus: opts.setStatus ? normalizeMissionStatus(opts.setStatus) : undefined,
-            skipFeature: skipFeature ?? undefined,
-            appendMilestones: appendMilestones.length > 0 ? appendMilestones : undefined,
-          }, opts.actor),
-        };
-      },
-      (result) => [`Intervened mission: ${result.mission.path}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    missionCmd
-      .command('list')
-      .description('List missions')
-      .option('--status <status>', 'Filter by mission status')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const missions = workgraph.mission.listMissions(workspacePath)
-          .filter((entry) => !opts.status || String(entry.fields.status) === String(opts.status));
-        return { missions };
-      },
-      (result) => {
-        if (result.missions.length === 0) return ['No missions found.'];
-        return result.missions.map((entry) =>
-          `[${String(entry.fields.status)}] ${String(entry.fields.title)} -> ${entry.path}`,
-        );
-      },
-    ),
-  );
-}
-
-function readMissionMilestonesInput(
-  rawJson: string | undefined,
-  jsonFile: string | undefined,
-  required: boolean = true,
-): workgraph.mission.MissionMilestonePlanInput[] {
-  if (!rawJson && !jsonFile) {
-    if (required) {
-      throw new Error('Mission milestones input is required. Use --milestones or --milestones-file.');
-    }
-    return [];
-  }
-  const parsed = rawJson
-    ? JSON.parse(rawJson)
-    : JSON.parse(fs.readFileSync(path.resolve(String(jsonFile)), 'utf-8'));
-  if (!Array.isArray(parsed)) {
-    throw new Error('Milestones input must be a JSON array.');
-  }
-  return parsed as workgraph.mission.MissionMilestonePlanInput[];
-}
-
-function normalizePriority(value: string): 'urgent' | 'high' | 'medium' | 'low' {
-  const normalized = String(value).trim().toLowerCase();
-  if (normalized === 'urgent' || normalized === 'high' || normalized === 'medium' || normalized === 'low') {
-    return normalized;
-  }
-  throw new Error(`Invalid mission priority "${value}". Expected urgent|high|medium|low.`);
-}
-
-function normalizeMissionStatus(value: string): workgraph.MissionStatus {
-  const normalized = String(value).trim().toLowerCase();
-  if (
-    normalized === 'planning'
-    || normalized === 'approved'
-    || normalized === 'active'
-    || normalized === 'validating'
-    || normalized === 'completed'
-    || normalized === 'failed'
-  ) {
-    return normalized;
-  }
-  throw new Error(`Invalid mission status "${value}". Expected planning|approved|active|validating|completed|failed.`);
-}
-
-function parseOptionalInt(value: unknown): number | undefined {
-  if (value === undefined || value === null || String(value).trim() === '') return undefined;
-  const parsed = Number.parseInt(String(value), 10);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Invalid integer value "${String(value)}".`);
-  }
-  return parsed;
-}
-
-function parseOptionalNumber(value: unknown): number | null | undefined {
-  if (value === undefined || value === null || String(value).trim() === '') return undefined;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Invalid number value "${String(value)}".`);
-  }
-  return parsed;
-}
-
-function parseSkipFeature(
-  value: unknown,
-): { milestoneId: string; threadPath: string } | null {
-  if (value === undefined || value === null) return null;
-  const raw = String(value).trim();
-  if (!raw) return null;
-  const separator = raw.indexOf(':');
-  if (separator <= 0 || separator >= raw.length - 1) {
-    throw new Error('Invalid --skip-feature value. Expected "<milestoneId>:<threadPath>".');
-  }
-  return {
-    milestoneId: raw.slice(0, separator).trim(),
-    threadPath: raw.slice(separator + 1).trim(),
-  };
-}
diff --git a/packages/cli/src/cli/commands/portability.ts b/packages/cli/src/cli/commands/portability.ts
deleted file mode 100644
index cc4fbc7..0000000
--- a/packages/cli/src/cli/commands/portability.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerPortabilityCommands(program: Command): void {
-  addWorkspaceOption(
-    program
-      .command('export <snapshotPath>')
-      .description('Export current workspace as tar.gz snapshot')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((snapshotPath, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.exportImport.exportWorkspaceSnapshot(workspacePath, snapshotPath);
-      },
-      (result) => [
-        `Exported workspace snapshot: ${result.snapshotPath}`,
-        `Workspace: ${result.workspacePath}`,
-        `Bytes: ${result.bytes}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    program
-      .command('import <snapshotPath>')
-      .description('Import a tar.gz snapshot into a workspace')
-      .option('--overwrite', 'Replace existing workspace contents')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((snapshotPath, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.exportImport.importWorkspaceSnapshot(snapshotPath, workspacePath, {
-          overwrite: !!opts.overwrite,
-        });
-      },
-      (result) => [
-        `Imported workspace snapshot: ${result.snapshotPath}`,
-        `Workspace: ${result.workspacePath}`,
-        `Files imported: ${result.filesImported}`,
-      ],
-    ),
-  );
-
-  program
-    .command('env')
-    .description('Show runtime environment and feature flags')
-    .option('--flag <name>', 'Resolve one feature flag by name')
-    .option('--json', 'Emit structured JSON output')
-    .action((opts) =>
-      runCommand(
-        opts,
-        () => {
-          const info = workgraph.environment.getEnvironmentInfo();
-          const selectedFlag = opts.flag
-            ? {
-                name: String(opts.flag),
-                enabled: workgraph.environment.isFeatureEnabled(String(opts.flag)),
-              }
-            : undefined;
-          return {
-            ...info,
-            selectedFlag,
-          };
-        },
-        (result) => [
-          `Environment: ${result.environment} (${result.source})`,
-          `Feature flags: ${Object.keys(result.featureFlags).length}`,
-          ...Object.entries(result.featureFlags)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([name, enabled]) => `- ${name}=${enabled}`),
-          ...(result.selectedFlag
-            ? [`Selected flag: ${result.selectedFlag.name}=${result.selectedFlag.enabled}`]
-            : []),
-        ],
-      ),
-    );
-}
diff --git a/packages/cli/src/cli/commands/safety.ts b/packages/cli/src/cli/commands/safety.ts
deleted file mode 100644
index 6a0f79f..0000000
--- a/packages/cli/src/cli/commands/safety.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerSafetyCommands(program: Command, defaultActor: string): void {
-  const safetyCmd = program
-    .command('safety')
-    .description('Continuous operations safety rails (rate limit, circuit breaker, kill switch)');
-
-  addWorkspaceOption(
-    safetyCmd
-      .command('status')
-      .description('Show current safety configuration and runtime state')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return workgraph.safety.getSafetyStatus(workspacePath);
-      },
-      (result) => [
-        `Blocked: ${result.blocked ? 'yes' : 'no'}`,
-        ...(result.reasons.length > 0 ? result.reasons.map((reason) => `Reason: ${reason}`) : []),
-        `Kill switch: ${result.config.killSwitch.engaged ? 'engaged' : 'released'}`,
-        `Rate limit: enabled=${result.config.rateLimit.enabled} window=${result.config.rateLimit.windowSeconds}s max=${result.config.rateLimit.maxOperations} used=${result.config.runtime.rateLimitOperations}`,
-        `Circuit breaker: enabled=${result.config.circuitBreaker.enabled} state=${result.config.runtime.circuitState} failures=${result.config.runtime.consecutiveFailures}`,
-        `Updated at: ${result.config.updatedAt}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    safetyCmd
-      .command('pause')
-      .description('Engage kill switch to pause autonomous operations')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--reason <text>', 'Optional pause reason')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          config: workgraph.safety.pauseSafetyOperations(workspacePath, opts.actor, opts.reason),
-        };
-      },
-      (result) => [
-        'Safety kill switch engaged.',
-        `Reason: ${String(result.config.killSwitch.reason ?? 'none')}`,
-        `Updated at: ${result.config.updatedAt}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    safetyCmd
-      .command('resume')
-      .description('Release kill switch and resume autonomous operations')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          config: workgraph.safety.resumeSafetyOperations(workspacePath, opts.actor),
-        };
-      },
-      (result) => [
-        'Safety kill switch released.',
-        `Updated at: ${result.config.updatedAt}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    safetyCmd
-      .command('reset')
-      .description('Reset safety runtime counters and circuit state')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--full', 'Also clear kill switch state')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          config: workgraph.safety.resetSafetyRails(workspacePath, {
-            actor: opts.actor,
-            clearKillSwitch: !!opts.full,
-          }),
-        };
-      },
-      (result) => [
-        'Safety runtime reset complete.',
-        `Circuit state: ${result.config.runtime.circuitState}`,
-        `Rate limit used: ${result.config.runtime.rateLimitOperations}`,
-        `Kill switch: ${result.config.killSwitch.engaged ? 'engaged' : 'released'}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    safetyCmd
-      .command('log')
-      .description('Show recent safety events from ledger')
-      .option('--count <n>', 'Number of entries', '20')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const parsedCount = Number.parseInt(String(opts.count), 10);
-        const count = Number.isFinite(parsedCount) ? Math.max(0, parsedCount) : 20;
-        return {
-          entries: workgraph.safety.listSafetyEvents(workspacePath, { count }),
-          count,
-        };
-      },
-      (result) => {
-        if (result.entries.length === 0) return ['No safety events found.'];
-        return result.entries.map((entry) => {
-          const eventName = readEventName(entry);
-          return `${entry.ts} ${eventName} actor=${entry.actor}`;
-        });
-      },
-    ),
-  );
-}
-
-function readEventName(entry: workgraph.LedgerEntry): string {
-  const data = entry.data as Record<string, unknown> | undefined;
-  const event = data?.event;
-  return typeof event === 'string' && event.trim().length > 0 ? event : 'safety.unknown';
-}
diff --git a/packages/cli/src/cli/commands/trigger.ts b/packages/cli/src/cli/commands/trigger.ts
deleted file mode 100644
index c10579b..0000000
--- a/packages/cli/src/cli/commands/trigger.ts
+++ /dev/null
@@ -1,505 +0,0 @@
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  addWorkspaceOption,
-  csv,
-  resolveWorkspacePath,
-  runCommand,
-} from '../core.js';
-
-export function registerTriggerCommands(program: Command, defaultActor: string): void {
-  const triggerCmd = program
-    .command('trigger')
-    .description('Programmable trigger primitives and evaluation engine');
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('create <name>')
-      .description('Create a trigger primitive (cron|webhook|event|manual)')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--type <type>', 'cron|webhook|event|manual', 'event')
-      .option('--condition <value>', 'Condition as cron text or JSON')
-      .option('--action <value>', 'Action as objective text or JSON')
-      .option('--objective <text>', 'Dispatch objective template shortcut')
-      .option('--adapter <name>', 'Dispatch adapter shortcut')
-      .option('--context <json>', 'Dispatch context JSON object shortcut')
-      .option('--enabled <bool>', 'Enable trigger (true|false)', 'true')
-      .option('--cooldown <seconds>', 'Cooldown seconds', '0')
-      .option('--tags <tags>', 'Comma-separated tags')
-      .option('--body <text>', 'Markdown body')
-      .option('--path <path>', 'Optional trigger markdown path override')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((name, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          trigger: workgraph.trigger.createTrigger(workspacePath, {
-            actor: opts.actor,
-            name,
-            type: parseTriggerType(opts.type),
-            condition: parseUnknownOption(opts.condition),
-            action: resolveActionInput(opts),
-            enabled: parseOptionalBoolean(opts.enabled, 'enabled'),
-            cooldown: parseOptionalInt(opts.cooldown, 'cooldown') ?? 0,
-            tags: csv(opts.tags),
-            body: opts.body,
-            path: opts.path,
-          }),
-        };
-      },
-      (result) => [
-        `Created trigger: ${result.trigger.path}`,
-        `Type: ${String(result.trigger.fields.type ?? 'event')}`,
-        `Enabled: ${String(result.trigger.fields.enabled ?? true)}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('list')
-      .description('List trigger primitives')
-      .option('--type <type>', 'Filter by cron|webhook|event|manual')
-      .option('--enabled <bool>', 'Filter by enabled state (true|false)')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const triggers = workgraph.trigger.listTriggers(workspacePath, {
-          type: opts.type ? parseTriggerType(opts.type) : undefined,
-          enabled: parseOptionalBoolean(opts.enabled, 'enabled'),
-        });
-        return {
-          triggers,
-          count: triggers.length,
-        };
-      },
-      (result) => {
-        if (result.triggers.length === 0) return ['No triggers found.'];
-        return [
-          ...result.triggers.map((trigger) =>
-            `[${String(trigger.fields.type ?? 'event')}] enabled=${String(trigger.fields.enabled ?? true)} ${trigger.path}`),
-          `${result.count} trigger(s)`,
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('show <triggerRef>')
-      .description('Show one trigger primitive')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const trigger = workgraph.trigger.showTrigger(workspacePath, triggerRef);
-        const history = workgraph.trigger.triggerHistory(workspacePath, triggerRef);
-        return {
-          trigger,
-          historyCount: history.length,
-        };
-      },
-      (result) => [
-        `Trigger: ${result.trigger.path}`,
-        `Name: ${String(result.trigger.fields.name ?? result.trigger.fields.title ?? result.trigger.path)}`,
-        `Type: ${String(result.trigger.fields.type ?? 'event')} Enabled: ${String(result.trigger.fields.enabled ?? true)}`,
-        `History entries: ${result.historyCount}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('update <triggerRef>')
-      .description('Update a trigger primitive')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--name <name>', 'Rename trigger')
-      .option('--type <type>', 'cron|webhook|event|manual')
-      .option('--condition <value>', 'Condition as cron text or JSON')
-      .option('--action <value>', 'Action as objective text or JSON')
-      .option('--objective <text>', 'Dispatch objective template shortcut')
-      .option('--adapter <name>', 'Dispatch adapter shortcut')
-      .option('--context <json>', 'Dispatch context JSON object shortcut')
-      .option('--enabled <bool>', 'Enable trigger (true|false)')
-      .option('--cooldown <seconds>', 'Cooldown seconds')
-      .option('--tags <tags>', 'Comma-separated tags')
-      .option('--body <text>', 'Replace markdown body')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          trigger: workgraph.trigger.updateTrigger(workspacePath, triggerRef, {
-            actor: opts.actor,
-            name: opts.name,
-            type: opts.type ? parseTriggerType(opts.type) : undefined,
-            condition: opts.condition !== undefined ? parseUnknownOption(opts.condition) : undefined,
-            action: resolveActionInput(opts, true),
-            enabled: parseOptionalBoolean(opts.enabled, 'enabled'),
-            cooldown: parseOptionalInt(opts.cooldown, 'cooldown'),
-            tags: opts.tags !== undefined ? (csv(opts.tags) ?? []) : undefined,
-            body: opts.body,
-          }),
-        };
-      },
-      (result) => [
-        `Updated trigger: ${result.trigger.path}`,
-        `Type: ${String(result.trigger.fields.type ?? 'event')}`,
-        `Enabled: ${String(result.trigger.fields.enabled ?? true)}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('delete <triggerRef>')
-      .description('Delete a trigger primitive (soft archive)')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        workgraph.trigger.deleteTrigger(workspacePath, triggerRef, opts.actor);
-        return { deleted: triggerRef };
-      },
-      (result) => [`Deleted trigger: ${result.deleted}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('enable <triggerRef>')
-      .description('Enable a trigger primitive')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          trigger: workgraph.trigger.enableTrigger(workspacePath, triggerRef, opts.actor),
-        };
-      },
-      (result) => [`Enabled trigger: ${result.trigger.path}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('disable <triggerRef>')
-      .description('Disable a trigger primitive')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          trigger: workgraph.trigger.disableTrigger(workspacePath, triggerRef, opts.actor),
-        };
-      },
-      (result) => [`Disabled trigger: ${result.trigger.path}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('evaluate [triggerRef]')
-      .description('Evaluate trigger engine once (all or one trigger)')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--now <iso>', 'Evaluation timestamp override (ISO-8601)')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const now = opts.now ? parseIsoDate(opts.now, 'now') : undefined;
-        if (triggerRef) {
-          return workgraph.trigger.evaluateTrigger(workspacePath, triggerRef, {
-            actor: opts.actor,
-            now,
-          });
-        }
-        return workgraph.triggerEngine.runTriggerEngineCycle(workspacePath, {
-          actor: opts.actor,
-          now,
-        });
-      },
-      (result) => {
-        if ('cycle' in result) {
-          const triggerResult = result.trigger;
-          return [
-            `Evaluated trigger: ${result.triggerPath}`,
-            `Fired: ${String(triggerResult?.fired ?? false)}`,
-            `Reason: ${String(triggerResult?.reason ?? 'n/a')}`,
-            ...(triggerResult?.nextFireAt ? [`Next fire: ${triggerResult.nextFireAt}`] : []),
-          ];
-        }
-        return [
-          `Evaluated: ${result.evaluated} triggers`,
-          `Fired: ${result.fired}`,
-          `Errors: ${result.errors}`,
-          ...result.triggers.map((entry) =>
-            `  ${entry.triggerPath}: ${entry.fired ? 'FIRED' : 'skipped'} (${entry.reason})${entry.nextFireAt ? ` next=${entry.nextFireAt}` : ''}`),
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('history <triggerRef>')
-      .description('Show trigger ledger history')
-      .option('--limit <n>', 'Limit number of history entries')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerRef, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const entries = workgraph.trigger.triggerHistory(workspacePath, triggerRef);
-        const limit = parseOptionalInt(opts.limit, 'limit');
-        const limited = limit ? entries.slice(-limit) : entries;
-        return {
-          triggerRef,
-          entries: limited,
-          count: limited.length,
-        };
-      },
-      (result) => {
-        if (result.entries.length === 0) return [`No history for ${result.triggerRef}.`];
-        return [
-          ...result.entries.map((entry) => `${entry.ts} ${entry.op} ${entry.actor}`),
-          `${result.count} entr${result.count === 1 ? 'y' : 'ies'}`,
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    triggerCmd
-      .command('fire <triggerPath>')
-      .description('Fire an approved/active trigger and dispatch a run')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--event-key <key>', 'Deterministic event key for idempotency')
-      .option('--objective <text>', 'Override run objective')
-      .option('--adapter <name>', 'Adapter override for dispatched run')
-      .option('--execute', 'Execute the triggered run immediately')
-      .option('--retry-failed', 'Retry failed run when idempotency resolves to failed status')
-      .option('--agents <actors>', 'Comma-separated agent identities for execution')
-      .option('--max-steps <n>', 'Maximum scheduler steps for execution')
-      .option('--step-delay-ms <ms>', 'Delay between scheduling steps for execution')
-      .option('--space <spaceRef>', 'Restrict execution to one space')
-      .option('--timeout-ms <ms>', 'Execution timeout in milliseconds')
-      .option('--dispatch-mode <mode>', 'direct|self-assembly')
-      .option('--self-assembly-agent <agent>', 'Agent identity for self-assembly dispatch mode')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((triggerPath, opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        if (opts.execute) {
-          return workgraph.trigger.fireTriggerAndExecute(workspacePath, triggerPath, {
-            actor: opts.actor,
-            eventKey: opts.eventKey,
-            objective: opts.objective,
-            adapter: opts.adapter,
-            retryFailed: Boolean(opts.retryFailed),
-            executeInput: {
-              agents: opts.agents ? String(opts.agents).split(',').map((entry: string) => entry.trim()).filter(Boolean) : undefined,
-              maxSteps: opts.maxSteps ? Number.parseInt(String(opts.maxSteps), 10) : undefined,
-              stepDelayMs: opts.stepDelayMs ? Number.parseInt(String(opts.stepDelayMs), 10) : undefined,
-              space: opts.space,
-              timeoutMs: opts.timeoutMs ? Number.parseInt(String(opts.timeoutMs), 10) : undefined,
-              dispatchMode: opts.dispatchMode,
-              selfAssemblyAgent: opts.selfAssemblyAgent,
-            },
-          });
-        }
-        return workgraph.trigger.fireTrigger(workspacePath, triggerPath, {
-          actor: opts.actor,
-          eventKey: opts.eventKey,
-          objective: opts.objective,
-          adapter: opts.adapter,
-        });
-      },
-      (result) => [
-        ...(() => {
-          const executedResult = result as { executed?: boolean; retriedFromRunId?: string };
-          if (!executedResult.executed) return [];
-          return [`Executed: yes${executedResult.retriedFromRunId ? ` (retried from ${executedResult.retriedFromRunId})` : ''}`];
-        })(),
-        `Fired trigger: ${result.triggerPath}`,
-        `Run: ${result.run.id} [${result.run.status}]`,
-      ],
-    ),
-  );
-
-  const triggerEngineCmd = triggerCmd
-    .command('engine')
-    .description('Run trigger engine');
-
-  addWorkspaceOption(
-    triggerEngineCmd
-      .command('run')
-      .description('Process one trigger-engine cycle')
-      .option('-a, --actor <name>', 'Actor', defaultActor)
-      .option('--execute-runs', 'Execute dispatch-run actions as full run->evidence loop')
-      .option('--retry-failed-runs', 'Retry failed runs when dispatch-run hits failed idempotent runs')
-      .option('--agents <actors>', 'Comma-separated agent identities for execution')
-      .option('--max-steps <n>', 'Maximum scheduler steps for execution')
-      .option('--step-delay-ms <ms>', 'Delay between scheduling steps for execution')
-      .option('--space <spaceRef>', 'Restrict execution to one space')
-      .option('--timeout-ms <ms>', 'Execution timeout in milliseconds')
-      .option('--dispatch-mode <mode>', 'direct|self-assembly')
-      .option('--self-assembly-agent <agent>', 'Agent identity for self-assembly dispatch mode')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      async () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        if (opts.executeRuns) {
-          return workgraph.triggerEngine.runTriggerRunEvidenceLoop(workspacePath, {
-            actor: opts.actor,
-            retryFailedRuns: Boolean(opts.retryFailedRuns),
-            execution: {
-              agents: opts.agents ? String(opts.agents).split(',').map((entry: string) => entry.trim()).filter(Boolean) : undefined,
-              maxSteps: opts.maxSteps ? Number.parseInt(String(opts.maxSteps), 10) : undefined,
-              stepDelayMs: opts.stepDelayMs ? Number.parseInt(String(opts.stepDelayMs), 10) : undefined,
-              space: opts.space,
-              timeoutMs: opts.timeoutMs ? Number.parseInt(String(opts.timeoutMs), 10) : undefined,
-              dispatchMode: opts.dispatchMode,
-              selfAssemblyAgent: opts.selfAssemblyAgent,
-            },
-          });
-        }
-        return workgraph.triggerEngine.runTriggerEngineCycle(workspacePath, {
-          actor: opts.actor,
-        });
-      },
-      (result) => {
-        if ('cycle' in result) {
-          return [
-            `Evaluated: ${result.cycle.evaluated} triggers`,
-            `Fired: ${result.cycle.fired}`,
-            `Errors: ${result.cycle.errors}`,
-            `Executed runs: ${result.executedRuns.length} (succeeded=${result.succeeded}, failed=${result.failed}, cancelled=${result.cancelled}, skipped=${result.skipped})`,
-            ...result.cycle.triggers.map((t) =>
-              `  ${t.triggerPath}: ${t.fired ? 'FIRED' : 'skipped'} (${t.reason})${t.error ? ` error: ${t.error}` : ''}`,
-            ),
-            ...result.executedRuns.map((run) =>
-              `  run ${run.runId}: ${run.status}${run.retriedFromRunId ? ` (retried from ${run.retriedFromRunId})` : ''}${run.error ? ` error: ${run.error}` : ''}`,
-            ),
-          ];
-        }
-        return [
-          `Evaluated: ${result.evaluated} triggers`,
-          `Fired: ${result.fired}`,
-          `Errors: ${result.errors}`,
-          ...result.triggers.map((t) =>
-            `  ${t.triggerPath}: ${t.fired ? 'FIRED' : 'skipped'} (${t.reason})${t.error ? ` error: ${t.error}` : ''}`,
-          ),
-        ];
-      },
-    ),
-  );
-}
-
-function parseTriggerType(value: unknown): workgraph.trigger.TriggerPrimitiveType {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (normalized === 'cron' || normalized === 'webhook' || normalized === 'event' || normalized === 'manual') {
-    return normalized;
-  }
-  throw new Error(`Invalid trigger type "${String(value)}". Expected cron|webhook|event|manual.`);
-}
-
-function parseOptionalBoolean(value: unknown, label: string): boolean | undefined {
-  if (value === undefined) return undefined;
-  if (typeof value === 'boolean') return value;
-  const normalized = String(value).trim().toLowerCase();
-  if (normalized === 'true') return true;
-  if (normalized === 'false') return false;
-  throw new Error(`Invalid ${label} value "${String(value)}". Expected true|false.`);
-}
-
-function parseOptionalInt(value: unknown, label: string): number | undefined {
-  if (value === undefined) return undefined;
-  const parsed = Number.parseInt(String(value), 10);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Invalid ${label} value "${String(value)}". Expected an integer.`);
-  }
-  return parsed;
-}
-
-function parseUnknownOption(value: unknown): unknown {
-  if (value === undefined) return undefined;
-  const text = String(value).trim();
-  if (!text) return undefined;
-  if (text.startsWith('{') || text.startsWith('[') || text.startsWith('"')) {
-    return JSON.parse(text);
-  }
-  return text;
-}
-
-function parseJsonObjectOption(value: unknown, label: string): Record<string, unknown> | undefined {
-  if (value === undefined) return undefined;
-  const text = String(value).trim();
-  if (!text) return undefined;
-  const parsed = JSON.parse(text) as unknown;
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error(`Invalid ${label} value. Expected a JSON object.`);
-  }
-  return parsed as Record<string, unknown>;
-}
-
-function parseIsoDate(value: unknown, label: string): Date {
-  const text = String(value ?? '').trim();
-  const timestamp = Date.parse(text);
-  if (!text || Number.isNaN(timestamp)) {
-    throw new Error(`Invalid ${label} value "${String(value)}". Expected ISO-8601 date/time.`);
-  }
-  return new Date(timestamp);
-}
-
-function resolveActionInput(
-  opts: {
-    action?: string;
-    objective?: string;
-    adapter?: string;
-    context?: string;
-  },
-  allowUndefined: boolean = false,
-): unknown {
-  if (opts.action !== undefined) {
-    return parseUnknownOption(opts.action);
-  }
-  const context = parseJsonObjectOption(opts.context, 'context');
-  if (opts.objective === undefined && opts.adapter === undefined && context === undefined) {
-    return allowUndefined ? undefined : undefined;
-  }
-  const action: Record<string, unknown> = {
-    type: 'dispatch-run',
-  };
-  if (opts.objective !== undefined) action.objective = opts.objective;
-  if (opts.adapter !== undefined) action.adapter = opts.adapter;
-  if (context) action.context = context;
-  return {
-    ...action,
-  };
-}
diff --git a/packages/cli/src/cli/commands/webhook.ts b/packages/cli/src/cli/commands/webhook.ts
deleted file mode 100644
index 22bef5a..0000000
--- a/packages/cli/src/cli/commands/webhook.ts
+++ /dev/null
@@ -1,282 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Command } from 'commander';
-import * as workgraph from '@versatly/workgraph-kernel';
-import {
-  deleteWebhookGatewaySource,
-  listWebhookGatewayLogs,
-  listWebhookGatewaySources,
-  registerWebhookGatewaySource,
-  startWorkgraphServer,
-  testWebhookGatewaySource,
-  waitForShutdown,
-  type WebhookGatewayProvider,
-} from '@versatly/workgraph-control-api';
-import {
-  addWorkspaceOption,
-  parsePortOption,
-  resolveWorkspacePath,
-  runCommand,
-  wantsJson,
-} from '../core.js';
-
-export function registerWebhookCommands(program: Command, defaultActor: string): void {
-  const webhookCmd = program
-    .command('webhook')
-    .description('Universal webhook gateway management and operations');
-
-  addWorkspaceOption(
-    webhookCmd
-      .command('serve')
-      .description('Serve HTTP endpoints for inbound webhook sources')
-      .option('--port <port>', 'HTTP port (defaults to server config or 8787)')
-      .option('--host <host>', 'Bind host (defaults to server config or 0.0.0.0)')
-      .option('--token <token>', 'Optional bearer token for MCP + REST auth')
-      .option('-a, --actor <name>', 'Default actor for gateway-triggered mutations')
-      .option('--json', 'Emit structured JSON startup output'),
-  ).action(async (opts) => {
-    const workspacePath = resolveWorkspacePath(opts);
-    const serverConfig = workgraph.serverConfig.loadServerConfig(workspacePath);
-    const port = opts.port !== undefined
-      ? parsePortOption(opts.port)
-      : (serverConfig?.port ?? 8787);
-    const host = opts.host
-      ? String(opts.host)
-      : (serverConfig?.host ?? '0.0.0.0');
-    const actor = opts.actor
-      ? String(opts.actor)
-      : (serverConfig?.defaultActor ?? defaultActor);
-    const bearerToken = opts.token
-      ? String(opts.token)
-      : serverConfig?.bearerToken;
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host,
-      port,
-      bearerToken,
-      defaultActor: actor,
-      endpointPath: serverConfig?.endpointPath,
-    });
-
-    const startupPayload = {
-      serverUrl: handle.baseUrl,
-      healthUrl: handle.healthUrl,
-      mcpUrl: handle.url,
-      webhookGatewayUrlTemplate: handle.webhookGatewayUrlTemplate,
-    };
-    if (wantsJson(opts)) {
-      console.log(JSON.stringify({
-        ok: true,
-        data: startupPayload,
-      }, null, 2));
-    } else {
-      console.log(`Server URL: ${handle.baseUrl}`);
-      console.log(`Webhook endpoint template: ${handle.webhookGatewayUrlTemplate}`);
-      console.log(`Health: ${handle.healthUrl}`);
-      console.log(`MCP endpoint: ${handle.url}`);
-    }
-
-    await waitForShutdown(handle, {
-      onSignal: (signal) => {
-        if (!wantsJson(opts)) {
-          console.error(`Received ${signal}; shutting down webhook gateway...`);
-        }
-      },
-      onClosed: () => {
-        if (!wantsJson(opts)) {
-          console.error('Webhook gateway stopped.');
-        }
-      },
-    });
-  });
-
-  addWorkspaceOption(
-    webhookCmd
-      .command('register <key>')
-      .description('Register a webhook source endpoint')
-      .requiredOption('--provider <provider>', 'github|linear|slack|generic')
-      .option('--secret <secret>', 'HMAC secret for signature verification')
-      .option('-a, --actor <name>', 'Actor used for accepted webhook events', defaultActor)
-      .option('--event-prefix <prefix>', 'Event namespace suffix (default: provider)')
-      .option('--disabled', 'Register source as disabled')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((key, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return {
-          source: registerWebhookGatewaySource(workspacePath, {
-            key,
-            provider: parseWebhookProvider(opts.provider),
-            secret: opts.secret,
-            actor: opts.actor,
-            eventPrefix: opts.eventPrefix,
-            enabled: !opts.disabled,
-          }),
-        };
-      },
-      (result) => [
-        `Registered webhook source: ${result.source.key}`,
-        `Provider: ${result.source.provider}`,
-        `Enabled: ${result.source.enabled}`,
-        `Secret configured: ${result.source.hasSecret}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    webhookCmd
-      .command('list')
-      .description('List registered webhook sources')
-      .option('--provider <provider>', 'Filter by provider github|linear|slack|generic')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const provider = opts.provider ? parseWebhookProvider(opts.provider) : undefined;
-        const sources = listWebhookGatewaySources(workspacePath)
-          .filter((source) => (provider ? source.provider === provider : true));
-        return {
-          count: sources.length,
-          sources,
-        };
-      },
-      (result) => {
-        if (result.sources.length === 0) return ['No webhook sources found.'];
-        return [
-          ...result.sources.map((source) =>
-            `${source.key} provider=${source.provider} enabled=${source.enabled} secret=${source.hasSecret}`),
-          `${result.count} source(s)`,
-        ];
-      },
-    ),
-  );
-
-  addWorkspaceOption(
-    webhookCmd
-      .command('delete <keyOrId>')
-      .description('Delete a registered webhook source')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((keyOrId, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const deleted = deleteWebhookGatewaySource(workspacePath, keyOrId);
-        if (!deleted) {
-          throw new Error(`Webhook source not found: ${keyOrId}`);
-        }
-        return {
-          deleted: keyOrId,
-        };
-      },
-      (result) => [`Deleted webhook source: ${result.deleted}`],
-    ),
-  );
-
-  addWorkspaceOption(
-    webhookCmd
-      .command('test <sourceKey>')
-      .description('Emit a synthetic webhook event for one source')
-      .option('--event <eventType>', 'Event type (default: webhook.<provider>.test)')
-      .option('--payload <json>', 'Payload JSON string')
-      .option('--payload-file <path>', 'Payload JSON file path')
-      .option('--delivery-id <id>', 'Optional explicit delivery id')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((sourceKey, opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        return testWebhookGatewaySource(workspacePath, {
-          sourceKey,
-          eventType: opts.event,
-          payload: parseTestPayload(opts.payload, opts.payloadFile),
-          deliveryId: opts.deliveryId,
-        });
-      },
-      (result) => [
-        `Sent synthetic webhook: ${result.source.key}`,
-        `Event: ${result.eventType}`,
-        `Delivery: ${result.deliveryId}`,
-      ],
-    ),
-  );
-
-  addWorkspaceOption(
-    webhookCmd
-      .command('log')
-      .description('Read recent webhook gateway delivery logs')
-      .option('--source <key>', 'Filter by source key')
-      .option('--limit <n>', 'Limit entries (default: 50)', '50')
-      .option('--json', 'Emit structured JSON output'),
-  ).action((opts) =>
-    runCommand(
-      opts,
-      () => {
-        const workspacePath = resolveWorkspacePath(opts);
-        const limit = Number.parseInt(String(opts.limit), 10);
-        const safeLimit = Number.isFinite(limit) && limit > 0 ? limit : 50;
-        const logs = listWebhookGatewayLogs(workspacePath, {
-          limit: safeLimit,
-          sourceKey: opts.source,
-        });
-        return {
-          count: logs.length,
-          logs,
-        };
-      },
-      (result) => {
-        if (result.logs.length === 0) return ['No webhook logs found.'];
-        return [
-          ...result.logs.map((entry) =>
-            `${entry.ts} [${entry.status}] source=${entry.sourceKey} event=${entry.eventType} code=${entry.statusCode}`),
-          `${result.count} log entr${result.count === 1 ? 'y' : 'ies'}`,
-        ];
-      },
-    ),
-  );
-}
-
-function parseWebhookProvider(value: unknown): WebhookGatewayProvider {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (
-    normalized === 'github'
-    || normalized === 'linear'
-    || normalized === 'slack'
-    || normalized === 'generic'
-  ) {
-    return normalized;
-  }
-  throw new Error(`Invalid webhook provider "${String(value)}". Expected github|linear|slack|generic.`);
-}
-
-function parseTestPayload(rawPayload: unknown, payloadFile: unknown): unknown {
-  const payloadText = typeof rawPayload === 'string'
-    ? rawPayload.trim()
-    : '';
-  if (payloadText) {
-    return parseJsonPayload(payloadText, '--payload');
-  }
-  const payloadFilePath = typeof payloadFile === 'string'
-    ? payloadFile.trim()
-    : '';
-  if (payloadFilePath) {
-    const absolutePath = path.resolve(payloadFilePath);
-    const fileText = fs.readFileSync(absolutePath, 'utf-8');
-    return parseJsonPayload(fileText, '--payload-file');
-  }
-  return undefined;
-}
-
-function parseJsonPayload(text: string, option: string): unknown {
-  try {
-    return JSON.parse(text) as unknown;
-  } catch {
-    throw new Error(`Invalid ${option} JSON payload.`);
-  }
-}
diff --git a/packages/cli/src/cli/core.ts b/packages/cli/src/cli/core.ts
index 645b63d..4c623a4 100644
--- a/packages/cli/src/cli/core.ts
+++ b/packages/cli/src/cli/core.ts
@@ -4,12 +4,11 @@ import path from 'node:path';
 import { Command } from 'commander';
 import * as workgraph from '@versatly/workgraph-kernel';
 
-export type JsonCapableOptions = {
+type JsonCapableOptions = {
   json?: boolean;
   workspace?: string;
   vault?: string;
   sharedVault?: string;
-  apiUrl?: string;
   apiKey?: string;
   dryRun?: boolean;
   __dryRunWorkspace?: string;
@@ -22,7 +21,6 @@ export function addWorkspaceOption<T extends Command>(command: T): T {
     .option('-w, --workspace <path>', 'Workgraph workspace path')
     .option('--vault <path>', 'Alias for --workspace')
     .option('--shared-vault <path>', 'Shared vault path (e.g. mounted via Tailscale)')
-    .option('--api-url <url>', 'Workgraph MCP HTTP endpoint URL (or WORKGRAPH_API_URL env)')
     .option('--api-key <token>', 'Agent credential API key (or WORKGRAPH_API_KEY env)')
     .option('--dry-run', 'Execute against a temporary workspace copy and discard changes');
 }
@@ -49,7 +47,7 @@ export function resolveWorkspacePath(opts: JsonCapableOptions): string {
   return sandboxWorkspace;
 }
 
-export function resolveWorkspacePathBase(opts: JsonCapableOptions): string {
+function resolveWorkspacePathBase(opts: JsonCapableOptions): string {
   const explicit = opts.workspace || opts.vault || opts.sharedVault;
   if (explicit) return path.resolve(explicit);
   if (process.env.WORKGRAPH_SHARED_VAULT) return path.resolve(process.env.WORKGRAPH_SHARED_VAULT);
@@ -95,36 +93,6 @@ export function csv(value?: string): string[] | undefined {
   return String(value).split(',').map((s) => s.trim()).filter(Boolean);
 }
 
-type IntegrationInstallCliOptions = JsonCapableOptions & {
-  actor: string;
-  owner?: string;
-  title?: string;
-  sourceUrl?: string;
-  force?: boolean;
-};
-
-export function installNamedIntegration(
-  workspacePath: string,
-  integrationName: string,
-  opts: IntegrationInstallCliOptions,
-): Promise<workgraph.InstallSkillIntegrationResult> {
-  return workgraph.integration.installIntegration(workspacePath, integrationName, {
-    actor: opts.actor,
-    owner: opts.owner,
-    title: opts.title,
-    sourceUrl: opts.sourceUrl,
-    force: !!opts.force,
-  });
-}
-
-export function renderInstalledIntegrationResult(result: workgraph.InstallSkillIntegrationResult): string[] {
-  return [
-    `${result.replacedExisting ? 'Updated' : 'Installed'} ${result.provider} integration skill: ${result.skill.path}`,
-    `Source: ${result.sourceUrl}`,
-    `Status: ${String(result.skill.fields.status)}`,
-  ];
-}
-
 function parseScalar(value: string): unknown {
   if (value === 'true') return true;
   if (value === 'false') return false;
@@ -162,7 +130,7 @@ export function parsePortOption(value: unknown): number {
   return parsed;
 }
 
-export function parsePositiveNumberOption(value: unknown, optionName: string): number {
+function parsePositiveNumberOption(value: unknown, optionName: string): number {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error(`Invalid --${optionName}. Expected a positive number.`);
@@ -249,13 +217,7 @@ function cleanupDryRunSandbox(opts: JsonCapableOptions): void {
   delete opts.__dryRunOriginal;
 }
 
-export function resolveApiUrl(opts: JsonCapableOptions): string | undefined {
-  const fromOption = readNonEmptyString((opts as { apiUrl?: unknown }).apiUrl);
-  if (fromOption) return fromOption;
-  return readNonEmptyString(process.env.WORKGRAPH_API_URL);
-}
-
-export function resolveApiKey(opts: JsonCapableOptions): string | undefined {
+function resolveApiKey(opts: JsonCapableOptions): string | undefined {
   const fromOption = readNonEmptyString((opts as { apiKey?: unknown }).apiKey);
   if (fromOption) return fromOption;
   const fromEnv = readNonEmptyString(process.env.WORKGRAPH_AGENT_API_KEY)
diff --git a/packages/cli/src/remote-client.ts b/packages/cli/src/remote-client.ts
deleted file mode 100644
index 5546c9d..0000000
--- a/packages/cli/src/remote-client.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-
-export interface WorkgraphRemoteClientOptions {
-  apiUrl: string;
-  apiKey?: string;
-  name?: string;
-  version?: string;
-}
-
-interface McpTextContent {
-  type: string;
-  text?: string;
-}
-
-interface McpToolResultEnvelope {
-  isError?: boolean;
-  structuredContent?: unknown;
-  content?: McpTextContent[];
-}
-
-export class WorkgraphRemoteClient {
-  private readonly client: Client;
-
-  private closed = false;
-
-  private constructor(
-    client: Client,
-  ) {
-    this.client = client;
-  }
-
-  static async connect(options: WorkgraphRemoteClientOptions): Promise<WorkgraphRemoteClient> {
-    const headers: Record<string, string> = {};
-    const apiKey = readNonEmptyString(options.apiKey);
-    if (apiKey) {
-      headers.authorization = `Bearer ${apiKey}`;
-    }
-
-    const client = new Client({
-      name: options.name ?? 'workgraph-cli-remote',
-      version: options.version ?? '1.0.0',
-    });
-    const transport = new StreamableHTTPClientTransport(new URL(options.apiUrl), {
-      requestInit: {
-        headers,
-      },
-    });
-    await client.connect(transport);
-    return new WorkgraphRemoteClient(client);
-  }
-
-  async listTools(): Promise<Array<{ name: string; description?: string }>> {
-    const result = await this.client.listTools();
-    return result.tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-    }));
-  }
-
-  async callTool<T>(name: string, args: Record<string, unknown> = {}): Promise<T> {
-    const raw = await this.client.callTool({
-      name,
-      arguments: args,
-    }) as unknown;
-    return parseToolResult<T>(raw, name);
-  }
-
-  async close(): Promise<void> {
-    if (this.closed) return;
-    this.closed = true;
-    await this.client.close();
-  }
-}
-
-function parseToolResult<T>(raw: unknown, toolName: string): T {
-  const envelope = raw as McpToolResultEnvelope | undefined;
-  if (!envelope || typeof envelope !== 'object') {
-    throw new Error(`MCP tool "${toolName}" returned an invalid response.`);
-  }
-  if (envelope.isError) {
-    const text = extractText(envelope.content);
-    throw new Error(text || `MCP tool "${toolName}" returned an error.`);
-  }
-  if (envelope.structuredContent !== undefined) {
-    return envelope.structuredContent as T;
-  }
-  const text = extractText(envelope.content);
-  if (text) {
-    try {
-      return JSON.parse(text) as T;
-    } catch {
-      throw new Error(text);
-    }
-  }
-  throw new Error(`MCP tool "${toolName}" returned no structured content.`);
-}
-
-function extractText(content: McpTextContent[] | undefined): string | undefined {
-  if (!Array.isArray(content)) return undefined;
-  const textChunk = content.find((entry) => entry.type === 'text' && typeof entry.text === 'string');
-  return readNonEmptyString(textChunk?.text);
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
diff --git a/packages/control-api/package.json b/packages/control-api/package.json
deleted file mode 100644
index be2e4d0..0000000
--- a/packages/control-api/package.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "name": "@versatly/workgraph-control-api",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-kernel": "workspace:*",
-    "@versatly/workgraph-mcp-server": "workspace:*"
-  }
-}
diff --git a/packages/control-api/src/dispatch.ts b/packages/control-api/src/dispatch.ts
deleted file mode 100644
index 3928749..0000000
--- a/packages/control-api/src/dispatch.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { dispatch as dispatchModule } from '@versatly/workgraph-kernel';
-
-export const {
-  createRun,
-  claimThread,
-  status,
-  followup,
-  stop,
-  markRun,
-  heartbeat,
-  reconcileExpiredLeases,
-  reconcileExternalRun,
-  pollExternalRuns,
-  handoffRun,
-  logs,
-  listRuns,
-  executeRun,
-  createAndExecuteRun,
-} = dispatchModule;
-
-export type DispatchCreateInput = Parameters<typeof createRun>[1];
-export type DispatchClaimResult = ReturnType<typeof claimThread>;
-export type DispatchExecuteInput = Parameters<typeof executeRun>[2];
-export type DispatchHeartbeatInput = Parameters<typeof heartbeat>[2];
-export type DispatchReconcileResult = ReturnType<typeof reconcileExpiredLeases>;
-export type DispatchExternalReconcileInput = Parameters<typeof reconcileExternalRun>[1];
-export type DispatchHandoffInput = Parameters<typeof handoffRun>[2];
-export type DispatchHandoffResult = ReturnType<typeof handoffRun>;
diff --git a/packages/control-api/src/index.ts b/packages/control-api/src/index.ts
deleted file mode 100644
index e091fc1..0000000
--- a/packages/control-api/src/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './dispatch.js';
-export * from './server.js';
-export * from './server-projections.js';
-export * from './webhook-gateway.js';
diff --git a/packages/control-api/src/server-entry.ts b/packages/control-api/src/server-entry.ts
deleted file mode 100644
index 0bab198..0000000
--- a/packages/control-api/src/server-entry.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { runWorkgraphServerFromEnv } from './server.js';
-
-runWorkgraphServerFromEnv().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.log(JSON.stringify({
-    ts: new Date().toISOString(),
-    level: 'error',
-    event: 'server_start_failed',
-    error: message,
-  }));
-  process.exitCode = 1;
-});
diff --git a/packages/control-api/src/server-events.test.ts b/packages/control-api/src/server-events.test.ts
deleted file mode 100644
index eb079cc..0000000
--- a/packages/control-api/src/server-events.test.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  ledger as ledgerModule,
-  type LedgerEntry,
-} from '@versatly/workgraph-kernel';
-import {
-  createDashboardEventFilter,
-  listDashboardEventsSince,
-  mapLedgerEntryToDashboardEvents,
-  toSsePayload,
-} from './server-events.js';
-
-const ledger = ledgerModule;
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-server-events-'));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('server dashboard events', () => {
-  it('maps deterministic per-event ids and deterministic SSE envelope shape', () => {
-    const entry: LedgerEntry = {
-      ts: '2026-03-01T00:00:00.000Z',
-      actor: 'agent-a',
-      op: 'create',
-      target: 'threads/deterministic.md',
-      type: 'thread',
-      data: {
-        status: 'open',
-      },
-      hash: 'hash-deterministic',
-      prevHash: 'GENESIS',
-    };
-
-    const events = mapLedgerEntryToDashboardEvents(entry);
-    expect(events.map((event) => event.id)).toEqual([
-      'hash-deterministic#thread.created',
-      'hash-deterministic#primitive.changed',
-      'hash-deterministic#ledger.appended',
-    ]);
-
-    const payload = toSsePayload(events[0]);
-    const dataLine = payload.split('\n').find((line) => line.startsWith('data: '));
-    expect(dataLine).toBeDefined();
-    const envelope = JSON.parse(dataLine!.slice('data: '.length)) as Record<string, unknown>;
-    expect(Object.keys(envelope)).toEqual(['id', 'type', 'path', 'actor', 'fields', 'ts']);
-    expect(envelope.id).toBe(events[0].id);
-    expect(envelope.type).toBe('thread.created');
-  });
-
-  it('emits dedicated lifecycle events for conversation, plan-step, and run primitives', () => {
-    const conversationEvents = mapLedgerEntryToDashboardEvents({
-      ts: '2026-03-01T00:00:00.000Z',
-      actor: 'agent-a',
-      op: 'update',
-      target: 'conversations/sync.md',
-      type: 'conversation',
-      hash: 'hash-conversation',
-      prevHash: 'GENESIS',
-      data: {
-        changed: ['status'],
-      },
-    });
-    expect(conversationEvents.map((event) => event.type)).toEqual([
-      'conversation.updated',
-      'primitive.changed',
-      'ledger.appended',
-    ]);
-
-    const stepEvents = mapLedgerEntryToDashboardEvents({
-      ts: '2026-03-01T00:00:01.000Z',
-      actor: 'agent-b',
-      op: 'create',
-      target: 'plan-steps/ship-api.md',
-      type: 'plan-step',
-      hash: 'hash-plan-step',
-      prevHash: 'hash-conversation',
-      data: {
-        status: 'open',
-      },
-    });
-    expect(stepEvents.map((event) => event.type)).toEqual([
-      'plan-step.updated',
-      'primitive.changed',
-      'ledger.appended',
-    ]);
-
-    const runEvents = mapLedgerEntryToDashboardEvents({
-      ts: '2026-03-01T00:00:02.000Z',
-      actor: 'agent-c',
-      op: 'update',
-      target: '.workgraph/runs/run_123',
-      type: 'run',
-      hash: 'hash-run',
-      prevHash: 'hash-plan-step',
-      data: {
-        status: 'running',
-      },
-    });
-    expect(runEvents.map((event) => event.type)).toEqual([
-      'run.updated',
-      'primitive.changed',
-      'ledger.appended',
-    ]);
-  });
-
-  it('replays from the exact event id, not only the ledger entry id', () => {
-    ledger.append(workspacePath, 'seed', 'create', 'threads/replay.md', 'thread');
-    ledger.append(workspacePath, 'seed', 'claim', 'threads/replay.md', 'thread');
-
-    const allEvents = listDashboardEventsSince(workspacePath, undefined);
-    expect(allEvents.length).toBeGreaterThan(4);
-    const anchor = allEvents[1];
-
-    const replay = listDashboardEventsSince(workspacePath, anchor.id);
-    expect(replay.map((event) => event.id)).toEqual(
-      allEvents.slice(2).map((event) => event.id),
-    );
-
-    const unknownReplay = listDashboardEventsSince(workspacePath, 'unknown-id');
-    expect(unknownReplay.map((event) => event.id)).toEqual(
-      allEvents.map((event) => event.id),
-    );
-  });
-
-  it('filters by event type, primitive type, and thread path', () => {
-    ledger.append(workspacePath, 'seed', 'create', 'threads/alpha.md', 'thread');
-    ledger.append(workspacePath, 'seed', 'update', '.workgraph/runs/run_1', 'run', {
-      status: 'running',
-    });
-    ledger.append(workspacePath, 'seed', 'update', 'conversations/alpha.md', 'conversation', {
-      status: 'active',
-    });
-
-    const threadFilter = createDashboardEventFilter({
-      threads: ['alpha'],
-    });
-    const threadEvents = listDashboardEventsSince(workspacePath, undefined, threadFilter);
-    expect(threadEvents.length).toBeGreaterThan(0);
-    expect(threadEvents.every((event) => event.path === 'threads/alpha.md')).toBe(true);
-
-    const runFilter = createDashboardEventFilter({
-      primitiveTypes: ['run'],
-    });
-    const runEvents = listDashboardEventsSince(workspacePath, undefined, runFilter);
-    expect(runEvents.length).toBeGreaterThan(0);
-    expect(runEvents.some((event) => event.type === 'run.updated')).toBe(true);
-    expect(runEvents.every((event) => event.type === 'run.updated' || event.fields.type === 'run')).toBe(true);
-
-    const conversationEventTypeFilter = createDashboardEventFilter({
-      eventTypes: ['conversation.updated'],
-    });
-    const conversationLifecycleEvents = listDashboardEventsSince(
-      workspacePath,
-      undefined,
-      conversationEventTypeFilter,
-    );
-    expect(conversationLifecycleEvents.length).toBe(1);
-    expect(conversationLifecycleEvents[0].type).toBe('conversation.updated');
-  });
-});
diff --git a/packages/control-api/src/server-events.ts b/packages/control-api/src/server-events.ts
deleted file mode 100644
index 47e274c..0000000
--- a/packages/control-api/src/server-events.ts
+++ /dev/null
@@ -1,361 +0,0 @@
-import { ledger as ledgerModule, type LedgerEntry, type LedgerOp } from '@versatly/workgraph-kernel';
-
-const ledger = ledgerModule;
-const EVENT_ID_DELIMITER = '#';
-
-export type DashboardEventType =
-  | 'thread.created'
-  | 'thread.updated'
-  | 'thread.claimed'
-  | 'thread.done'
-  | 'thread.blocked'
-  | 'thread.released'
-  | 'conversation.updated'
-  | 'plan-step.updated'
-  | 'run.updated'
-  | 'ledger.appended'
-  | 'primitive.changed';
-
-export interface DashboardEvent {
-  id: string;
-  type: DashboardEventType;
-  path: string;
-  actor: string;
-  fields: Record<string, unknown>;
-  ts: string;
-}
-
-export interface DashboardEventFilter {
-  eventTypes?: ReadonlySet<string>;
-  primitiveTypes?: ReadonlySet<string>;
-  threadPaths?: ReadonlySet<string>;
-}
-
-export interface CreateDashboardEventFilterInput {
-  eventTypes?: Iterable<string>;
-  primitiveTypes?: Iterable<string>;
-  threads?: Iterable<string>;
-}
-
-/**
- * Deterministic event projection for dashboard consumers.
- *
- * Guarantees:
- * - Event order follows ledger append order + stable projection order per ledger entry.
- * - Event ids are deterministic and unique per projected event.
- * - Replays are idempotent via `id` and `Last-Event-ID`.
- */
-export function mapLedgerEntryToDashboardEvents(entry: LedgerEntry): DashboardEvent[] {
-  const entryId = readEntryId(entry);
-  const base = {
-    path: entry.target,
-    actor: entry.actor,
-    ts: entry.ts,
-  };
-
-  const projected: Array<Omit<DashboardEvent, 'id'>> = [];
-  const pushEvent = (type: DashboardEventType, fields: Record<string, unknown>) => {
-    projected.push({
-      ...base,
-      type,
-      fields,
-    });
-  };
-
-  if (entry.type === 'thread') {
-    const threadEventType = toThreadEventType(entry.op);
-    if (threadEventType) {
-      pushEvent(threadEventType, deriveEventFields(entry));
-    }
-  }
-
-  const primitiveLifecycleType = toPrimitiveLifecycleEventType(entry);
-  if (primitiveLifecycleType) {
-    pushEvent(primitiveLifecycleType, {
-      op: entry.op,
-      type: entry.type,
-      ...sanitizeData(entry.data),
-    });
-  }
-
-  if (shouldEmitPrimitiveChanged(entry)) {
-    pushEvent('primitive.changed', {
-      op: entry.op,
-      type: entry.type,
-      ...sanitizeData(entry.data),
-    });
-  };
-
-  pushEvent('ledger.appended', {
-    op: entry.op,
-    type: entry.type,
-    ...sanitizeData(entry.data),
-  });
-
-  const slotByType = new Map<string, number>();
-  return projected.map((event) => {
-    const slot = slotByType.get(event.type) ?? 0;
-    slotByType.set(event.type, slot + 1);
-    const slotName = slot === 0 ? event.type : `${event.type}.${slot + 1}`;
-    return {
-      id: composeEventId(entryId, slotName),
-      ...event,
-    };
-  });
-}
-
-export function listDashboardEventsSince(
-  workspacePath: string,
-  lastEventId: string | undefined,
-  filter?: DashboardEventFilter,
-): DashboardEvent[] {
-  const allEvents = ledger
-    .readAll(workspacePath)
-    .flatMap((entry) => mapLedgerEntryToDashboardEvents(entry));
-  const startIdx = resolveReplayStartIndex(allEvents, lastEventId);
-  const replay = allEvents.slice(startIdx);
-  if (!filter) return replay;
-  return replay.filter((event) => matchesDashboardEventFilter(event, filter));
-}
-
-export function subscribeToDashboardEvents(
-  workspacePath: string,
-  onEvent: (event: DashboardEvent) => void,
-  filter?: DashboardEventFilter,
-): () => void {
-  return ledger.subscribe(workspacePath, (entry) => {
-    const events = mapLedgerEntryToDashboardEvents(entry);
-    for (const event of events) {
-      if (!matchesDashboardEventFilter(event, filter)) continue;
-      onEvent(event);
-    }
-  });
-}
-
-export function toSsePayload(event: DashboardEvent): string {
-  const body = JSON.stringify({
-    id: event.id,
-    type: event.type,
-    path: event.path,
-    actor: event.actor,
-    fields: event.fields,
-    ts: event.ts,
-  });
-  return `id: ${event.id}\nevent: ${event.type}\ndata: ${body}\n\n`;
-}
-
-export function deriveEventFields(entry: LedgerEntry): Record<string, unknown> {
-  const fallback = sanitizeData(entry.data);
-  switch (entry.op) {
-    case 'claim':
-      return {
-        status: 'active',
-        owner: entry.actor,
-        ...fallback,
-      };
-    case 'release':
-    case 'reopen':
-      return {
-        status: 'open',
-        owner: null,
-        ...fallback,
-      };
-    case 'done':
-      return {
-        status: 'done',
-        ...fallback,
-      };
-    case 'block':
-      return {
-        status: 'blocked',
-        ...fallback,
-      };
-    case 'unblock':
-      return {
-        status: 'active',
-        ...fallback,
-      };
-    case 'cancel':
-      return {
-        status: 'cancelled',
-        owner: null,
-        ...fallback,
-      };
-    case 'delete':
-      return {
-        deleted: true,
-        ...fallback,
-      };
-    default:
-      return fallback;
-  }
-}
-
-function shouldEmitPrimitiveChanged(entry: LedgerEntry): boolean {
-  if (!entry.type) return false;
-  if (entry.target.startsWith('.workgraph/ledger')) return false;
-  return isPrimitiveMutationOp(entry.op);
-}
-
-export function createDashboardEventFilter(input: CreateDashboardEventFilterInput): DashboardEventFilter | undefined {
-  const eventTypes = normalizeStringSet(input.eventTypes);
-  const primitiveTypes = normalizeStringSet(input.primitiveTypes);
-  const threadPaths = normalizeThreadPathSet(input.threads);
-  if (!eventTypes && !primitiveTypes && !threadPaths) return undefined;
-  return {
-    ...(eventTypes ? { eventTypes } : {}),
-    ...(primitiveTypes ? { primitiveTypes } : {}),
-    ...(threadPaths ? { threadPaths } : {}),
-  };
-}
-
-export function matchesDashboardEventFilter(event: DashboardEvent, filter: DashboardEventFilter | undefined): boolean {
-  if (!filter) return true;
-  if (filter.eventTypes && !filter.eventTypes.has(event.type.toLowerCase())) {
-    return false;
-  }
-  if (filter.primitiveTypes) {
-    const primitiveType = inferPrimitiveType(event)?.toLowerCase();
-    if (!primitiveType || !filter.primitiveTypes.has(primitiveType)) {
-      return false;
-    }
-  }
-  if (filter.threadPaths) {
-    const eventThreadPath = normalizeThreadPath(event.path);
-    if (!eventThreadPath || !filter.threadPaths.has(eventThreadPath)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function isPrimitiveMutationOp(op: LedgerOp): boolean {
-  return op === 'create' ||
-    op === 'update' ||
-    op === 'delete' ||
-    op === 'claim' ||
-    op === 'release' ||
-    op === 'done' ||
-    op === 'block' ||
-    op === 'unblock' ||
-    op === 'reopen' ||
-    op === 'cancel' ||
-    op === 'heartbeat' ||
-    op === 'handoff' ||
-    op === 'decompose';
-}
-
-function toThreadEventType(op: LedgerOp): DashboardEventType | undefined {
-  if (op === 'create') return 'thread.created';
-  if (op === 'update') return 'thread.updated';
-  if (op === 'claim') return 'thread.claimed';
-  if (op === 'done') return 'thread.done';
-  if (op === 'block') return 'thread.blocked';
-  if (op === 'release' || op === 'reopen') return 'thread.released';
-  if (op === 'unblock' || op === 'cancel' || op === 'heartbeat' || op === 'handoff' || op === 'decompose') {
-    return 'thread.updated';
-  }
-  return undefined;
-}
-
-function toPrimitiveLifecycleEventType(entry: LedgerEntry): DashboardEventType | undefined {
-  if (!entry.type || !isPrimitiveMutationOp(entry.op)) return undefined;
-  if (entry.type === 'conversation') return 'conversation.updated';
-  if (entry.type === 'plan-step') return 'plan-step.updated';
-  if (entry.type === 'run') return 'run.updated';
-  return undefined;
-}
-
-function readEntryId(entry: LedgerEntry): string {
-  if (entry.hash) return entry.hash;
-  return `${entry.ts}:${entry.actor}:${entry.op}:${entry.target}`;
-}
-
-function composeEventId(entryId: string, slotName: string): string {
-  return `${entryId}${EVENT_ID_DELIMITER}${slotName}`;
-}
-
-function resolveReplayStartIndex(events: DashboardEvent[], lastEventId: string | undefined): number {
-  if (!lastEventId) return 0;
-  const normalized = lastEventId.trim();
-  if (!normalized) return 0;
-  const idx = events.findIndex((event) => event.id === normalized);
-  if (idx < 0) return 0;
-  return idx + 1;
-}
-
-function sanitizeData(data: Record<string, unknown> | undefined): Record<string, unknown> {
-  if (!data) return {};
-  return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== undefined));
-}
-
-function inferPrimitiveType(event: DashboardEvent): string | undefined {
-  if (event.type.startsWith('thread.')) return 'thread';
-  const fromFields = readNonEmptyString(event.fields.type);
-  if (fromFields) return fromFields;
-  const fromPath = primitiveTypeFromPath(event.path);
-  if (fromPath) return fromPath;
-  return undefined;
-}
-
-function primitiveTypeFromPath(rawPath: string): string | undefined {
-  const normalized = String(rawPath).replace(/\\/g, '/').replace(/^\.\//, '');
-  if (!normalized) return undefined;
-  if (normalized.startsWith('.workgraph/runs/')) return 'run';
-  if (normalized.startsWith('.workgraph/')) return undefined;
-  const directory = normalized.split('/')[0];
-  if (directory === 'threads') return 'thread';
-  if (directory === 'conversations') return 'conversation';
-  if (directory === 'plan-steps') return 'plan-step';
-  return undefined;
-}
-
-function normalizeStringSet(values: Iterable<string> | undefined): ReadonlySet<string> | undefined {
-  if (!values) return undefined;
-  const set = new Set<string>();
-  for (const raw of values) {
-    const value = String(raw).trim().toLowerCase();
-    if (!value) continue;
-    set.add(value);
-  }
-  return set.size > 0 ? set : undefined;
-}
-
-function normalizeThreadPathSet(values: Iterable<string> | undefined): ReadonlySet<string> | undefined {
-  if (!values) return undefined;
-  const set = new Set<string>();
-  for (const raw of values) {
-    const normalized = normalizeThreadPath(raw);
-    if (!normalized) continue;
-    set.add(normalized);
-  }
-  return set.size > 0 ? set : undefined;
-}
-
-function normalizeThreadPath(rawPath: string): string | undefined {
-  const raw = String(rawPath).trim();
-  if (!raw) return undefined;
-  const decoded = safeDecodeURIComponent(raw);
-  const trimmed = decoded.replace(/\\/g, '/').replace(/^\.\//, '');
-  if (!trimmed) return undefined;
-  const withDirectory = trimmed.startsWith('threads/')
-    ? trimmed
-    : `threads/${trimmed}`;
-  return withDirectory.endsWith('.md')
-    ? withDirectory
-    : `${withDirectory}.md`;
-}
-
-function safeDecodeURIComponent(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
diff --git a/packages/control-api/src/server-lenses.ts b/packages/control-api/src/server-lenses.ts
deleted file mode 100644
index 55e465b..0000000
--- a/packages/control-api/src/server-lenses.ts
+++ /dev/null
@@ -1,421 +0,0 @@
-import {
-  ledger as ledgerModule,
-  store as storeModule,
-  type LedgerEntry,
-  type PrimitiveInstance,
-} from '@versatly/workgraph-kernel';
-import { deriveEventFields } from './server-events.js';
-
-const ledger = ledgerModule;
-const store = storeModule;
-
-const STALE_THREAD_MS = 24 * 60 * 60 * 1_000;
-const AGENT_ONLINE_WINDOW_MS = 30 * 60 * 1_000;
-
-export interface LensOptions {
-  space?: string;
-}
-
-export interface AttentionLensResult {
-  threads: AttentionLensThread[];
-  summary: {
-    blocked: number;
-    stale: number;
-    urgent_unclaimed: number;
-  };
-}
-
-export interface AttentionLensThread {
-  path: string;
-  title: string;
-  status: string;
-  priority: string;
-  owner?: string;
-  space?: string;
-  updated?: string;
-  reason: 'blocked' | 'urgent_unclaimed' | 'stale' | 'unresolved_dependencies';
-  unresolvedDeps?: string[];
-}
-
-export interface AgentsLensResult {
-  agents: AgentLensSummary[];
-}
-
-export interface AgentLensSummary {
-  name: string;
-  lastSeen: string;
-  actionCount: number;
-  claimedThreads: string[];
-  online: boolean;
-}
-
-export interface SpacesLensResult {
-  spaces: SpaceLensSummary[];
-}
-
-export interface SpaceLensSummary {
-  name: string;
-  total: number;
-  open: number;
-  active: number;
-  blocked: number;
-  done: number;
-  progress: number;
-}
-
-export interface TimelineLensResult {
-  events: TimelineLensEvent[];
-}
-
-export interface TimelineLensEvent {
-  timestamp: string;
-  actor: string;
-  operation: string;
-  path: string;
-  threadTitle?: string;
-  changedFields: Record<string, unknown>;
-}
-
-export function buildAttentionLens(workspacePath: string, options: LensOptions = {}): AttentionLensResult {
-  const normalizedSpace = normalizeSpaceRef(options.space);
-  const nowMs = Date.now();
-  const claims = ledger.allClaims(workspacePath);
-  const allThreads = listThreads(workspacePath, normalizedSpace);
-  const threadByPath = new Map(allThreads.map((thread) => [thread.path, thread]));
-
-  const blocked = allThreads
-    .filter((thread) => threadStatus(thread) === 'blocked')
-    .sort(comparePriorityThenUpdatedAsc);
-  const urgentUnclaimed = allThreads
-    .filter((thread) =>
-      threadStatus(thread) === 'open' &&
-      normalizePriority(thread.fields.priority) === 'urgent' &&
-      !claims.has(thread.path))
-    .sort(comparePriorityThenUpdatedAsc);
-  const stale = allThreads
-    .filter((thread) =>
-      threadStatus(thread) === 'active' &&
-      isStaleThread(thread, nowMs))
-    .sort(comparePriorityThenUpdatedAsc);
-  const unresolvedDeps = allThreads
-    .map((thread) => ({ thread, unresolved: unresolvedDependencies(thread, threadByPath) }))
-    .filter((entry) =>
-      entry.unresolved.length > 0 &&
-      threadStatus(entry.thread) !== 'done' &&
-      threadStatus(entry.thread) !== 'cancelled')
-    .sort((a, b) => comparePriorityThenUpdatedAsc(a.thread, b.thread));
-
-  const prioritized = new Map<string, AttentionLensThread>();
-  for (const thread of blocked) {
-    prioritized.set(thread.path, toAttentionThread(thread, 'blocked'));
-  }
-  for (const thread of urgentUnclaimed) {
-    if (!prioritized.has(thread.path)) {
-      prioritized.set(thread.path, toAttentionThread(thread, 'urgent_unclaimed'));
-    }
-  }
-  for (const thread of stale) {
-    if (!prioritized.has(thread.path)) {
-      prioritized.set(thread.path, toAttentionThread(thread, 'stale'));
-    }
-  }
-  for (const entry of unresolvedDeps) {
-    if (!prioritized.has(entry.thread.path)) {
-      prioritized.set(
-        entry.thread.path,
-        toAttentionThread(entry.thread, 'unresolved_dependencies', entry.unresolved),
-      );
-    }
-  }
-
-  return {
-    threads: [...prioritized.values()],
-    summary: {
-      blocked: blocked.length,
-      stale: stale.length,
-      urgent_unclaimed: urgentUnclaimed.length,
-    },
-  };
-}
-
-export function buildAgentsLens(workspacePath: string, options: LensOptions = {}): AgentsLensResult {
-  const normalizedSpace = normalizeSpaceRef(options.space);
-  const threadByPath = buildThreadPathIndex(workspacePath);
-  const allEntries = ledger.readAll(workspacePath);
-  const entries = filterLedgerBySpace(allEntries, normalizedSpace, threadByPath);
-  const claims = [...ledger.allClaims(workspacePath).entries()]
-    .filter(([threadPath]) => threadInSpace(threadByPath.get(threadPath), normalizedSpace));
-
-  const byAgent = new Map<string, AgentLensSummary>();
-  for (const entry of entries) {
-    const current = byAgent.get(entry.actor) ?? {
-      name: entry.actor,
-      lastSeen: entry.ts,
-      actionCount: 0,
-      claimedThreads: [],
-      online: false,
-    };
-    current.actionCount += 1;
-    if (entry.ts > current.lastSeen) current.lastSeen = entry.ts;
-    byAgent.set(entry.actor, current);
-  }
-
-  for (const [threadPath, owner] of claims) {
-    const current = byAgent.get(owner) ?? {
-      name: owner,
-      lastSeen: '',
-      actionCount: 0,
-      claimedThreads: [],
-      online: false,
-    };
-    if (!current.claimedThreads.includes(threadPath)) {
-      current.claimedThreads.push(threadPath);
-    }
-    byAgent.set(owner, current);
-  }
-
-  const nowMs = Date.now();
-  const agents = [...byAgent.values()]
-    .map((agent) => ({
-      ...agent,
-      claimedThreads: [...agent.claimedThreads].sort((a, b) => a.localeCompare(b)),
-      online: isOnline(agent.lastSeen, nowMs),
-    }))
-    .sort((a, b) => {
-      if (a.online !== b.online) return a.online ? -1 : 1;
-      return b.lastSeen.localeCompare(a.lastSeen) || b.actionCount - a.actionCount || a.name.localeCompare(b.name);
-    });
-
-  return { agents };
-}
-
-export function buildSpacesLens(workspacePath: string, options: LensOptions = {}): SpacesLensResult {
-  const normalizedSpace = normalizeSpaceRef(options.space);
-  const allThreads = listThreads(workspacePath, normalizedSpace);
-  const bySpace = new Map<string, SpaceLensSummary>();
-
-  for (const thread of allThreads) {
-    const spaceName = normalizeSpaceRef(thread.fields.space) ?? 'unassigned';
-    const current = bySpace.get(spaceName) ?? {
-      name: spaceName,
-      total: 0,
-      open: 0,
-      active: 0,
-      blocked: 0,
-      done: 0,
-      progress: 0,
-    };
-    current.total += 1;
-    const status = threadStatus(thread);
-    if (status === 'open') current.open += 1;
-    if (status === 'active') current.active += 1;
-    if (status === 'blocked') current.blocked += 1;
-    if (status === 'done') current.done += 1;
-    bySpace.set(spaceName, current);
-  }
-
-  const spaces = [...bySpace.values()]
-    .map((space) => ({
-      ...space,
-      progress: space.total === 0 ? 0 : roundToTwo((space.done / space.total) * 100),
-    }))
-    .sort((a, b) => a.name.localeCompare(b.name));
-
-  return { spaces };
-}
-
-export function buildTimelineLens(workspacePath: string, options: LensOptions = {}): TimelineLensResult {
-  const normalizedSpace = normalizeSpaceRef(options.space);
-  const threadByPath = buildThreadPathIndex(workspacePath);
-  const allEntries = ledger.readAll(workspacePath);
-  const entries = filterLedgerBySpace(allEntries, normalizedSpace, threadByPath)
-    .slice(-50)
-    .reverse();
-
-  return {
-    events: entries.map((entry) => {
-      const threadTitle = resolveThreadTitle(entry, threadByPath);
-      return {
-        timestamp: entry.ts,
-        actor: entry.actor,
-        operation: entry.op,
-        path: entry.target,
-        ...(threadTitle ? { threadTitle } : {}),
-        changedFields: deriveEventFields(entry),
-      };
-    }),
-  };
-}
-
-function listThreads(workspacePath: string, space: string | undefined): PrimitiveInstance[] {
-  const allThreads = store.list(workspacePath, 'thread');
-  return allThreads.filter((thread) => threadInSpace(thread, space));
-}
-
-function buildThreadPathIndex(workspacePath: string): Map<string, PrimitiveInstance> {
-  const threads = store.list(workspacePath, 'thread');
-  return new Map(threads.map((thread) => [thread.path, thread]));
-}
-
-function filterLedgerBySpace(
-  entries: LedgerEntry[],
-  space: string | undefined,
-  threadByPath: Map<string, PrimitiveInstance>,
-): LedgerEntry[] {
-  if (!space) return entries;
-  return entries.filter((entry) => {
-    const targetThread = resolveThreadForLedgerEntry(entry, threadByPath);
-    return threadInSpace(targetThread, space);
-  });
-}
-
-function resolveThreadForLedgerEntry(
-  entry: LedgerEntry,
-  threadByPath: Map<string, PrimitiveInstance>,
-): PrimitiveInstance | undefined {
-  if (entry.type === 'thread' || looksLikeThreadPath(entry.target)) {
-    return threadByPath.get(normalizeThreadPath(entry.target));
-  }
-  return undefined;
-}
-
-function resolveThreadTitle(
-  entry: LedgerEntry,
-  threadByPath: Map<string, PrimitiveInstance>,
-): string | undefined {
-  const thread = resolveThreadForLedgerEntry(entry, threadByPath);
-  if (!thread) return undefined;
-  const title = String(thread.fields.title ?? '').trim();
-  return title || thread.path;
-}
-
-function unresolvedDependencies(
-  thread: PrimitiveInstance,
-  threadByPath: Map<string, PrimitiveInstance>,
-): string[] {
-  const deps = Array.isArray(thread.fields.deps) ? thread.fields.deps : [];
-  const unresolved: string[] = [];
-  for (const dep of deps) {
-    const normalized = normalizeThreadPath(dep);
-    if (!normalized) continue;
-    if (normalized.startsWith('external/')) {
-      unresolved.push(normalized);
-      continue;
-    }
-    const dependencyThread = threadByPath.get(normalized);
-    if (!dependencyThread || threadStatus(dependencyThread) !== 'done') {
-      unresolved.push(normalized);
-    }
-  }
-  return unresolved;
-}
-
-function toAttentionThread(
-  thread: PrimitiveInstance,
-  reason: AttentionLensThread['reason'],
-  unresolved: string[] = [],
-): AttentionLensThread {
-  const owner = readOptionalString(thread.fields.owner);
-  const space = normalizeSpaceRef(thread.fields.space);
-  const updated = readOptionalString(thread.fields.updated);
-  return {
-    path: thread.path,
-    title: String(thread.fields.title ?? thread.path),
-    status: threadStatus(thread),
-    priority: normalizePriority(thread.fields.priority),
-    ...(owner ? { owner } : {}),
-    ...(space ? { space } : {}),
-    ...(updated ? { updated } : {}),
-    reason,
-    ...(unresolved.length > 0 ? { unresolvedDeps: unresolved } : {}),
-  };
-}
-
-function isStaleThread(thread: PrimitiveInstance, nowMs: number): boolean {
-  const updatedTs = parseTimestampMs(thread.fields.updated ?? thread.fields.created);
-  if (!Number.isFinite(updatedTs)) return false;
-  return nowMs - updatedTs > STALE_THREAD_MS;
-}
-
-function isOnline(lastSeen: string, nowMs: number): boolean {
-  const ts = parseTimestampMs(lastSeen);
-  if (!Number.isFinite(ts)) return false;
-  return nowMs - ts <= AGENT_ONLINE_WINDOW_MS;
-}
-
-function comparePriorityThenUpdatedAsc(a: PrimitiveInstance, b: PrimitiveInstance): number {
-  const priorityDelta = priorityRank(a.fields.priority) - priorityRank(b.fields.priority);
-  if (priorityDelta !== 0) return priorityDelta;
-  const updatedA = parseTimestampMs(a.fields.updated ?? a.fields.created);
-  const updatedB = parseTimestampMs(b.fields.updated ?? b.fields.created);
-  const safeA = Number.isFinite(updatedA) ? updatedA : Number.MAX_SAFE_INTEGER;
-  const safeB = Number.isFinite(updatedB) ? updatedB : Number.MAX_SAFE_INTEGER;
-  return safeA - safeB;
-}
-
-function priorityRank(value: unknown): number {
-  const normalized = normalizePriority(value);
-  if (normalized === 'urgent') return 0;
-  if (normalized === 'high') return 1;
-  if (normalized === 'medium') return 2;
-  if (normalized === 'low') return 3;
-  return 4;
-}
-
-function threadStatus(thread: PrimitiveInstance): string {
-  return String(thread.fields.status ?? '');
-}
-
-function normalizePriority(value: unknown): string {
-  return String(value ?? 'medium').trim().toLowerCase();
-}
-
-function normalizeSpaceRef(value: unknown): string | undefined {
-  const raw = readOptionalString(value);
-  if (!raw) return undefined;
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]')
-    ? raw.slice(2, -2)
-    : raw;
-  return unwrapped.endsWith('.md') ? unwrapped : `${unwrapped}.md`;
-}
-
-function threadInSpace(thread: PrimitiveInstance | undefined, space: string | undefined): boolean {
-  if (!space) return true;
-  if (!thread) return false;
-  return normalizeSpaceRef(thread.fields.space) === space;
-}
-
-function looksLikeThreadPath(value: string): boolean {
-  return value.replace(/\\/g, '/').startsWith('threads/');
-}
-
-function normalizeThreadPath(value: unknown): string {
-  const raw = String(value ?? '').trim();
-  if (!raw) return '';
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]')
-    ? raw.slice(2, -2)
-    : raw;
-  const primary = unwrapped.split('|')[0].trim().split('#')[0].trim();
-  if (!primary) return '';
-  if (primary.startsWith('external/')) return primary;
-  const withPathPrefix = primary.startsWith('threads/')
-    ? primary
-    : `threads/${primary}`;
-  return withPathPrefix.endsWith('.md') ? withPathPrefix : `${withPathPrefix}.md`;
-}
-
-function parseTimestampMs(value: unknown): number {
-  const parsed = Date.parse(String(value ?? ''));
-  if (!Number.isFinite(parsed)) return Number.NaN;
-  return parsed;
-}
-
-function roundToTwo(value: number): number {
-  return Math.round(value * 100) / 100;
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
diff --git a/packages/control-api/src/server-projections.test.ts b/packages/control-api/src/server-projections.test.ts
deleted file mode 100644
index 9b9f246..0000000
--- a/packages/control-api/src/server-projections.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { projections as projectionsModule, registry as registryModule, thread as threadModule } from '@versatly/workgraph-kernel';
-import { startWorkgraphServer } from './server.js';
-
-const projections = projectionsModule;
-const registry = registryModule;
-const thread = threadModule;
-
-let workspacePath: string;
-
-describe('server projection routes', () => {
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-server-projections-'));
-    registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
-    thread.createThread(workspacePath, 'Projection thread', 'projection thread goal', 'agent-projection');
-  });
-
-  afterEach(() => {
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-  });
-
-  it('serves named projection endpoints over HTTP', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const runHealth = await fetch(`${handle.baseUrl}/api/projections/run-health`);
-      const runHealthBody = await runHealth.json() as { ok: boolean; projection: ReturnType<typeof projections.buildRunHealthProjection> };
-      expect(runHealth.status).toBe(200);
-      expect(runHealthBody.ok).toBe(true);
-      expect(runHealthBody.projection.scope).toBe('run');
-
-      const overview = await fetch(`${handle.baseUrl}/api/projections/overview`);
-      const overviewBody = await overview.json() as { ok: boolean; projection: { projections: Record<string, unknown> } };
-      expect(overview.status).toBe(200);
-      expect(overviewBody.ok).toBe(true);
-      expect(Object.keys(overviewBody.projection.projections)).toEqual(expect.arrayContaining([
-        'runHealth',
-        'riskDashboard',
-        'missionProgress',
-        'transportHealth',
-        'federationStatus',
-        'triggerHealth',
-        'autonomyHealth',
-      ]));
-
-      const controlPlaneIndex = await fetch(`${handle.baseUrl}/control-plane`);
-      expect(controlPlaneIndex.status).toBe(200);
-      expect(await controlPlaneIndex.text()).toContain('WorkGraph Operator Control Plane');
-
-      const runHealthPage = await fetch(`${handle.baseUrl}/control-plane/run-health`);
-      expect(runHealthPage.status).toBe(200);
-      expect(await runHealthPage.text()).toContain('data-projection="run-health"');
-    } finally {
-      await handle.close();
-    }
-  });
-});
diff --git a/packages/control-api/src/server-projections.ts b/packages/control-api/src/server-projections.ts
deleted file mode 100644
index fa3984c..0000000
--- a/packages/control-api/src/server-projections.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import {
-  projections as projectionsModule,
-} from '@versatly/workgraph-kernel';
-
-const projections = projectionsModule;
-
-export type ProjectionRouteName =
-  | 'overview'
-  | 'run-health'
-  | 'risk-dashboard'
-  | 'mission-progress'
-  | 'transport-health'
-  | 'federation-status'
-  | 'trigger-health'
-  | 'autonomy-health';
-
-export function buildProjectionByName(workspacePath: string, name: ProjectionRouteName) {
-  switch (name) {
-    case 'overview':
-      return buildProjectionOverview(workspacePath);
-    case 'run-health':
-      return projections.buildRunHealthProjection(workspacePath);
-    case 'risk-dashboard':
-      return projections.buildRiskDashboardProjection(workspacePath);
-    case 'mission-progress':
-      return projections.buildMissionProgressProjection(workspacePath);
-    case 'transport-health':
-      return projections.buildTransportHealthProjection(workspacePath);
-    case 'federation-status':
-      return projections.buildFederationStatusProjection(workspacePath);
-    case 'trigger-health':
-      return projections.buildTriggerHealthProjection(workspacePath);
-    case 'autonomy-health':
-      return projections.buildAutonomyHealthProjection(workspacePath);
-    default:
-      return assertNever(name);
-  }
-}
-
-export function listProjectionRouteNames(): ProjectionRouteName[] {
-  return [
-    'overview',
-    'run-health',
-    'risk-dashboard',
-    'mission-progress',
-    'transport-health',
-    'federation-status',
-    'trigger-health',
-    'autonomy-health',
-  ];
-}
-
-export function buildProjectionOverview(workspacePath: string) {
-  return {
-    generatedAt: new Date().toISOString(),
-    projections: {
-      runHealth: projections.buildRunHealthProjection(workspacePath),
-      riskDashboard: projections.buildRiskDashboardProjection(workspacePath),
-      missionProgress: projections.buildMissionProgressProjection(workspacePath),
-      transportHealth: projections.buildTransportHealthProjection(workspacePath),
-      federationStatus: projections.buildFederationStatusProjection(workspacePath),
-      triggerHealth: projections.buildTriggerHealthProjection(workspacePath),
-      autonomyHealth: projections.buildAutonomyHealthProjection(workspacePath),
-    },
-  };
-}
-
-function assertNever(value: never): never {
-  throw new Error(`Unhandled projection route "${String(value)}".`);
-}
diff --git a/packages/control-api/src/server-webhooks.test.ts b/packages/control-api/src/server-webhooks.test.ts
deleted file mode 100644
index 0d2cf06..0000000
--- a/packages/control-api/src/server-webhooks.test.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  transport as transportModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-import { dispatchWebhookEvent, registerWebhook } from './server-webhooks.js';
-import type { DashboardEvent } from './server-events.js';
-
-const transport = transportModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-
-function makeEvent(): DashboardEvent {
-  return {
-    id: 'evt_dashboard_1',
-    type: 'thread.done',
-    path: 'threads/example.md',
-    actor: 'agent-a',
-    fields: {
-      status: 'done',
-    },
-    ts: '2026-03-11T10:00:00.000Z',
-  };
-}
-
-function mockResponse(options: { ok: boolean; status: number; text?: string; statusText?: string }): Response {
-  return {
-    ok: options.ok,
-    status: options.status,
-    statusText: options.statusText ?? '',
-    text: async () => options.text ?? '',
-  } as Response;
-}
-
-describe('server webhook transport integration', () => {
-  const fetchMock = vi.fn();
-
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-server-webhooks-'));
-    workspace.initWorkspace(workspacePath, {
-      createReadme: false,
-      createBases: false,
-    });
-    vi.restoreAllMocks();
-    fetchMock.mockReset();
-    vi.stubGlobal('fetch', fetchMock);
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-  });
-
-  it('writes outbox records for successful webhook deliveries', async () => {
-    registerWebhook(workspacePath, {
-      url: 'https://hooks.example/success',
-      events: ['thread.*'],
-    });
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 202,
-    }));
-
-    await dispatchWebhookEvent(workspacePath, makeEvent());
-
-    const outbox = transport.listTransportOutbox(workspacePath);
-    expect(outbox).toHaveLength(1);
-    expect(outbox[0].status).toBe('delivered');
-    expect(outbox[0].deliveryHandler).toBe('dashboard-webhook');
-  });
-
-  it('writes dead-letter records when webhook delivery fails', async () => {
-    registerWebhook(workspacePath, {
-      url: 'https://hooks.example/failure',
-      events: ['thread.*'],
-    });
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: false,
-      status: 500,
-      statusText: 'Server Error',
-    }));
-
-    await dispatchWebhookEvent(workspacePath, makeEvent());
-
-    const outbox = transport.listTransportOutbox(workspacePath);
-    expect(outbox).toHaveLength(1);
-    expect(outbox[0].status).toBe('failed');
-
-    const deadLetters = transport.listTransportDeadLetters(workspacePath);
-    expect(deadLetters).toHaveLength(1);
-    expect(deadLetters[0].sourceRecordId).toBe(outbox[0].id);
-  });
-});
diff --git a/packages/control-api/src/server-webhooks.ts b/packages/control-api/src/server-webhooks.ts
deleted file mode 100644
index 7cf0d2d..0000000
--- a/packages/control-api/src/server-webhooks.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-import crypto, { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import {
-  transport as transportModule,
-} from '@versatly/workgraph-kernel';
-import type { DashboardEvent } from './server-events.js';
-
-const WEBHOOKS_PATH = '.workgraph/webhooks.json';
-const WEBHOOKS_VERSION = 1;
-const transport = transportModule;
-
-interface WebhookStoreFile {
-  version: number;
-  webhooks: StoredWebhook[];
-}
-
-interface StoredWebhook {
-  id: string;
-  url: string;
-  events: string[];
-  secret?: string;
-  createdAt: string;
-}
-
-export interface WebhookView {
-  id: string;
-  url: string;
-  events: string[];
-  createdAt: string;
-  hasSecret: boolean;
-}
-
-export interface RegisterWebhookInput {
-  url: string;
-  events: string[];
-  secret?: string;
-}
-
-export function listWebhooks(workspacePath: string): WebhookView[] {
-  const store = readWebhookStore(workspacePath);
-  return store.webhooks.map(toWebhookView);
-}
-
-export function registerWebhook(workspacePath: string, input: RegisterWebhookInput): WebhookView {
-  const url = normalizeWebhookUrl(input.url);
-  const events = normalizeEventPatterns(input.events);
-  const secret = readOptionalString(input.secret);
-
-  const store = readWebhookStore(workspacePath);
-  const record: StoredWebhook = {
-    id: randomUUID(),
-    url,
-    events,
-    createdAt: new Date().toISOString(),
-    ...(secret ? { secret } : {}),
-  };
-  store.webhooks.push(record);
-  writeWebhookStore(workspacePath, store);
-  return toWebhookView(record);
-}
-
-export function deleteWebhook(workspacePath: string, id: string): boolean {
-  const normalizedId = String(id ?? '').trim();
-  if (!normalizedId) return false;
-  const store = readWebhookStore(workspacePath);
-  const before = store.webhooks.length;
-  store.webhooks = store.webhooks.filter((item) => item.id !== normalizedId);
-  if (store.webhooks.length === before) return false;
-  writeWebhookStore(workspacePath, store);
-  return true;
-}
-
-export async function dispatchWebhookEvent(workspacePath: string, event: DashboardEvent): Promise<void> {
-  const store = readWebhookStore(workspacePath);
-  const matching = store.webhooks.filter((webhook) =>
-    webhook.events.some((pattern) => eventPatternMatches(pattern, event.type))
-  );
-  if (matching.length === 0) return;
-
-  const payload = JSON.stringify({
-    id: event.id,
-    type: event.type,
-    path: event.path,
-    actor: event.actor,
-    fields: event.fields,
-    ts: event.ts,
-  });
-  await Promise.allSettled(
-    matching.map(async (webhook) => {
-      const headers: Record<string, string> = {
-        'content-type': 'application/json',
-      };
-      if (webhook.secret) {
-        headers['X-WorkGraph-Signature'] = signPayload(payload, webhook.secret);
-      }
-      const envelope = transport.createTransportEnvelope({
-        direction: 'outbound',
-        channel: 'dashboard-webhook',
-        topic: event.type,
-        source: 'control-api.server-events',
-        target: webhook.url,
-        dedupKeys: [`dashboard-event:${event.id}`, `webhook:${webhook.id}:${event.id}`],
-        correlationId: event.id,
-        payload: {
-          event,
-          webhookId: webhook.id,
-          request: {
-            url: webhook.url,
-            method: 'POST',
-            headers,
-            body: payload,
-          },
-        },
-      });
-      const outbox = transport.createTransportOutboxRecord(workspacePath, {
-        envelope,
-        deliveryHandler: 'dashboard-webhook',
-        deliveryTarget: webhook.url,
-        message: `Dispatching dashboard event ${event.id} to webhook ${webhook.id}.`,
-      });
-      try {
-        const response = await fetch(webhook.url, {
-          method: 'POST',
-          headers,
-          body: payload,
-        });
-        if (!response.ok) {
-          throw new Error(`Webhook ${webhook.id} responded with status ${response.status}.`);
-        }
-        transport.markTransportOutboxDelivered(workspacePath, outbox.id, `Delivered dashboard event ${event.id}.`);
-      } catch (error) {
-        transport.markTransportOutboxFailed(workspacePath, outbox.id, {
-          message: error instanceof Error ? error.message : String(error),
-          context: {
-            webhookId: webhook.id,
-            eventId: event.id,
-            url: webhook.url,
-          },
-        });
-        throw error;
-      }
-    }),
-  );
-}
-
-function readWebhookStore(workspacePath: string): WebhookStoreFile {
-  const filePath = webhookFilePath(workspacePath);
-  if (!fs.existsSync(filePath)) {
-    return {
-      version: WEBHOOKS_VERSION,
-      webhooks: [],
-    };
-  }
-  try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as WebhookStoreFile;
-    if (!Array.isArray(parsed.webhooks)) {
-      throw new Error('Invalid webhook store shape.');
-    }
-    return {
-      version: WEBHOOKS_VERSION,
-      webhooks: parsed.webhooks
-        .map((webhook) => sanitizeStoredWebhook(webhook))
-        .filter((entry): entry is StoredWebhook => entry !== null),
-    };
-  } catch {
-    return {
-      version: WEBHOOKS_VERSION,
-      webhooks: [],
-    };
-  }
-}
-
-function writeWebhookStore(workspacePath: string, store: WebhookStoreFile): void {
-  const filePath = webhookFilePath(workspacePath);
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const serialized: WebhookStoreFile = {
-    version: WEBHOOKS_VERSION,
-    webhooks: store.webhooks.map((webhook) => ({
-      id: webhook.id,
-      url: webhook.url,
-      events: webhook.events,
-      ...(webhook.secret ? { secret: webhook.secret } : {}),
-      createdAt: webhook.createdAt,
-    })),
-  };
-  fs.writeFileSync(filePath, JSON.stringify(serialized, null, 2) + '\n', 'utf-8');
-}
-
-function webhookFilePath(workspacePath: string): string {
-  return path.join(workspacePath, WEBHOOKS_PATH);
-}
-
-function normalizeWebhookUrl(value: string): string {
-  const raw = String(value ?? '').trim();
-  if (!raw) {
-    throw new Error('Missing webhook url.');
-  }
-  let parsed: URL;
-  try {
-    parsed = new URL(raw);
-  } catch {
-    throw new Error(`Invalid webhook url "${raw}".`);
-  }
-  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-    throw new Error(`Invalid webhook url "${raw}". Expected http(s).`);
-  }
-  return parsed.toString();
-}
-
-function normalizeEventPatterns(value: string[]): string[] {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error('Missing webhook events. Provide at least one event pattern.');
-  }
-  const normalized = value
-    .map((item) => String(item).trim())
-    .filter(Boolean);
-  if (normalized.length === 0) {
-    throw new Error('Missing webhook events. Provide at least one event pattern.');
-  }
-  return [...new Set(normalized)];
-}
-
-function signPayload(payload: string, secret: string): string {
-  const digest = crypto.createHmac('sha256', secret).update(payload).digest('hex');
-  return `sha256=${digest}`;
-}
-
-function eventPatternMatches(pattern: string, eventType: string): boolean {
-  if (pattern === '*') return true;
-  if (pattern.endsWith('*')) {
-    return eventType.startsWith(pattern.slice(0, -1));
-  }
-  return pattern === eventType;
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function sanitizeStoredWebhook(raw: unknown): StoredWebhook | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const candidate = raw as Partial<StoredWebhook>;
-  const id = readOptionalString(candidate.id);
-  const url = readOptionalString(candidate.url);
-  const createdAt = readOptionalString(candidate.createdAt) ?? new Date(0).toISOString();
-  if (!id || !url) return null;
-  const events = normalizeStoredEvents(candidate.events);
-  if (events.length === 0) return null;
-  return {
-    id,
-    url,
-    events,
-    createdAt,
-    ...(readOptionalString(candidate.secret) ? { secret: readOptionalString(candidate.secret)! } : {}),
-  };
-}
-
-function normalizeStoredEvents(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((item) => String(item).trim())
-    .filter(Boolean);
-}
-
-function toWebhookView(webhook: StoredWebhook): WebhookView {
-  return {
-    id: webhook.id,
-    url: webhook.url,
-    events: [...webhook.events],
-    createdAt: webhook.createdAt,
-    hasSecret: typeof webhook.secret === 'string' && webhook.secret.length > 0,
-  };
-}
diff --git a/packages/control-api/src/server.test.ts b/packages/control-api/src/server.test.ts
deleted file mode 100644
index 8a896a6..0000000
--- a/packages/control-api/src/server.test.ts
+++ /dev/null
@@ -1,694 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  agent as agentModule,
-  ledger as ledgerModule,
-  store as storeModule,
-  thread as threadModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-import { startWorkgraphServer } from './server.js';
-
-const agent = agentModule;
-const ledger = ledgerModule;
-const store = storeModule;
-const thread = threadModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-server-http-'));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-interface SseEnvelope {
-  id: string;
-  type: string;
-  path: string;
-  actor: string;
-  fields: Record<string, unknown>;
-  ts: string;
-}
-
-interface ParsedSseEvent {
-  id: string;
-  event: string;
-  data: SseEnvelope;
-}
-
-interface SseReader {
-  nextEvent: (timeoutMs?: number) => Promise<ParsedSseEvent>;
-  close: () => Promise<void>;
-}
-
-async function openSseStream(url: string, init?: RequestInit): Promise<SseReader> {
-  const response = await fetch(url, init);
-  expect(response.status).toBe(200);
-  expect(response.body).toBeDefined();
-  return createSseReader(response.body!);
-}
-
-function createSseReader(stream: ReadableStream<Uint8Array>): SseReader {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-  let ended = false;
-
-  const nextEvent = async (timeoutMs: number = 4_000): Promise<ParsedSseEvent> => {
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-      const parsed = tryParseFromBuffer();
-      if (parsed) return parsed;
-      if (ended) {
-        throw new Error('SSE stream ended before next event.');
-      }
-      const remainingMs = deadline - Date.now();
-      if (remainingMs <= 0) {
-        throw new Error('Timed out waiting for SSE event.');
-      }
-      const chunk = await withTimeout(reader.read(), remainingMs, 'Timed out waiting for SSE chunk.');
-      if (chunk.done) {
-        ended = true;
-        buffer += decoder.decode();
-        continue;
-      }
-      buffer += decoder.decode(chunk.value, { stream: true });
-    }
-  };
-
-  const close = async () => {
-    ended = true;
-    try {
-      await reader.cancel();
-    } catch {
-      // no-op
-    }
-  };
-
-  const tryParseFromBuffer = (): ParsedSseEvent | null => {
-    while (true) {
-      const boundaryIndex = buffer.indexOf('\n\n');
-      if (boundaryIndex < 0) return null;
-      const block = buffer.slice(0, boundaryIndex);
-      buffer = buffer.slice(boundaryIndex + 2);
-      const parsed = parseSseBlock(block);
-      if (parsed) return parsed;
-    }
-  };
-
-  return {
-    nextEvent,
-    close,
-  };
-}
-
-function parseSseBlock(block: string): ParsedSseEvent | null {
-  const lines = block.split('\n').map((line) => line.replace(/\r$/, ''));
-  let id = '';
-  let event = '';
-  const dataLines: string[] = [];
-  for (const line of lines) {
-    if (!line || line.startsWith(':')) continue;
-    const separator = line.indexOf(':');
-    if (separator < 0) continue;
-    const key = line.slice(0, separator).trim();
-    const value = line.slice(separator + 1).trimStart();
-    if (key === 'id') {
-      id = value;
-      continue;
-    }
-    if (key === 'event') {
-      event = value;
-      continue;
-    }
-    if (key === 'data') {
-      dataLines.push(value);
-    }
-  }
-  if (dataLines.length === 0) return null;
-  const data = JSON.parse(dataLines.join('\n')) as SseEnvelope;
-  return {
-    id: id || data.id,
-    event: event || data.type,
-    data,
-  };
-}
-
-async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-  return await new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(message));
-    }, timeoutMs);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      },
-    );
-  });
-}
-
-describe('workgraph server REST API', () => {
-  it('serves /health endpoint', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/health`);
-      const body = await response.json() as Record<string, unknown>;
-      expect(response.status).toBe(200);
-      expect(body.ok).toBe(true);
-      expect(body.endpointPath).toBe('/mcp');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('returns workspace status from /api/status', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      thread.createThread(workspacePath, 'Status thread', 'Status goal', 'seed');
-      const response = await fetch(`${handle.baseUrl}/api/status`);
-      const body = await response.json() as {
-        ok: boolean;
-        status: { threads: { total: number } };
-      };
-      expect(response.status).toBe(200);
-      expect(body.ok).toBe(true);
-      expect(body.status.threads.total).toBe(1);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('rejects missing token for protected REST endpoints', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      bearerToken: 'secret',
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/status`);
-      const body = await response.json() as Record<string, unknown>;
-      expect(response.status).toBe(401);
-      expect(body.error).toBe('Missing bearer token.');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('rejects invalid token for protected REST endpoints', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      bearerToken: 'secret',
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/status`, {
-        headers: {
-          authorization: 'Bearer wrong',
-        },
-      });
-      const body = await response.json() as Record<string, unknown>;
-      expect(response.status).toBe(403);
-      expect(body.error).toBe('Invalid bearer token.');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('accepts valid token for protected REST endpoints', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      bearerToken: 'secret',
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/status`, {
-        headers: {
-          authorization: 'Bearer secret',
-        },
-      });
-      expect(response.status).toBe(200);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('lists threads with filters and limit', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      thread.createThread(workspacePath, 'Open backend', 'Goal', 'seed', { space: 'spaces/backend' });
-      const active = thread.createThread(workspacePath, 'Active backend', 'Goal', 'seed', { space: 'spaces/backend' });
-      thread.claim(workspacePath, active.path, 'agent-a');
-      thread.createThread(workspacePath, 'Open frontend', 'Goal', 'seed', { space: 'spaces/frontend' });
-
-      const response = await fetch(`${handle.baseUrl}/api/threads?status=open&space=spaces/backend&limit=1`);
-      const body = await response.json() as {
-        ok: boolean;
-        count: number;
-        threads: Array<{ path: string; ready: boolean; fields: { status: string } }>;
-      };
-      expect(response.status).toBe(200);
-      expect(body.ok).toBe(true);
-      expect(body.count).toBe(1);
-      expect(body.threads[0].path).toBe('threads/open-backend.md');
-      expect(body.threads[0].fields.status).toBe('open');
-      expect(typeof body.threads[0].ready).toBe('boolean');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('returns one thread by slug id', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const created = thread.createThread(workspacePath, 'Lookup thread', 'Goal', 'seed');
-      const response = await fetch(`${handle.baseUrl}/api/threads/lookup-thread`);
-      const body = await response.json() as { ok: boolean; thread: { path: string } };
-      expect(response.status).toBe(200);
-      expect(body.ok).toBe(true);
-      expect(body.thread.path).toBe(created.path);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('returns one thread by encoded path id', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const created = thread.createThread(workspacePath, 'Lookup encoded', 'Goal', 'seed');
-      const encodedPath = encodeURIComponent(created.path);
-      const response = await fetch(`${handle.baseUrl}/api/threads/${encodedPath}`);
-      const body = await response.json() as { ok: boolean; thread: { path: string } };
-      expect(response.status).toBe(200);
-      expect(body.ok).toBe(true);
-      expect(body.thread.path).toBe(created.path);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('returns 404 when thread is missing', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/threads/does-not-exist`);
-      expect(response.status).toBe(404);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('creates threads via POST /api/threads', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      defaultActor: 'api-default',
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/threads`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          title: 'From API',
-          goal: 'Ship from REST',
-          tags: ['api', 'test'],
-        }),
-      });
-      const body = await response.json() as { ok: boolean; thread: { path: string } };
-      expect(response.status).toBe(201);
-      expect(body.ok).toBe(true);
-      expect(body.thread.path).toBe('threads/from-api.md');
-      const persisted = store.read(workspacePath, body.thread.path);
-      expect(persisted).not.toBeNull();
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('creates intake-style threads from observation', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/threads`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          observation: 'Observed deployment regression in edge nodes',
-        }),
-      });
-      const body = await response.json() as { ok: boolean; thread: { path: string } };
-      expect(response.status).toBe(201);
-      expect(body.ok).toBe(true);
-      expect(body.thread.path).toBe('threads/observed-deployment-regression-in-edge-nodes.md');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('updates thread status via PATCH /api/threads/:id', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      defaultActor: 'api-default',
-    });
-    try {
-      const created = thread.createThread(workspacePath, 'Patch me', 'Goal', 'seed');
-
-      const claimResponse = await fetch(`${handle.baseUrl}/api/threads/patch-me`, {
-        method: 'PATCH',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          status: 'active',
-          actor: 'api-worker',
-        }),
-      });
-      const claimBody = await claimResponse.json() as { ok: boolean; thread: { fields: { status: string; owner: string } } };
-      expect(claimResponse.status).toBe(200);
-      expect(claimBody.ok).toBe(true);
-      expect(claimBody.thread.fields.status).toBe('active');
-      expect(claimBody.thread.fields.owner).toBe('api-worker');
-
-      const doneResponse = await fetch(`${handle.baseUrl}/api/threads/${encodeURIComponent(created.path)}`, {
-        method: 'PATCH',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          status: 'done',
-          actor: 'api-worker',
-          output: 'Done from REST https://github.com/Versatly/workgraph/pull/1',
-        }),
-      });
-      const doneBody = await doneResponse.json() as { ok: boolean; thread: { fields: { status: string } } };
-      expect(doneResponse.status).toBe(200);
-      expect(doneBody.ok).toBe(true);
-      expect(doneBody.thread.fields.status).toBe('done');
-
-      const reopenResponse = await fetch(`${handle.baseUrl}/api/threads/patch-me`, {
-        method: 'PATCH',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          status: 'open',
-          actor: 'api-worker',
-          reason: 'Needs follow-up',
-        }),
-      });
-      const reopenBody = await reopenResponse.json() as { ok: boolean; thread: { fields: { status: string } } };
-      expect(reopenResponse.status).toBe(200);
-      expect(reopenBody.ok).toBe(true);
-      expect(reopenBody.thread.fields.status).toBe('open');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('returns recent ledger entries with a limit', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const first = thread.createThread(workspacePath, 'Ledger one', 'Goal', 'seed');
-      const second = thread.createThread(workspacePath, 'Ledger two', 'Goal', 'seed');
-      thread.claim(workspacePath, first.path, 'agent-a');
-      thread.claim(workspacePath, second.path, 'agent-b');
-
-      const response = await fetch(`${handle.baseUrl}/api/ledger?limit=2`);
-      const body = await response.json() as {
-        ok: boolean;
-        count: number;
-        entries: Array<{ target: string }>;
-      };
-      expect(response.status).toBe(200);
-      expect(body.ok).toBe(true);
-      expect(body.count).toBe(2);
-      expect(body.entries.length).toBe(2);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('replays missed thread events from Last-Event-ID with stable ordering and ids', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    const streams: SseReader[] = [];
-    try {
-      const createdThread = thread.createThread(workspacePath, 'SSE replay', 'Replay goal', 'seed');
-      const streamUrl = `${handle.baseUrl}/api/events`
-        + `?thread=${encodeURIComponent(createdThread.path)}`
-        + '&event=thread.created&event=thread.claimed&event=thread.done';
-
-      const initialStream = await openSseStream(streamUrl);
-      streams.push(initialStream);
-      const createdEvent = await initialStream.nextEvent();
-      expect(createdEvent.event).toBe('thread.created');
-      expect(createdEvent.data.id).toBe(createdEvent.id);
-      expect(Object.keys(createdEvent.data)).toEqual(['id', 'type', 'path', 'actor', 'fields', 'ts']);
-      await initialStream.close();
-
-      thread.claim(workspacePath, createdThread.path, 'worker-a');
-      thread.done(
-        workspacePath,
-        createdThread.path,
-        'worker-a',
-        'Completed in SSE replay test https://github.com/Versatly/workgraph/pull/1',
-      );
-
-      const replayStream = await openSseStream(streamUrl, {
-        headers: {
-          'last-event-id': createdEvent.id,
-        },
-      });
-      streams.push(replayStream);
-      const firstMissed = await replayStream.nextEvent();
-      const secondMissed = await replayStream.nextEvent();
-      expect(firstMissed.event).toBe('thread.claimed');
-      expect(secondMissed.event).toBe('thread.done');
-      expect(firstMissed.id).not.toBe(secondMissed.id);
-      await replayStream.close();
-
-      const deterministicReplay = await openSseStream(streamUrl, {
-        headers: {
-          'last-event-id': createdEvent.id,
-        },
-      });
-      streams.push(deterministicReplay);
-      const replayAgainFirst = await deterministicReplay.nextEvent();
-      const replayAgainSecond = await deterministicReplay.nextEvent();
-      expect([replayAgainFirst.id, replayAgainSecond.id]).toEqual([firstMissed.id, secondMissed.id]);
-      expect([replayAgainFirst.event, replayAgainSecond.event]).toEqual(['thread.claimed', 'thread.done']);
-      await deterministicReplay.close();
-    } finally {
-      for (const stream of streams) {
-        await stream.close();
-      }
-      await handle.close();
-    }
-  });
-
-  it('supports primitive filters for conversation, plan-step, and run updates', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    const streams: SseReader[] = [];
-    try {
-      ledger.append(workspacePath, 'seed', 'update', 'conversations/sse.md', 'conversation', {
-        status: 'active',
-      });
-      ledger.append(workspacePath, 'seed', 'update', 'plan-steps/sse.md', 'plan-step', {
-        status: 'active',
-      });
-      ledger.append(workspacePath, 'seed', 'update', '.workgraph/runs/run_sse', 'run', {
-        status: 'running',
-      });
-
-      const conversationStream = await openSseStream(
-        `${handle.baseUrl}/api/events?primitive=conversation&event=conversation.updated`,
-      );
-      streams.push(conversationStream);
-      const conversationEvent = await conversationStream.nextEvent();
-      expect(conversationEvent.event).toBe('conversation.updated');
-      expect(conversationEvent.data.path).toBe('conversations/sse.md');
-      await conversationStream.close();
-
-      const stepStream = await openSseStream(
-        `${handle.baseUrl}/api/events?primitive=plan-step&event=plan-step.updated`,
-      );
-      streams.push(stepStream);
-      const stepEvent = await stepStream.nextEvent();
-      expect(stepEvent.event).toBe('plan-step.updated');
-      expect(stepEvent.data.path).toBe('plan-steps/sse.md');
-      await stepStream.close();
-
-      const runStream = await openSseStream(
-        `${handle.baseUrl}/api/events?primitive=run&event=run.updated`,
-      );
-      streams.push(runStream);
-      const runEvent = await runStream.nextEvent();
-      expect(runEvent.event).toBe('run.updated');
-      expect(runEvent.data.path).toBe('.workgraph/runs/run_sse');
-      await runStream.close();
-    } finally {
-      for (const stream of streams) {
-        await stream.close();
-      }
-      await handle.close();
-    }
-  });
-
-  it('sends keepalive heartbeat comments for idle SSE streams', async () => {
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      sseKeepaliveMs: 100,
-    });
-    try {
-      const response = await fetch(`${handle.baseUrl}/api/events?event=thread.done`);
-      expect(response.status).toBe(200);
-      expect(response.body).toBeDefined();
-      const reader = response.body!.getReader();
-      const decoder = new TextDecoder();
-      let output = '';
-      const deadline = Date.now() + 1_500;
-      while (Date.now() < deadline && !output.includes(':keepalive')) {
-        const remaining = deadline - Date.now();
-        const chunk = await withTimeout(
-          reader.read(),
-          remaining,
-          'Timed out waiting for SSE keepalive comment.',
-        );
-        if (chunk.done) break;
-        output += decoder.decode(chunk.value, { stream: true });
-      }
-      expect(output.includes(':keepalive')).toBe(true);
-      await reader.cancel();
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('enforces strict credential identity for mutating REST endpoints', async () => {
-    const init = workspace.initWorkspace(workspacePath, { createReadme: false, createBases: false });
-    const registration = agent.registerAgent(workspacePath, 'api-admin', {
-      token: init.bootstrapTrustToken,
-      capabilities: ['thread:create', 'thread:update', 'thread:complete'],
-    });
-    expect(registration.apiKey).toBeDefined();
-
-    const serverConfigPath = path.join(workspacePath, '.workgraph', 'server.json');
-    const serverConfig = JSON.parse(fs.readFileSync(serverConfigPath, 'utf-8')) as Record<string, unknown>;
-    serverConfig.auth = {
-      mode: 'strict',
-      allowUnauthenticatedFallback: false,
-    };
-    fs.writeFileSync(serverConfigPath, `${JSON.stringify(serverConfig, null, 2)}\n`, 'utf-8');
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-      defaultActor: 'system',
-    });
-    try {
-      const unauthorized = await fetch(`${handle.baseUrl}/api/threads`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          title: 'Strict denied',
-          goal: 'Missing credential should fail',
-        }),
-      });
-      expect(unauthorized.status).toBe(403);
-
-      const spoofed = await fetch(`${handle.baseUrl}/api/threads`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          authorization: `Bearer ${registration.apiKey}`,
-        },
-        body: JSON.stringify({
-          title: 'Strict spoofed',
-          goal: 'Credential actor mismatch should fail',
-          actor: 'spoofed-actor',
-        }),
-      });
-      expect(spoofed.status).toBe(403);
-
-      const authorized = await fetch(`${handle.baseUrl}/api/threads`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          authorization: `Bearer ${registration.apiKey}`,
-        },
-        body: JSON.stringify({
-          title: 'Strict allowed',
-          goal: 'Valid credential actor should pass',
-        }),
-      });
-      expect(authorized.status).toBe(201);
-      const body = await authorized.json() as { ok: boolean; thread: { path: string } };
-      expect(body.ok).toBe(true);
-      expect(body.thread.path).toBe('threads/strict-allowed.md');
-    } finally {
-      await handle.close();
-    }
-  });
-});
diff --git a/packages/control-api/src/server.ts b/packages/control-api/src/server.ts
deleted file mode 100644
index 3ee5a0f..0000000
--- a/packages/control-api/src/server.ts
+++ /dev/null
@@ -1,1042 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import {
-  auth as authModule,
-  ledger as ledgerModule,
-  orientation as orientationModule,
-  store as storeModule,
-  thread as threadModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-import {
-  startWorkgraphMcpHttpServer,
-  type WorkgraphMcpHttpServerHandle,
-} from '@versatly/workgraph-mcp-server';
-import {
-  buildAgentsLens,
-  buildAttentionLens,
-  buildSpacesLens,
-  buildTimelineLens,
-} from './server-lenses.js';
-import {
-  buildProjectionByName,
-  listProjectionRouteNames,
-} from './server-projections.js';
-import {
-  createDashboardEventFilter,
-  type DashboardEvent,
-  listDashboardEventsSince,
-  subscribeToDashboardEvents,
-  toSsePayload,
-} from './server-events.js';
-import {
-  deleteWebhook,
-  dispatchWebhookEvent,
-  listWebhooks,
-  registerWebhook,
-} from './server-webhooks.js';
-import { registerWebhookGatewayEndpoint } from './webhook-gateway.js';
-
-const ledger = ledgerModule;
-const auth = authModule;
-const orientation = orientationModule;
-const store = storeModule;
-const thread = threadModule;
-const workspace = workspaceModule;
-
-const DEFAULT_HOST = '0.0.0.0';
-const DEFAULT_PORT = 8787;
-const DEFAULT_WORKSPACE = '/data/workspace';
-const DEFAULT_ENDPOINT_PATH = '/mcp';
-const DEFAULT_LEDGER_LIMIT = 20;
-const DEFAULT_THREADS_LIMIT = 100;
-const MAX_LEDGER_LIMIT = 500;
-const MAX_THREADS_LIMIT = 1_000;
-const DEFAULT_SSE_KEEPALIVE_MS = 15_000;
-const SSE_RETRY_MS = 3_000;
-
-type LogLevel = 'info' | 'warn' | 'error';
-
-export interface WorkgraphServerOptions {
-  workspacePath: string;
-  host?: string;
-  port?: number;
-  bearerToken?: string;
-  defaultActor?: string;
-  endpointPath?: string;
-  sseKeepaliveMs?: number;
-}
-
-type PrimitiveInstance = any;
-type ThreadStatus = string;
-
-export interface WorkgraphServerHandle {
-  host: string;
-  port: number;
-  endpointPath: string;
-  baseUrl: string;
-  healthUrl: string;
-  url: string;
-  webhookGatewayUrlTemplate: string;
-  close: () => Promise<void>;
-  workspacePath: string;
-  workspaceInitialized: boolean;
-}
-
-interface WaitForShutdownOptions {
-  onSignal?: (signal: NodeJS.Signals) => void;
-  onClosed?: () => void;
-}
-
-interface ThreadUpdateRequestBody {
-  actor?: unknown;
-  status?: unknown;
-  output?: unknown;
-  reason?: unknown;
-  blockedBy?: unknown;
-  leaseTtlMinutes?: unknown;
-}
-
-interface ThreadCreateRequestBody {
-  actor?: unknown;
-  title?: unknown;
-  goal?: unknown;
-  observation?: unknown;
-  priority?: unknown;
-  deps?: unknown;
-  parent?: unknown;
-  space?: unknown;
-  context_refs?: unknown;
-  tags?: unknown;
-}
-
-interface WebhookCreateRequestBody {
-  actor?: unknown;
-  url?: unknown;
-  events?: unknown;
-  secret?: unknown;
-}
-
-export async function startWorkgraphServer(options: WorkgraphServerOptions): Promise<WorkgraphServerHandle> {
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-  const workspacePath = path.resolve(options.workspacePath);
-  const host = readNonEmptyString(options.host) ?? DEFAULT_HOST;
-  const port = normalizePort(options.port, DEFAULT_PORT);
-  const endpointPath = readNonEmptyString(options.endpointPath) ?? DEFAULT_ENDPOINT_PATH;
-  const defaultActor = readNonEmptyString(options.defaultActor) ?? 'anonymous';
-  const sseKeepaliveMs = normalizeSseKeepaliveMs(options.sseKeepaliveMs);
-
-  const workspaceInitialized = ensureWorkspaceInitialized(workspacePath);
-  const unsubscribeWebhookDispatch = subscribeToDashboardEvents(workspacePath, (event) => {
-    void dispatchWebhookEvent(workspacePath, event);
-  });
-
-  let handle: WorkgraphMcpHttpServerHandle;
-  try {
-    handle = await startWorkgraphMcpHttpServer({
-      workspacePath,
-      defaultActor,
-      host,
-      port,
-      endpointPath,
-      bearerToken: options.bearerToken,
-      onApp: ({ app, bearerAuthMiddleware }) => {
-        registerWebhookGatewayEndpoint(app, workspacePath);
-        app.use('/api', bearerAuthMiddleware);
-        app.use('/api', (req: any, _res: any, next: () => void) => {
-          auth.runWithAuthContext(buildRequestAuthContext(req), () => next());
-        });
-        registerRestRoutes(app, workspacePath, defaultActor, sseKeepaliveMs);
-      },
-    });
-  } catch (error) {
-    unsubscribeWebhookDispatch();
-    throw error;
-  }
-
-  return {
-    ...handle,
-    webhookGatewayUrlTemplate: `${handle.baseUrl}/webhook-gateway/{sourceKey}`,
-    close: async () => {
-      unsubscribeWebhookDispatch();
-      await handle.close();
-    },
-    workspacePath,
-    workspaceInitialized,
-  };
-}
-
-export async function waitForShutdown(
-  handle: Pick<WorkgraphServerHandle, 'close'>,
-  options: WaitForShutdownOptions = {},
-): Promise<void> {
-  let closing = false;
-  await new Promise<void>((resolve, reject) => {
-    const stop = async (signal: NodeJS.Signals) => {
-      if (closing) return;
-      closing = true;
-      options.onSignal?.(signal);
-      try {
-        await handle.close();
-        options.onClosed?.();
-        cleanup();
-        resolve();
-      } catch (error) {
-        cleanup();
-        reject(error);
-      }
-    };
-
-    const onSigterm = () => { void stop('SIGTERM'); };
-    const onSigint = () => { void stop('SIGINT'); };
-    const cleanup = () => {
-      process.off('SIGTERM', onSigterm);
-      process.off('SIGINT', onSigint);
-    };
-
-    process.on('SIGTERM', onSigterm);
-    process.on('SIGINT', onSigint);
-  });
-}
-
-export async function runWorkgraphServerFromEnv(): Promise<void> {
-  const options = loadServerOptionsFromEnv(process.env);
-  logJson('info', 'server_starting', {
-    workspacePath: options.workspacePath,
-    host: options.host,
-    port: options.port,
-    endpointPath: options.endpointPath,
-    auth: options.bearerToken ? 'bearer' : 'none',
-    actor: options.defaultActor,
-  });
-
-  const handle = await startWorkgraphServer(options);
-  if (handle.workspaceInitialized) {
-    logJson('info', 'workspace_initialized', { workspacePath: handle.workspacePath });
-  }
-  logJson('info', 'server_started', {
-    workspacePath: handle.workspacePath,
-    host: handle.host,
-    port: handle.port,
-    endpointPath: handle.endpointPath,
-    mcpUrl: handle.url,
-    healthUrl: handle.healthUrl,
-    webhookGatewayUrlTemplate: handle.webhookGatewayUrlTemplate,
-  });
-
-  await waitForShutdown(handle, {
-    onSignal: (signal) => {
-      logJson('info', 'shutdown_signal', { signal });
-    },
-    onClosed: () => {
-      logJson('info', 'server_stopped', {});
-    },
-  });
-}
-
-export function loadServerOptionsFromEnv(env: NodeJS.ProcessEnv): WorkgraphServerOptions {
-  return {
-    workspacePath: readNonEmptyString(env.WORKGRAPH_WORKSPACE) ?? DEFAULT_WORKSPACE,
-    host: readNonEmptyString(env.WORKGRAPH_HOST) ?? DEFAULT_HOST,
-    port: parseOptionalPort(env.WORKGRAPH_PORT) ?? DEFAULT_PORT,
-    bearerToken: readNonEmptyString(env.WORKGRAPH_BEARER_TOKEN),
-    defaultActor: readNonEmptyString(env.WORKGRAPH_ACTOR) ?? 'anonymous',
-    endpointPath: DEFAULT_ENDPOINT_PATH,
-    sseKeepaliveMs: parseOptionalPositiveInt(env.WORKGRAPH_SSE_KEEPALIVE_MS, {
-      max: 60_000,
-    }),
-  };
-}
-
-function registerRestRoutes(
-  app: any,
-  workspacePath: string,
-  defaultActor: string,
-  sseKeepaliveMs: number,
-): void {
-  app.get('/api/events', (req: any, res: any) => {
-    try {
-      const lastEventId = readNonEmptyString(req.headers?.['last-event-id'])
-        ?? readNonEmptyString(req.query?.lastEventId);
-      const filter = createDashboardEventFilter({
-        eventTypes: readCsvQueryValues(req.query, ['event', 'events']),
-        primitiveTypes: readCsvQueryValues(req.query, ['primitive', 'primitiveType']),
-        threads: readCsvQueryValues(req.query, ['thread']),
-      });
-      res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
-      res.setHeader('Cache-Control', 'no-cache, no-transform');
-      res.setHeader('Connection', 'keep-alive');
-      res.setHeader('X-Accel-Buffering', 'no');
-      if (typeof res.flushHeaders === 'function') {
-        res.flushHeaders();
-      }
-      if (!safeStreamWrite(res, ':connected\n\n')) return;
-      if (!safeStreamWrite(res, `retry: ${SSE_RETRY_MS}\n\n`)) return;
-
-      let cleaned = false;
-      let streamReady = false;
-      let unsubscribe = () => {};
-      let keepAlive: NodeJS.Timeout | undefined;
-      const queuedLiveEvents: DashboardEvent[] = [];
-      let dedupeDuringBootstrap = true;
-      const bootstrapDeliveredIds = new Set<string>();
-
-      const cleanup = () => {
-        if (cleaned) return;
-        cleaned = true;
-        if (keepAlive) {
-          clearInterval(keepAlive);
-        }
-        unsubscribe();
-      };
-
-      const emitEvent = (event: DashboardEvent): boolean => {
-        if (dedupeDuringBootstrap) {
-          if (bootstrapDeliveredIds.has(event.id)) return true;
-          bootstrapDeliveredIds.add(event.id);
-        }
-        if (safeStreamWrite(res, toSsePayload(event))) {
-          return true;
-        }
-        cleanup();
-        return false;
-      };
-
-      unsubscribe = subscribeToDashboardEvents(workspacePath, (event) => {
-        if (!streamReady) {
-          queuedLiveEvents.push(event);
-          return;
-        }
-        emitEvent(event);
-      }, filter);
-
-      const replay = listDashboardEventsSince(workspacePath, lastEventId, filter);
-      for (const event of replay) {
-        if (!emitEvent(event)) return;
-      }
-
-      while (queuedLiveEvents.length > 0) {
-        const event = queuedLiveEvents.shift();
-        if (!event) break;
-        if (!emitEvent(event)) return;
-      }
-      streamReady = true;
-      dedupeDuringBootstrap = false;
-      bootstrapDeliveredIds.clear();
-
-      keepAlive = setInterval(() => {
-        if (!safeStreamWrite(res, `:keepalive ${Date.now()}\n\n`)) {
-          cleanup();
-        }
-      }, sseKeepaliveMs);
-      if (typeof keepAlive.unref === 'function') {
-        keepAlive.unref();
-      }
-
-      req.on('close', cleanup);
-      req.on('aborted', cleanup);
-      res.on('close', cleanup);
-      res.on('error', cleanup);
-    } catch (error) {
-      if (!res.headersSent) {
-        writeRouteError(res, error);
-      }
-    }
-  });
-
-  app.get('/api/status', (_req: any, res: any) => {
-    try {
-      const snapshot = orientation.statusSnapshot(workspacePath);
-      res.json({
-        ok: true,
-        status: snapshot,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/api/threads', (req: any, res: any) => {
-    try {
-      const status = readNonEmptyString(req.query?.status);
-      const space = readNonEmptyString(req.query?.space);
-      const limit = parseOptionalPositiveInt(req.query?.limit, {
-        fallback: DEFAULT_THREADS_LIMIT,
-        max: MAX_THREADS_LIMIT,
-      }) ?? DEFAULT_THREADS_LIMIT;
-      const threads = listThreads(workspacePath, {
-        status,
-        space,
-        limit,
-      });
-      res.json({
-        ok: true,
-        count: threads.length,
-        threads,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/api/threads/:id', (req: any, res: any) => {
-    try {
-      const threadId = readNonEmptyString(req.params?.id);
-      if (!threadId) {
-        res.status(400).json({
-          ok: false,
-          error: 'Thread id is required.',
-        });
-        return;
-      }
-      const resolved = resolveThreadInstance(workspacePath, threadId);
-      if (!resolved) {
-        res.status(404).json({
-          ok: false,
-          error: `Thread not found: ${threadId}`,
-        });
-        return;
-      }
-      res.json({
-        ok: true,
-        thread: resolved,
-        history: ledger.historyOf(workspacePath, resolved.path),
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.post('/api/threads', (req: any, res: any) => {
-    try {
-      const payload = toRecord(req.body);
-      const actor = resolveMutationActor(req, workspacePath, payload.actor, defaultActor);
-      const created = createThreadFromPayload(workspacePath, payload, actor);
-      res.status(201).json({
-        ok: true,
-        thread: created,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.patch('/api/threads/:id', (req: any, res: any) => {
-    try {
-      const threadId = readNonEmptyString(req.params?.id);
-      if (!threadId) {
-        res.status(400).json({
-          ok: false,
-          error: 'Thread id is required.',
-        });
-        return;
-      }
-      const payload = toRecord(req.body);
-      const actor = resolveMutationActor(req, workspacePath, payload.actor, defaultActor);
-      const updated = updateThreadFromPayload(workspacePath, threadId, payload, actor);
-      res.json({
-        ok: true,
-        thread: updated,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/api/ledger', (req: any, res: any) => {
-    try {
-      const limit = parseOptionalPositiveInt(req.query?.limit, {
-        fallback: DEFAULT_LEDGER_LIMIT,
-        max: MAX_LEDGER_LIMIT,
-      }) ?? DEFAULT_LEDGER_LIMIT;
-      const entries = ledger.recent(workspacePath, limit);
-      res.json({
-        ok: true,
-        count: entries.length,
-        entries,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/api/lens/:name', (req: any, res: any) => {
-    try {
-      const lensName = readNonEmptyString(req.params?.name)?.toLowerCase();
-      const space = readNonEmptyString(req.query?.space);
-      if (!lensName) {
-        res.status(400).json({
-          ok: false,
-          error: 'Lens name is required.',
-        });
-        return;
-      }
-
-      if (lensName === 'attention') {
-        res.json({
-          ok: true,
-          ...buildAttentionLens(workspacePath, { space }),
-        });
-        return;
-      }
-      if (lensName === 'agents') {
-        res.json({
-          ok: true,
-          ...buildAgentsLens(workspacePath, { space }),
-        });
-        return;
-      }
-      if (lensName === 'spaces') {
-        res.json({
-          ok: true,
-          ...buildSpacesLens(workspacePath, { space }),
-        });
-        return;
-      }
-      if (lensName === 'timeline') {
-        res.json({
-          ok: true,
-          ...buildTimelineLens(workspacePath, { space }),
-        });
-        return;
-      }
-
-      res.status(404).json({
-        ok: false,
-        error: `Unknown lens "${lensName}".`,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/api/projections/:name', (req: any, res: any) => {
-    try {
-      const projectionName = readNonEmptyString(req.params?.name)?.toLowerCase();
-      if (!projectionName) {
-        res.status(400).json({
-          ok: false,
-          error: 'Missing projection name.',
-        });
-        return;
-      }
-      const allowed = new Set(listProjectionRouteNames());
-      if (!allowed.has(projectionName as ReturnType<typeof listProjectionRouteNames>[number])) {
-        res.status(404).json({
-          ok: false,
-          error: `Unknown projection "${projectionName}".`,
-          available: listProjectionRouteNames(),
-        });
-        return;
-      }
-      const projection = buildProjectionByName(
-        workspacePath,
-        projectionName as ReturnType<typeof listProjectionRouteNames>[number],
-      );
-      res.json({
-        ok: true,
-        projection,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/control-plane', (_req: any, res: any) => {
-    try {
-      serveControlPlaneFile(res, 'index.html', 'text/html; charset=utf-8');
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/control-plane/style.css', (_req: any, res: any) => {
-    try {
-      serveControlPlaneFile(res, 'style.css', 'text/css; charset=utf-8');
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/control-plane/app.js', (_req: any, res: any) => {
-    try {
-      serveControlPlaneFile(res, 'app.js', 'application/javascript; charset=utf-8');
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/control-plane/:page', (req: any, res: any) => {
-    try {
-      const page = readNonEmptyString(req.params?.page)?.toLowerCase();
-      if (!page) {
-        res.status(400).json({
-          ok: false,
-          error: 'Missing control-plane page name.',
-        });
-        return;
-      }
-      const allowedPages = new Set(listProjectionRouteNames().filter((entry) => entry !== 'overview'));
-      if (!allowedPages.has(page as Exclude<ReturnType<typeof listProjectionRouteNames>[number], 'overview'>)) {
-        res.status(404).json({
-          ok: false,
-          error: `Unknown control-plane page "${page}".`,
-          available: [...allowedPages],
-        });
-        return;
-      }
-      serveControlPlaneFile(res, `${page}.html`, 'text/html; charset=utf-8');
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.get('/api/webhooks', (_req: any, res: any) => {
-    try {
-      const webhooks = listWebhooks(workspacePath);
-      res.json({
-        ok: true,
-        count: webhooks.length,
-        webhooks,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.post('/api/webhooks', (req: any, res: any) => {
-    try {
-      const payload = toRecord(req.body) as WebhookCreateRequestBody;
-      const actor = resolveMutationActor(req, workspacePath, payload.actor, defaultActor);
-      const url = readNonEmptyString(payload.url);
-      if (!url) {
-        throw new Error('Missing required field "url".');
-      }
-      const events = parseStringList(payload.events);
-      if (!events || events.length === 0) {
-        throw new Error('Missing required field "events".');
-      }
-      auth.assertAuthorizedMutation(workspacePath, {
-        actor,
-        action: 'webhook.register',
-        target: '.workgraph/webhooks.json',
-        requiredCapabilities: ['policy:manage', 'dispatch:run'],
-        metadata: {
-          module: 'control-api',
-        },
-      });
-      const webhook = registerWebhook(workspacePath, {
-        url,
-        events,
-        secret: readNonEmptyString(payload.secret),
-      });
-      ledger.append(workspacePath, actor, 'create', `.workgraph/webhooks/${webhook.id}`, 'webhook', {
-        url: webhook.url,
-        events: webhook.events,
-      });
-      res.status(201).json({
-        ok: true,
-        webhook,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-
-  app.delete('/api/webhooks/:id', (req: any, res: any) => {
-    try {
-      const actor = resolveMutationActor(req, workspacePath, undefined, defaultActor);
-      const webhookId = readNonEmptyString(req.params?.id);
-      if (!webhookId) {
-        res.status(400).json({
-          ok: false,
-          error: 'Webhook id is required.',
-        });
-        return;
-      }
-      auth.assertAuthorizedMutation(workspacePath, {
-        actor,
-        action: 'webhook.delete',
-        target: `.workgraph/webhooks.json#${webhookId}`,
-        requiredCapabilities: ['policy:manage', 'dispatch:run'],
-        metadata: {
-          module: 'control-api',
-        },
-      });
-      const deleted = deleteWebhook(workspacePath, webhookId);
-      if (!deleted) {
-        res.status(404).json({
-          ok: false,
-          error: `Webhook not found: ${webhookId}`,
-        });
-        return;
-      }
-      ledger.append(workspacePath, actor, 'delete', `.workgraph/webhooks/${webhookId}`, 'webhook');
-      res.json({
-        ok: true,
-        id: webhookId,
-      });
-    } catch (error) {
-      writeRouteError(res, error);
-    }
-  });
-}
-
-function ensureWorkspaceInitialized(workspacePath: string): boolean {
-  let initialized = false;
-  if (!fs.existsSync(workspacePath)) {
-    fs.mkdirSync(workspacePath, { recursive: true });
-  }
-  if (!workspace.isWorkgraphWorkspace(workspacePath)) {
-    workspace.initWorkspace(workspacePath);
-    initialized = true;
-  }
-  return initialized;
-}
-
-function listThreads(
-  workspacePath: string,
-  options: { status?: string; space?: string; limit: number },
-): Array<PrimitiveInstance & { ready: boolean }> {
-  const baseThreads = options.space
-    ? store.threadsInSpace(workspacePath, options.space)
-    : store.list(workspacePath, 'thread');
-  const readySet = new Set(
-    (options.space
-      ? thread.listReadyThreadsInSpace(workspacePath, options.space)
-      : thread.listReadyThreads(workspacePath))
-      .map((item) => item.path),
-  );
-
-  let filtered = baseThreads;
-  if (options.status) {
-    filtered = filtered.filter((item) => String(item.fields.status) === options.status);
-  }
-
-  return filtered
-    .slice(0, options.limit)
-    .map((item) => ({
-      ...item,
-      ready: readySet.has(item.path),
-    }));
-}
-
-function createThreadFromPayload(
-  workspacePath: string,
-  payload: Record<string, unknown>,
-  actor: string,
-): PrimitiveInstance {
-  const body = payload as ThreadCreateRequestBody;
-  const goal = readNonEmptyString(body.goal) ?? readNonEmptyString(body.observation);
-  if (!goal) {
-    throw new Error('Missing required field "goal" (or "observation").');
-  }
-  const title = readNonEmptyString(body.title) ?? summarizeGoal(goal);
-  return thread.createThread(workspacePath, title, goal, actor, {
-    priority: readNonEmptyString(body.priority),
-    deps: parseStringList(body.deps),
-    parent: readNonEmptyString(body.parent),
-    space: readNonEmptyString(body.space),
-    context_refs: parseStringList(body.context_refs),
-    tags: parseStringList(body.tags),
-  });
-}
-
-function updateThreadFromPayload(
-  workspacePath: string,
-  rawThreadId: string,
-  payload: Record<string, unknown>,
-  actor: string,
-): PrimitiveInstance {
-  const threadInstance = resolveThreadInstance(workspacePath, rawThreadId);
-  if (!threadInstance) {
-    throw new Error(`Thread not found: ${rawThreadId}`);
-  }
-
-  const body = payload as ThreadUpdateRequestBody;
-  const status = readNonEmptyString(body.status);
-  if (!isThreadStatus(status)) {
-    throw new Error('Invalid or missing field "status". Expected open|active|blocked|done|cancelled.');
-  }
-
-  const reason = readNonEmptyString(body.reason);
-  const output = readNonEmptyString(body.output);
-  const blockedBy = readNonEmptyString(body.blockedBy) ?? 'external/manual';
-  const leaseTtlMinutes = parseOptionalPositiveInt(body.leaseTtlMinutes, {
-    max: 24 * 60,
-  });
-
-  switch (status) {
-    case 'open': {
-      const currentStatus = String(threadInstance.fields.status);
-      if (currentStatus === 'done' || currentStatus === 'cancelled') {
-        return thread.reopen(workspacePath, threadInstance.path, actor, reason);
-      }
-      return thread.release(workspacePath, threadInstance.path, actor, reason);
-    }
-    case 'active': {
-      const currentStatus = String(threadInstance.fields.status);
-      if (currentStatus === 'blocked') {
-        return thread.unblock(workspacePath, threadInstance.path, actor);
-      }
-      return thread.claim(workspacePath, threadInstance.path, actor, {
-        leaseTtlMinutes,
-      });
-    }
-    case 'blocked':
-      return thread.block(workspacePath, threadInstance.path, actor, blockedBy, reason);
-    case 'done':
-      return thread.done(workspacePath, threadInstance.path, actor, output);
-    case 'cancelled':
-      return thread.cancel(workspacePath, threadInstance.path, actor, reason);
-  }
-}
-
-function resolveThreadInstance(workspacePath: string, rawThreadId: string): PrimitiveInstance | null {
-  const resolvedId = safeDecodeURIComponent(rawThreadId);
-  const candidates = threadPathCandidates(resolvedId);
-  for (const candidate of candidates) {
-    const item = store.read(workspacePath, candidate);
-    if (item && item.type === 'thread') {
-      return item;
-    }
-  }
-  return null;
-}
-
-function threadPathCandidates(raw: string): string[] {
-  const normalized = normalizeThreadPath(raw);
-  const output = new Set<string>();
-  if (normalized) output.add(normalized);
-  if (normalized && !normalized.startsWith('threads/')) {
-    output.add(normalizeThreadPath(`threads/${normalized}`));
-  }
-  return [...output].filter(Boolean);
-}
-
-function normalizeThreadPath(raw: string): string {
-  const trimmed = raw.trim().replace(/^\.\//, '');
-  if (!trimmed) return '';
-  if (trimmed.endsWith('.md')) return trimmed;
-  return `${trimmed}.md`;
-}
-
-function summarizeGoal(goal: string): string {
-  const line = goal.split('\n').map((item) => item.trim()).find(Boolean) ?? 'Untitled Thread';
-  return line.slice(0, 80);
-}
-
-function parseOptionalPositiveInt(
-  value: unknown,
-  options: { fallback?: number; max?: number } = {},
-): number | undefined {
-  const normalized = readFirstValue(value);
-  if (normalized === undefined || normalized === null || normalized === '') {
-    if (options.fallback !== undefined) return options.fallback;
-    return undefined;
-  }
-
-  const parsed = Number.parseInt(String(normalized), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`Invalid positive integer value "${String(normalized)}".`);
-  }
-  if (options.max !== undefined) {
-    return Math.min(parsed, options.max);
-  }
-  return parsed;
-}
-
-function parseOptionalPort(value: unknown): number | undefined {
-  const raw = readFirstValue(value);
-  if (raw === undefined || raw === null || raw === '') return undefined;
-  const parsed = Number.parseInt(String(raw), 10);
-  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 65535) {
-    throw new Error(`Invalid port "${String(raw)}". Expected 0..65535.`);
-  }
-  return parsed;
-}
-
-function normalizePort(value: number | undefined, fallback: number): number {
-  if (value === undefined) return fallback;
-  if (!Number.isFinite(value) || value < 0 || value > 65535) {
-    throw new Error(`Invalid port "${String(value)}". Expected 0..65535.`);
-  }
-  return Math.trunc(value);
-}
-
-function normalizeSseKeepaliveMs(value: number | undefined): number {
-  if (value === undefined) return DEFAULT_SSE_KEEPALIVE_MS;
-  if (!Number.isFinite(value) || value < 100 || value > 60_000) {
-    throw new Error(`Invalid sse keepalive "${String(value)}". Expected 100..60000 ms.`);
-  }
-  return Math.trunc(value);
-}
-
-function parseStringList(value: unknown): string[] | undefined {
-  if (value === undefined || value === null) return undefined;
-  if (Array.isArray(value)) {
-    const items = value
-      .map((item) => String(item).trim())
-      .filter(Boolean);
-    return items.length > 0 ? items : undefined;
-  }
-  const fromString = String(value)
-    .split(',')
-    .map((item) => item.trim())
-    .filter(Boolean);
-  return fromString.length > 0 ? fromString : undefined;
-}
-
-function readCsvQueryValues(
-  query: Record<string, unknown> | undefined,
-  keys: string[],
-): string[] | undefined {
-  if (!query) return undefined;
-  const values = new Set<string>();
-  for (const key of keys) {
-    const raw = query[key];
-    if (raw === undefined || raw === null) continue;
-    const normalized = parseStringList(raw);
-    if (!normalized) continue;
-    for (const item of normalized) {
-      values.add(item);
-    }
-  }
-  return values.size > 0 ? [...values] : undefined;
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  const picked = readFirstValue(value);
-  if (typeof picked !== 'string') return undefined;
-  const trimmed = picked.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function readFirstValue(value: unknown): unknown {
-  if (Array.isArray(value)) return value[0];
-  return value;
-}
-
-function isThreadStatus(value: string | undefined): value is ThreadStatus {
-  return value === 'open' || value === 'active' || value === 'blocked' || value === 'done' || value === 'cancelled';
-}
-
-function writeRouteError(res: any, error: unknown): void {
-  const message = error instanceof Error ? error.message : String(error);
-  const status = inferHttpStatus(message);
-  res.status(status).json({
-    ok: false,
-    error: message,
-  });
-}
-
-function inferHttpStatus(message: string): number {
-  if (message.includes('not found')) return 404;
-  if (message.includes('already claimed') || message.includes('owned by')) return 409;
-  if (
-    message.includes('Identity verification failed') ||
-    message.includes('Policy gate blocked') ||
-    message.includes('Credential scope blocked') ||
-    message.includes('Mutation blocked')
-  ) {
-    return 403;
-  }
-  if (
-    message.includes('Invalid') ||
-    message.includes('Missing') ||
-    message.includes('Cannot') ||
-    message.includes('Expected')
-  ) {
-    return 400;
-  }
-  return 500;
-}
-
-function toRecord(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  return value as Record<string, unknown>;
-}
-
-function safeDecodeURIComponent(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-function safeStreamWrite(res: any, chunk: string): boolean {
-  if (res.writableEnded || res.destroyed) return false;
-  try {
-    res.write(chunk);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function serveControlPlaneFile(res: any, fileName: string, contentType: string): void {
-  const root = resolveControlPlaneRoot();
-  const filePath = path.join(root, fileName);
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Control plane asset not found: ${fileName}`);
-  }
-  res.setHeader('Content-Type', contentType);
-  res.status(200).send(fs.readFileSync(filePath, 'utf-8'));
-}
-
-function resolveControlPlaneRoot(): string {
-  const cwdPath = path.resolve(process.cwd(), 'apps', 'web-control-plane');
-  if (fs.existsSync(cwdPath)) return cwdPath;
-  const workspacePath = path.resolve('/workspace/apps/web-control-plane');
-  if (fs.existsSync(workspacePath)) return workspacePath;
-  throw new Error('Unable to locate web control plane assets.');
-}
-
-function logJson(level: LogLevel, event: string, data: Record<string, unknown>): void {
-  console.log(JSON.stringify({
-    ts: new Date().toISOString(),
-    level,
-    event,
-    ...data,
-  }));
-}
-
-function buildRequestAuthContext(req: any): { credentialToken?: string; source: 'rest' } {
-  const credentialToken = readBearerToken(req?.headers?.authorization);
-  return {
-    ...(credentialToken ? { credentialToken } : {}),
-    source: 'rest',
-  };
-}
-
-function resolveMutationActor(
-  req: any,
-  workspacePath: string,
-  explicitActor: unknown,
-  defaultActor: string,
-): string {
-  const fromBody = readNonEmptyString(explicitActor);
-  if (fromBody) return fromBody;
-  const fromHeader = readNonEmptyString(req?.headers?.['x-workgraph-actor']);
-  if (fromHeader) return fromHeader;
-  const bearerToken = readBearerToken(req?.headers?.authorization);
-  if (bearerToken) {
-    const verification = auth.verifyAgentCredential(workspacePath, bearerToken, {
-      touchLastUsed: false,
-    });
-    if (verification.valid && verification.credential) {
-      return verification.credential.actor;
-    }
-  }
-  return defaultActor;
-}
-
-function readBearerToken(headerValue: unknown): string | undefined {
-  const authorization = readNonEmptyString(headerValue);
-  if (!authorization || !authorization.startsWith('Bearer ')) {
-    return undefined;
-  }
-  return readNonEmptyString(authorization.slice('Bearer '.length));
-}
diff --git a/packages/control-api/src/webhook-gateway.test.ts b/packages/control-api/src/webhook-gateway.test.ts
deleted file mode 100644
index 5dd2505..0000000
--- a/packages/control-api/src/webhook-gateway.test.ts
+++ /dev/null
@@ -1,363 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { ledger as ledgerModule, workspace as workspaceModule } from '@versatly/workgraph-kernel';
-import { startWorkgraphServer } from './server.js';
-import {
-  deleteWebhookGatewaySource,
-  listWebhookGatewayLogs,
-  listWebhookGatewaySources,
-  registerWebhookGatewaySource,
-  testWebhookGatewaySource,
-} from './webhook-gateway.js';
-
-const ledger = ledgerModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-webhook-gateway-'));
-  workspace.initWorkspace(workspacePath, {
-    createBases: false,
-    createReadme: false,
-  });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('webhook gateway source lifecycle', () => {
-  it('registers, lists, tests, and deletes sources', () => {
-    const created = registerWebhookGatewaySource(workspacePath, {
-      key: 'github-main',
-      provider: 'github',
-      secret: 'github-secret',
-      actor: 'bot-github',
-    });
-    expect(created.key).toBe('github-main');
-    expect(created.provider).toBe('github');
-    expect(created.hasSecret).toBe(true);
-
-    const listed = listWebhookGatewaySources(workspacePath);
-    expect(listed).toHaveLength(1);
-    expect(listed[0].key).toBe('github-main');
-
-    const tested = testWebhookGatewaySource(workspacePath, {
-      sourceKey: 'github-main',
-      eventType: 'webhook.github.test.ping',
-      payload: {
-        ping: true,
-      },
-    });
-    expect(tested.eventType).toBe('webhook.github.test.ping');
-    expect(tested.log.status).toBe('accepted');
-
-    const recent = ledger.recent(workspacePath, 5);
-    const gatewayLedgerEntry = recent.find((entry) => entry.target.includes('.workgraph/webhook-gateway/github-main/'));
-    expect(gatewayLedgerEntry).toBeDefined();
-    expect(gatewayLedgerEntry?.type).toBe('event');
-
-    const logs = listWebhookGatewayLogs(workspacePath, { limit: 10 });
-    expect(logs.length).toBeGreaterThan(0);
-    expect(logs[0]?.sourceKey).toBe('github-main');
-
-    const deleted = deleteWebhookGatewaySource(workspacePath, 'github-main');
-    expect(deleted).toBe(true);
-    expect(listWebhookGatewaySources(workspacePath)).toHaveLength(0);
-  });
-});
-
-describe('webhook gateway HTTP endpoint', () => {
-  it('accepts valid GitHub signatures and emits event ledger entries', async () => {
-    registerWebhookGatewaySource(workspacePath, {
-      key: 'github-main',
-      provider: 'github',
-      secret: 'github-secret',
-      actor: 'github-bot',
-    });
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const payload = JSON.stringify({
-        action: 'opened',
-        pull_request: {
-          number: 42,
-        },
-      });
-      const signature = signGithub(payload, 'github-secret');
-      const response = await fetch(`${handle.baseUrl}/webhook-gateway/github-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-github-event': 'pull_request',
-          'x-github-delivery': 'delivery-123',
-          'x-hub-signature-256': signature,
-        },
-        body: payload,
-      });
-      const body = await response.json() as Record<string, unknown>;
-
-      expect(response.status).toBe(202);
-      expect(body.accepted).toBe(true);
-      expect(body.eventType).toBe('webhook.github.pull_request');
-
-      const recent = ledger.recent(workspacePath, 10);
-      const entry = recent.find((item) => item.target.includes('.workgraph/webhook-gateway/github-main/delivery-123'));
-      expect(entry).toBeDefined();
-      expect(entry?.data?.event_type).toBe('webhook.github.pull_request');
-
-      const logs = listWebhookGatewayLogs(workspacePath, { limit: 1 });
-      expect(logs[0]?.status).toBe('accepted');
-      expect(logs[0]?.signatureVerified).toBe(true);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('deduplicates GitHub webhook retries by delivery id', async () => {
-    registerWebhookGatewaySource(workspacePath, {
-      key: 'github-main',
-      provider: 'github',
-      secret: 'github-secret',
-      actor: 'github-bot',
-    });
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const payload = JSON.stringify({
-        action: 'synchronize',
-        pull_request: {
-          number: 42,
-        },
-      });
-      const signature = signGithub(payload, 'github-secret');
-      const first = await fetch(`${handle.baseUrl}/webhook-gateway/github-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-github-event': 'pull_request',
-          'x-github-delivery': 'delivery-dup-1',
-          'x-hub-signature-256': signature,
-        },
-        body: payload,
-      });
-      const firstBody = await first.json() as Record<string, unknown>;
-      expect(first.status).toBe(202);
-      expect(firstBody.accepted).toBe(true);
-
-      const second = await fetch(`${handle.baseUrl}/webhook-gateway/github-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-github-event': 'pull_request',
-          'x-github-delivery': 'delivery-dup-1',
-          'x-hub-signature-256': signature,
-        },
-        body: payload,
-      });
-      const secondBody = await second.json() as Record<string, unknown>;
-      expect(second.status).toBe(200);
-      expect(secondBody.accepted).toBe(false);
-      expect(secondBody.reason).toBe('duplicate');
-      expect(secondBody.duplicateBy).toBe('deliveryId');
-
-      const recent = ledger.recent(workspacePath, 20);
-      const gatewayEntries = recent.filter((entry) => entry.target.includes('.workgraph/webhook-gateway/github-main/delivery-dup-1'));
-      expect(gatewayEntries).toHaveLength(1);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('deduplicates GitHub webhook retries by payload digest', async () => {
-    registerWebhookGatewaySource(workspacePath, {
-      key: 'github-main',
-      provider: 'github',
-      secret: 'github-secret',
-      actor: 'github-bot',
-    });
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const payload = JSON.stringify({
-        action: 'opened',
-        issue: {
-          number: 77,
-        },
-      });
-      const signature = signGithub(payload, 'github-secret');
-      const first = await fetch(`${handle.baseUrl}/webhook-gateway/github-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-github-event': 'issues',
-          'x-github-delivery': 'delivery-digest-1',
-          'x-hub-signature-256': signature,
-        },
-        body: payload,
-      });
-      expect(first.status).toBe(202);
-
-      const second = await fetch(`${handle.baseUrl}/webhook-gateway/github-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-github-event': 'issues',
-          'x-github-delivery': 'delivery-digest-2',
-          'x-hub-signature-256': signature,
-        },
-        body: payload,
-      });
-      const secondBody = await second.json() as Record<string, unknown>;
-      expect(second.status).toBe(200);
-      expect(secondBody.accepted).toBe(false);
-      expect(secondBody.reason).toBe('duplicate');
-      expect(secondBody.duplicateBy).toBe('payloadDigest');
-
-      const recent = ledger.recent(workspacePath, 20);
-      const gatewayEntries = recent.filter((entry) => entry.target.includes('.workgraph/webhook-gateway/github-main/'));
-      expect(gatewayEntries).toHaveLength(1);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('rejects invalid GitHub signatures', async () => {
-    registerWebhookGatewaySource(workspacePath, {
-      key: 'github-main',
-      provider: 'github',
-      secret: 'github-secret',
-    });
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const payload = JSON.stringify({
-        action: 'created',
-      });
-      const response = await fetch(`${handle.baseUrl}/webhook-gateway/github-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-github-event': 'issue_comment',
-          'x-hub-signature-256': 'sha256=deadbeef',
-        },
-        body: payload,
-      });
-      const body = await response.json() as Record<string, unknown>;
-      expect(response.status).toBe(401);
-      expect(String(body.error)).toContain('GitHub signature verification failed');
-
-      const logs = listWebhookGatewayLogs(workspacePath, { limit: 1 });
-      expect(logs[0]?.status).toBe('rejected');
-      expect(logs[0]?.statusCode).toBe(401);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('rejects stale Slack timestamps even with valid signature', async () => {
-    registerWebhookGatewaySource(workspacePath, {
-      key: 'slack-main',
-      provider: 'slack',
-      secret: 'slack-secret',
-    });
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const payload = JSON.stringify({
-        type: 'event_callback',
-        event: {
-          type: 'message',
-        },
-      });
-      const staleTimestamp = String(Math.floor(Date.now() / 1_000) - 60 * 10);
-      const signature = signSlack(payload, 'slack-secret', staleTimestamp);
-      const response = await fetch(`${handle.baseUrl}/webhook-gateway/slack-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-slack-request-timestamp': staleTimestamp,
-          'x-slack-signature': signature,
-        },
-        body: payload,
-      });
-      const body = await response.json() as Record<string, unknown>;
-      expect(response.status).toBe(401);
-      expect(String(body.error)).toContain('outside the accepted time window');
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('accepts unsigned generic source when no secret is configured', async () => {
-    registerWebhookGatewaySource(workspacePath, {
-      key: 'generic-main',
-      provider: 'generic',
-    });
-
-    const handle = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-    try {
-      const payload = JSON.stringify({
-        type: 'deploy.completed',
-        env: 'prod',
-      });
-      const response = await fetch(`${handle.baseUrl}/webhook-gateway/generic-main`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-webhook-event': 'deploy.completed',
-          'x-request-id': 'req-123',
-        },
-        body: payload,
-      });
-      const body = await response.json() as Record<string, unknown>;
-      expect(response.status).toBe(202);
-      expect(body.eventType).toBe('webhook.generic.deploy.completed');
-
-      const logs = listWebhookGatewayLogs(workspacePath, { limit: 1 });
-      expect(logs[0]?.status).toBe('accepted');
-      expect(logs[0]?.signatureVerified).toBe(false);
-    } finally {
-      await handle.close();
-    }
-  });
-});
-
-function signGithub(rawBody: string, secret: string): string {
-  const digest = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
-  return `sha256=${digest}`;
-}
-
-function signSlack(rawBody: string, secret: string, timestamp: string): string {
-  const base = `v0:${timestamp}:${rawBody}`;
-  const digest = crypto.createHmac('sha256', secret).update(base).digest('hex');
-  return `v0=${digest}`;
-}
diff --git a/packages/control-api/src/webhook-gateway.ts b/packages/control-api/src/webhook-gateway.ts
deleted file mode 100644
index abee9e7..0000000
--- a/packages/control-api/src/webhook-gateway.ts
+++ /dev/null
@@ -1,1177 +0,0 @@
-import crypto, { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import {
-  ledger as ledgerModule,
-  transport as transportModule,
-} from '@versatly/workgraph-kernel';
-
-const ledger = ledgerModule;
-const transport = transportModule;
-
-const WEBHOOK_GATEWAY_STORE_PATH = '.workgraph/webhook-gateway-sources.json';
-const WEBHOOK_GATEWAY_LOG_PATH = '.workgraph/webhook-gateway.log.jsonl';
-const WEBHOOK_GATEWAY_STORE_VERSION = 1;
-const DEFAULT_LOG_LIMIT = 50;
-const MAX_LOG_LIMIT = 1_000;
-const MAX_WEBHOOK_BODY_BYTES = 2 * 1024 * 1024;
-const SLACK_SIGNATURE_MAX_AGE_SECONDS = 60 * 5;
-const WEBHOOK_DEDUP_TTL_MS = 5 * 60_000;
-const WEBHOOK_DEDUP_MAX_ENTRIES = 1_000;
-
-const recentWebhookDedup = new Map<string, number>();
-
-export type WebhookGatewayProvider = 'github' | 'linear' | 'slack' | 'generic';
-type LogStatus = 'accepted' | 'rejected';
-
-interface WebhookGatewayStoreFile {
-  version: number;
-  sources: StoredWebhookGatewaySource[];
-}
-
-interface StoredWebhookGatewaySource {
-  id: string;
-  key: string;
-  provider: WebhookGatewayProvider;
-  createdAt: string;
-  enabled: boolean;
-  secret?: string;
-  actor?: string;
-  eventPrefix?: string;
-}
-
-interface SignatureVerificationResult {
-  ok: boolean;
-  verified: boolean;
-  message: string;
-}
-
-export interface RegisterWebhookGatewaySourceInput {
-  key: string;
-  provider: WebhookGatewayProvider;
-  secret?: string;
-  actor?: string;
-  eventPrefix?: string;
-  enabled?: boolean;
-}
-
-export interface WebhookGatewaySourceView {
-  id: string;
-  key: string;
-  provider: WebhookGatewayProvider;
-  createdAt: string;
-  enabled: boolean;
-  hasSecret: boolean;
-  actor?: string;
-  eventPrefix?: string;
-}
-
-export interface WebhookGatewayLogEntry {
-  id: string;
-  ts: string;
-  sourceKey: string;
-  provider: WebhookGatewayProvider;
-  eventType: string;
-  actor: string;
-  status: LogStatus;
-  statusCode: number;
-  signatureVerified: boolean;
-  message: string;
-  deliveryId?: string;
-  payloadDigest: string;
-}
-
-export interface TestWebhookGatewaySourceInput {
-  sourceKey: string;
-  eventType?: string;
-  payload?: unknown;
-  deliveryId?: string;
-}
-
-export interface TestWebhookGatewaySourceResult {
-  eventType: string;
-  deliveryId: string;
-  source: WebhookGatewaySourceView;
-  log: WebhookGatewayLogEntry;
-}
-
-interface AdaptedWebhookPayload {
-  eventType: string;
-  deliveryId: string;
-  payload: unknown;
-}
-
-export function registerWebhookGatewaySource(
-  workspacePath: string,
-  input: RegisterWebhookGatewaySourceInput,
-): WebhookGatewaySourceView {
-  const key = normalizeSourceKey(input.key);
-  const provider = normalizeProvider(input.provider);
-  if (!provider) {
-    throw new Error(`Invalid webhook gateway provider "${String(input.provider)}". Expected github|linear|slack|generic.`);
-  }
-  const secret = readOptionalString(input.secret);
-  const actor = readOptionalString(input.actor);
-  const eventPrefix = readOptionalString(input.eventPrefix);
-  const enabled = input.enabled !== false;
-
-  const store = readWebhookGatewayStore(workspacePath);
-  const existing = store.sources.find((source) => source.key === key);
-  if (existing) {
-    throw new Error(`Webhook gateway source already exists: ${key}`);
-  }
-
-  const source: StoredWebhookGatewaySource = {
-    id: randomUUID(),
-    key,
-    provider,
-    createdAt: new Date().toISOString(),
-    enabled,
-    ...(secret ? { secret } : {}),
-    ...(actor ? { actor } : {}),
-    ...(eventPrefix ? { eventPrefix } : {}),
-  };
-  store.sources.push(source);
-  writeWebhookGatewayStore(workspacePath, store);
-  return toWebhookGatewaySourceView(source);
-}
-
-export function listWebhookGatewaySources(workspacePath: string): WebhookGatewaySourceView[] {
-  const store = readWebhookGatewayStore(workspacePath);
-  return store.sources
-    .slice()
-    .sort((left, right) => left.key.localeCompare(right.key))
-    .map(toWebhookGatewaySourceView);
-}
-
-export function deleteWebhookGatewaySource(workspacePath: string, keyOrId: string): boolean {
-  const normalized = String(keyOrId ?? '').trim();
-  if (!normalized) return false;
-
-  const store = readWebhookGatewayStore(workspacePath);
-  const before = store.sources.length;
-  store.sources = store.sources.filter((source) => source.key !== normalized && source.id !== normalized);
-  if (before === store.sources.length) return false;
-  writeWebhookGatewayStore(workspacePath, store);
-  return true;
-}
-
-export function listWebhookGatewayLogs(
-  workspacePath: string,
-  options: {
-    limit?: number;
-    sourceKey?: string;
-  } = {},
-): WebhookGatewayLogEntry[] {
-  const filePath = webhookGatewayLogPath(workspacePath);
-  if (!fs.existsSync(filePath)) return [];
-  const limit = normalizeLogLimit(options.limit);
-  const sourceKey = readOptionalString(options.sourceKey);
-
-  const lines = fs.readFileSync(filePath, 'utf-8')
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean);
-  const parsed: WebhookGatewayLogEntry[] = [];
-  for (let idx = lines.length - 1; idx >= 0; idx -= 1) {
-    const line = lines[idx];
-    let candidate: unknown;
-    try {
-      candidate = JSON.parse(line) as unknown;
-    } catch {
-      continue;
-    }
-    const log = sanitizeWebhookGatewayLogEntry(candidate);
-    if (!log) continue;
-    if (sourceKey && log.sourceKey !== sourceKey) continue;
-    parsed.push(log);
-    if (parsed.length >= limit) break;
-  }
-  return parsed;
-}
-
-export function testWebhookGatewaySource(
-  workspacePath: string,
-  input: TestWebhookGatewaySourceInput,
-): TestWebhookGatewaySourceResult {
-  const source = resolveSourceByKeyOrId(workspacePath, input.sourceKey);
-  if (!source) {
-    throw new Error(`Webhook gateway source not found: ${input.sourceKey}`);
-  }
-  const now = new Date().toISOString();
-  const deliveryId = normalizeDeliveryId(input.deliveryId) ?? `test-${Date.now()}`;
-  const eventType = normalizeEventType(
-    input.eventType
-      ?? `webhook.${source.eventPrefix ?? source.provider}.test`,
-  );
-  const payload = input.payload ?? {
-    source: source.key,
-    provider: source.provider,
-    mode: 'test',
-    ts: now,
-  };
-  const payloadText = stringifyPayload(payload);
-  const payloadDigest = sha256Hex(payloadText);
-  const actor = source.actor ?? `webhook:${source.key}`;
-  appendWebhookGatewayLedgerEvent(workspacePath, source, {
-    eventType,
-    deliveryId,
-    payload,
-    payloadDigest,
-    actor,
-  });
-
-  const log: WebhookGatewayLogEntry = {
-    id: randomUUID(),
-    ts: now,
-    sourceKey: source.key,
-    provider: source.provider,
-    eventType,
-    actor,
-    status: 'accepted',
-    statusCode: 202,
-    signatureVerified: false,
-    message: 'Synthetic webhook gateway test event accepted.',
-    deliveryId,
-    payloadDigest,
-  };
-  appendWebhookGatewayLog(workspacePath, log);
-  return {
-    eventType,
-    deliveryId,
-    source: toWebhookGatewaySourceView(source),
-    log,
-  };
-}
-
-export function registerWebhookGatewayEndpoint(app: any, workspacePath: string): void {
-  app.post('/webhook-gateway/:sourceKey', async (req: any, res: any) => {
-    const sourceKey = readOptionalString(req.params?.sourceKey);
-    if (!sourceKey) {
-      writeWebhookGatewayHttpResponse(res, 400, {
-        ok: false,
-        error: 'Webhook source key is required.',
-      });
-      return;
-    }
-
-    try {
-      const source = resolveSourceByKeyOrId(workspacePath, sourceKey);
-      if (!source) {
-        const log = createRejectedGatewayLog({
-          sourceKey,
-          provider: 'generic',
-          eventType: 'webhook.unknown',
-          actor: `webhook:${sourceKey}`,
-          statusCode: 404,
-          signatureVerified: false,
-          message: `Webhook gateway source not found: ${sourceKey}`,
-          payloadDigest: sha256Hex(''),
-        });
-        appendWebhookGatewayLog(workspacePath, log);
-        writeWebhookGatewayHttpResponse(res, 404, {
-          ok: false,
-          error: `Webhook gateway source not found: ${sourceKey}`,
-        });
-        return;
-      }
-      if (!source.enabled) {
-        const log = createRejectedGatewayLog({
-          sourceKey: source.key,
-          provider: source.provider,
-          eventType: `webhook.${source.eventPrefix ?? source.provider}.disabled`,
-          actor: source.actor ?? `webhook:${source.key}`,
-          statusCode: 403,
-          signatureVerified: false,
-          message: `Webhook gateway source is disabled: ${source.key}`,
-          payloadDigest: sha256Hex(''),
-        });
-        appendWebhookGatewayLog(workspacePath, log);
-        writeWebhookGatewayHttpResponse(res, 403, {
-          ok: false,
-          error: `Webhook gateway source is disabled: ${source.key}`,
-        });
-        return;
-      }
-
-      const body = await resolveWebhookBody(req);
-      const verification = verifyWebhookSignature(source, req.headers, body.rawBody);
-      if (!verification.ok) {
-        const adaptedForReject = adaptWebhookPayload(source, req.headers, body.jsonBody, body.rawBody);
-        const log = createRejectedGatewayLog({
-          sourceKey: source.key,
-          provider: source.provider,
-          eventType: adaptedForReject.eventType,
-          actor: source.actor ?? `webhook:${source.key}`,
-          statusCode: 401,
-          signatureVerified: verification.verified,
-          message: verification.message,
-          deliveryId: adaptedForReject.deliveryId,
-          payloadDigest: sha256Hex(body.rawBody),
-        });
-        appendWebhookGatewayLog(workspacePath, log);
-        writeWebhookGatewayHttpResponse(res, 401, {
-          ok: false,
-          error: verification.message,
-        });
-        return;
-      }
-
-      const adapted = adaptWebhookPayload(source, req.headers, body.jsonBody, body.rawBody);
-      const payloadDigest = sha256Hex(body.rawBody);
-      const actor = source.actor ?? `webhook:${source.key}`;
-      const dedupKeys = [
-        `${source.key}:delivery:${adapted.deliveryId}`,
-        `${source.key}:payload:${payloadDigest}`,
-      ];
-
-      if (source.provider === 'slack' && isSlackChallengePayload(body.jsonBody)) {
-        const challenge = String((body.jsonBody as Record<string, unknown>).challenge ?? '');
-        const acceptedLog: WebhookGatewayLogEntry = {
-          id: randomUUID(),
-          ts: new Date().toISOString(),
-          sourceKey: source.key,
-          provider: source.provider,
-          eventType: adapted.eventType,
-          actor,
-          status: 'accepted',
-          statusCode: 200,
-          signatureVerified: verification.verified,
-          message: 'Slack URL verification challenge accepted.',
-          deliveryId: adapted.deliveryId,
-          payloadDigest,
-        };
-        appendWebhookGatewayLog(workspacePath, acceptedLog);
-        writeWebhookGatewayHttpResponse(res, 200, {
-          ok: true,
-          challenge,
-          source: source.key,
-          eventType: adapted.eventType,
-        });
-        return;
-      }
-
-      const duplicateBy = detectRecentWebhookDuplicate(
-        workspacePath,
-        source.key,
-        adapted.deliveryId,
-        payloadDigest,
-      );
-      if (duplicateBy) {
-        const duplicateLog: WebhookGatewayLogEntry = {
-          id: randomUUID(),
-          ts: new Date().toISOString(),
-          sourceKey: source.key,
-          provider: source.provider,
-          eventType: adapted.eventType,
-          actor,
-          status: 'accepted',
-          statusCode: 200,
-          signatureVerified: verification.verified,
-          message: `Duplicate webhook ignored (${duplicateBy}).`,
-          deliveryId: adapted.deliveryId,
-          payloadDigest,
-        };
-        appendWebhookGatewayLog(workspacePath, duplicateLog);
-        writeWebhookGatewayHttpResponse(res, 200, {
-          ok: true,
-          accepted: false,
-          reason: 'duplicate',
-          duplicateBy,
-          source: source.key,
-          provider: source.provider,
-          eventType: adapted.eventType,
-          deliveryId: adapted.deliveryId,
-        });
-        return;
-      }
-
-      const inboxEnvelope = transport.createTransportEnvelope({
-        direction: 'inbound',
-        channel: 'webhook-gateway',
-        topic: adapted.eventType,
-        source: `webhook-gateway:${source.key}`,
-        target: '.workgraph/webhook-gateway',
-        provider: source.provider,
-        correlationId: adapted.deliveryId,
-        dedupKeys,
-        payload: {
-          sourceKey: source.key,
-          provider: source.provider,
-          eventType: adapted.eventType,
-          deliveryId: adapted.deliveryId,
-          payload: adapted.payload,
-        },
-      });
-      const inboxResult = transport.recordTransportInbox(workspacePath, {
-        envelope: inboxEnvelope,
-        dedupKeys,
-        message: 'Accepted inbound webhook event.',
-      });
-      if (inboxResult.duplicate) {
-        const duplicateLog: WebhookGatewayLogEntry = {
-          id: randomUUID(),
-          ts: new Date().toISOString(),
-          sourceKey: source.key,
-          provider: source.provider,
-          eventType: adapted.eventType,
-          actor,
-          status: 'accepted',
-          statusCode: 200,
-          signatureVerified: verification.verified,
-          message: 'Duplicate webhook ignored (persistent inbox dedup).',
-          deliveryId: adapted.deliveryId,
-          payloadDigest,
-        };
-        appendWebhookGatewayLog(workspacePath, duplicateLog);
-        writeWebhookGatewayHttpResponse(res, 200, {
-          ok: true,
-          accepted: false,
-          reason: 'duplicate',
-          duplicateBy: 'inbox',
-          source: source.key,
-          provider: source.provider,
-          eventType: adapted.eventType,
-          deliveryId: adapted.deliveryId,
-        });
-        return;
-      }
-
-      appendWebhookGatewayLedgerEvent(workspacePath, source, {
-        eventType: adapted.eventType,
-        deliveryId: adapted.deliveryId,
-        payload: adapted.payload,
-        payloadDigest,
-        actor,
-      });
-      const acceptedLog: WebhookGatewayLogEntry = {
-        id: randomUUID(),
-        ts: new Date().toISOString(),
-        sourceKey: source.key,
-        provider: source.provider,
-        eventType: adapted.eventType,
-        actor,
-        status: 'accepted',
-        statusCode: 202,
-        signatureVerified: verification.verified,
-        message: verification.message,
-        deliveryId: adapted.deliveryId,
-        payloadDigest,
-      };
-      appendWebhookGatewayLog(workspacePath, acceptedLog);
-      writeWebhookGatewayHttpResponse(res, 202, {
-        ok: true,
-        accepted: true,
-        source: source.key,
-        provider: source.provider,
-        eventType: adapted.eventType,
-        deliveryId: adapted.deliveryId,
-      });
-    } catch (error) {
-      writeWebhookGatewayHttpResponse(res, 500, {
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  });
-}
-
-function detectRecentWebhookDuplicate(
-  workspacePath: string,
-  sourceKey: string,
-  deliveryId: string,
-  payloadDigest: string,
-): 'deliveryId' | 'payloadDigest' | null {
-  const nowMs = Date.now();
-  evictExpiredWebhookDedupEntries(nowMs);
-  const deliveryKey = `${workspacePath}|${sourceKey}|delivery|${deliveryId}`;
-  if (isWebhookDedupHit(deliveryKey, nowMs)) {
-    return 'deliveryId';
-  }
-  const payloadKey = `${workspacePath}|${sourceKey}|digest|${payloadDigest}`;
-  if (isWebhookDedupHit(payloadKey, nowMs)) {
-    return 'payloadDigest';
-  }
-  rememberWebhookDedupKey(deliveryKey, nowMs);
-  rememberWebhookDedupKey(payloadKey, nowMs);
-  return null;
-}
-
-function isWebhookDedupHit(key: string, nowMs: number): boolean {
-  const expiresAt = recentWebhookDedup.get(key);
-  if (!expiresAt) return false;
-  if (expiresAt <= nowMs) {
-    recentWebhookDedup.delete(key);
-    return false;
-  }
-  // Re-insert to refresh LRU order while keeping original expiration.
-  recentWebhookDedup.delete(key);
-  recentWebhookDedup.set(key, expiresAt);
-  return true;
-}
-
-function rememberWebhookDedupKey(key: string, nowMs: number): void {
-  recentWebhookDedup.set(key, nowMs + WEBHOOK_DEDUP_TTL_MS);
-  while (recentWebhookDedup.size > WEBHOOK_DEDUP_MAX_ENTRIES) {
-    const oldest = recentWebhookDedup.keys().next().value as string | undefined;
-    if (!oldest) break;
-    recentWebhookDedup.delete(oldest);
-  }
-}
-
-function evictExpiredWebhookDedupEntries(nowMs: number): void {
-  for (const [key, expiresAt] of recentWebhookDedup.entries()) {
-    if (expiresAt <= nowMs) {
-      recentWebhookDedup.delete(key);
-    }
-  }
-}
-
-function readWebhookGatewayStore(workspacePath: string): WebhookGatewayStoreFile {
-  const filePath = webhookGatewayStorePath(workspacePath);
-  if (!fs.existsSync(filePath)) {
-    return {
-      version: WEBHOOK_GATEWAY_STORE_VERSION,
-      sources: [],
-    };
-  }
-  try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as Partial<WebhookGatewayStoreFile>;
-    const sources = Array.isArray(parsed.sources)
-      ? parsed.sources
-        .map((entry) => sanitizeStoredSource(entry))
-        .filter((entry): entry is StoredWebhookGatewaySource => entry !== null)
-      : [];
-    return {
-      version: WEBHOOK_GATEWAY_STORE_VERSION,
-      sources,
-    };
-  } catch {
-    return {
-      version: WEBHOOK_GATEWAY_STORE_VERSION,
-      sources: [],
-    };
-  }
-}
-
-function writeWebhookGatewayStore(workspacePath: string, store: WebhookGatewayStoreFile): void {
-  const filePath = webhookGatewayStorePath(workspacePath);
-  ensureParentDirectory(filePath);
-  const serialized: WebhookGatewayStoreFile = {
-    version: WEBHOOK_GATEWAY_STORE_VERSION,
-    sources: store.sources.map((source) => ({
-      id: source.id,
-      key: source.key,
-      provider: source.provider,
-      createdAt: source.createdAt,
-      enabled: source.enabled,
-      ...(source.secret ? { secret: source.secret } : {}),
-      ...(source.actor ? { actor: source.actor } : {}),
-      ...(source.eventPrefix ? { eventPrefix: source.eventPrefix } : {}),
-    })),
-  };
-  fs.writeFileSync(filePath, `${JSON.stringify(serialized, null, 2)}\n`, 'utf-8');
-}
-
-function resolveSourceByKeyOrId(workspacePath: string, keyOrId: string): StoredWebhookGatewaySource | null {
-  const normalized = String(keyOrId ?? '').trim();
-  if (!normalized) return null;
-  const store = readWebhookGatewayStore(workspacePath);
-  return store.sources.find((source) => source.key === normalized || source.id === normalized) ?? null;
-}
-
-function verifyWebhookSignature(
-  source: StoredWebhookGatewaySource,
-  headers: Record<string, unknown>,
-  rawBody: string,
-): SignatureVerificationResult {
-  const secret = readOptionalString(source.secret);
-  if (!secret) {
-    return {
-      ok: true,
-      verified: false,
-      message: 'Accepted unsigned webhook (source has no secret configured).',
-    };
-  }
-
-  switch (source.provider) {
-    case 'github':
-      return verifyGithubSignature(headers, rawBody, secret);
-    case 'slack':
-      return verifySlackSignature(headers, rawBody, secret);
-    case 'linear':
-      return verifyLinearSignature(headers, rawBody, secret);
-    case 'generic':
-      return verifyGenericSignature(headers, rawBody, secret);
-    default:
-      return {
-        ok: false,
-        verified: false,
-        message: `Unsupported webhook gateway provider: ${source.provider}`,
-      };
-  }
-}
-
-function verifyGithubSignature(
-  headers: Record<string, unknown>,
-  rawBody: string,
-  secret: string,
-): SignatureVerificationResult {
-  const signature = readHeader(headers, 'x-hub-signature-256');
-  if (!signature) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Missing GitHub signature header: x-hub-signature-256.',
-    };
-  }
-  const expected = `sha256=${hmacSha256Hex(secret, rawBody)}`;
-  if (!safeSignaturesMatch(signature, [expected])) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'GitHub signature verification failed.',
-    };
-  }
-  return {
-    ok: true,
-    verified: true,
-    message: 'GitHub signature verified.',
-  };
-}
-
-function verifySlackSignature(
-  headers: Record<string, unknown>,
-  rawBody: string,
-  secret: string,
-): SignatureVerificationResult {
-  const signature = readHeader(headers, 'x-slack-signature');
-  const timestampRaw = readHeader(headers, 'x-slack-request-timestamp');
-  if (!signature || !timestampRaw) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Missing Slack signature headers.',
-    };
-  }
-  const timestampSeconds = Number.parseInt(timestampRaw, 10);
-  if (!Number.isFinite(timestampSeconds)) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Invalid Slack signature timestamp.',
-    };
-  }
-  const nowSeconds = Math.floor(Date.now() / 1_000);
-  if (Math.abs(nowSeconds - timestampSeconds) > SLACK_SIGNATURE_MAX_AGE_SECONDS) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Slack signature timestamp is outside the accepted time window.',
-    };
-  }
-  const base = `v0:${timestampRaw}:${rawBody}`;
-  const expected = `v0=${hmacSha256Hex(secret, base)}`;
-  if (!safeSignaturesMatch(signature, [expected])) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Slack signature verification failed.',
-    };
-  }
-  return {
-    ok: true,
-    verified: true,
-    message: 'Slack signature verified.',
-  };
-}
-
-function verifyLinearSignature(
-  headers: Record<string, unknown>,
-  rawBody: string,
-  secret: string,
-): SignatureVerificationResult {
-  const signature = readHeader(headers, 'linear-signature') ?? readHeader(headers, 'x-linear-signature');
-  if (!signature) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Missing Linear signature header.',
-    };
-  }
-  const expectedHex = hmacSha256Hex(secret, rawBody);
-  const expectedBase64 = hmacSha256Base64(secret, rawBody);
-  if (!safeSignaturesMatch(signature, [expectedHex, `sha256=${expectedHex}`, expectedBase64])) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Linear signature verification failed.',
-    };
-  }
-  return {
-    ok: true,
-    verified: true,
-    message: 'Linear signature verified.',
-  };
-}
-
-function verifyGenericSignature(
-  headers: Record<string, unknown>,
-  rawBody: string,
-  secret: string,
-): SignatureVerificationResult {
-  const signature = readHeader(headers, 'x-workgraph-signature')
-    ?? readHeader(headers, 'x-webhook-signature')
-    ?? readHeader(headers, 'x-signature');
-  if (!signature) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Missing generic webhook signature header.',
-    };
-  }
-  const expectedHex = hmacSha256Hex(secret, rawBody);
-  if (!safeSignaturesMatch(signature, [expectedHex, `sha256=${expectedHex}`])) {
-    return {
-      ok: false,
-      verified: false,
-      message: 'Generic signature verification failed.',
-    };
-  }
-  return {
-    ok: true,
-    verified: true,
-    message: 'Generic signature verified.',
-  };
-}
-
-function adaptWebhookPayload(
-  source: StoredWebhookGatewaySource,
-  headers: Record<string, unknown>,
-  jsonBody: unknown,
-  rawBody: string,
-): AdaptedWebhookPayload {
-  const fallbackDeliveryId = deriveFallbackDeliveryId(rawBody);
-  const prefix = normalizeEventPrefix(source.eventPrefix ?? source.provider);
-
-  if (source.provider === 'github') {
-    const githubEvent = readHeader(headers, 'x-github-event')
-      ?? readRecordString(jsonBody, 'action')
-      ?? 'unknown';
-    const deliveryId = readHeader(headers, 'x-github-delivery') ?? fallbackDeliveryId;
-    return {
-      eventType: normalizeEventType(`webhook.${prefix}.${normalizeEventToken(githubEvent)}`),
-      deliveryId,
-      payload: jsonBody,
-    };
-  }
-
-  if (source.provider === 'linear') {
-    const action = readRecordString(jsonBody, 'action') ?? 'unknown';
-    const entityType = readRecordString(jsonBody, 'type')
-      ?? readRecordString(jsonBody, 'entity')
-      ?? 'event';
-    const deliveryId = readHeader(headers, 'linear-delivery')
-      ?? readHeader(headers, 'x-linear-delivery')
-      ?? fallbackDeliveryId;
-    return {
-      eventType: normalizeEventType(
-        `webhook.${prefix}.${normalizeEventToken(entityType)}.${normalizeEventToken(action)}`,
-      ),
-      deliveryId,
-      payload: jsonBody,
-    };
-  }
-
-  if (source.provider === 'slack') {
-    const topLevelType = readRecordString(jsonBody, 'type') ?? 'unknown';
-    const event = readRecordValue(jsonBody, 'event');
-    const nestedEventType = readRecordString(event, 'type');
-    const deliveryId = readRecordString(jsonBody, 'event_id')
-      ?? readHeader(headers, 'x-slack-request-timestamp')
-      ?? fallbackDeliveryId;
-    const suffix = nestedEventType
-      ? `${normalizeEventToken(topLevelType)}.${normalizeEventToken(nestedEventType)}`
-      : normalizeEventToken(topLevelType);
-    return {
-      eventType: normalizeEventType(`webhook.${prefix}.${suffix}`),
-      deliveryId,
-      payload: jsonBody,
-    };
-  }
-
-  const genericEvent = readHeader(headers, 'x-webhook-event')
-    ?? readHeader(headers, 'x-event-type')
-    ?? readRecordString(jsonBody, 'event')
-    ?? readRecordString(jsonBody, 'type')
-    ?? 'received';
-  const genericDelivery = readHeader(headers, 'x-webhook-delivery')
-    ?? readHeader(headers, 'x-request-id')
-    ?? fallbackDeliveryId;
-  return {
-    eventType: normalizeEventType(`webhook.${prefix}.${normalizeEventToken(genericEvent)}`),
-    deliveryId: genericDelivery,
-    payload: jsonBody,
-  };
-}
-
-function appendWebhookGatewayLedgerEvent(
-  workspacePath: string,
-  source: StoredWebhookGatewaySource,
-  input: {
-    eventType: string;
-    deliveryId: string;
-    payload: unknown;
-    payloadDigest: string;
-    actor: string;
-  },
-): void {
-  const safeDeliveryId = normalizeDeliveryId(input.deliveryId) ?? deriveFallbackDeliveryId(input.payloadDigest);
-  const target = `.workgraph/webhook-gateway/${source.key}/${safeDeliveryId}`;
-  ledger.append(workspacePath, input.actor, 'update', target, 'event', {
-    event_type: input.eventType,
-    provider: source.provider,
-    source_key: source.key,
-    delivery_id: safeDeliveryId,
-    payload_digest: input.payloadDigest,
-    payload: input.payload,
-  });
-}
-
-function appendWebhookGatewayLog(workspacePath: string, entry: WebhookGatewayLogEntry): void {
-  const filePath = webhookGatewayLogPath(workspacePath);
-  ensureParentDirectory(filePath);
-  fs.appendFileSync(filePath, `${JSON.stringify(entry)}\n`, 'utf-8');
-}
-
-function createRejectedGatewayLog(input: {
-  sourceKey: string;
-  provider: WebhookGatewayProvider;
-  eventType: string;
-  actor: string;
-  statusCode: number;
-  signatureVerified: boolean;
-  message: string;
-  payloadDigest: string;
-  deliveryId?: string;
-}): WebhookGatewayLogEntry {
-  return {
-    id: randomUUID(),
-    ts: new Date().toISOString(),
-    sourceKey: input.sourceKey,
-    provider: input.provider,
-    eventType: normalizeEventType(input.eventType),
-    actor: input.actor,
-    status: 'rejected',
-    statusCode: input.statusCode,
-    signatureVerified: input.signatureVerified,
-    message: input.message,
-    ...(input.deliveryId ? { deliveryId: input.deliveryId } : {}),
-    payloadDigest: input.payloadDigest,
-  };
-}
-
-async function resolveWebhookBody(req: any): Promise<{ rawBody: string; jsonBody: unknown }> {
-  if (Buffer.isBuffer(req.body)) {
-    const rawBody = req.body.toString('utf-8');
-    return {
-      rawBody,
-      jsonBody: safeParseJson(rawBody),
-    };
-  }
-  if (typeof req.body === 'string') {
-    return {
-      rawBody: req.body,
-      jsonBody: safeParseJson(req.body),
-    };
-  }
-  if (req.body && typeof req.body === 'object') {
-    return {
-      rawBody: stringifyPayload(req.body),
-      jsonBody: req.body,
-    };
-  }
-  if (Buffer.isBuffer(req.rawBody)) {
-    const rawBody = req.rawBody.toString('utf-8');
-    return {
-      rawBody,
-      jsonBody: safeParseJson(rawBody),
-    };
-  }
-  if (typeof req.rawBody === 'string') {
-    return {
-      rawBody: req.rawBody,
-      jsonBody: safeParseJson(req.rawBody),
-    };
-  }
-
-  const streamBody = await readRequestBody(req);
-  return {
-    rawBody: streamBody,
-    jsonBody: safeParseJson(streamBody),
-  };
-}
-
-async function readRequestBody(req: any): Promise<string> {
-  const chunks: Buffer[] = [];
-  let totalBytes = 0;
-  await new Promise<void>((resolve, reject) => {
-    req.on('data', (chunk: Buffer | string) => {
-      const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-      totalBytes += bufferChunk.byteLength;
-      if (totalBytes > MAX_WEBHOOK_BODY_BYTES) {
-        reject(new Error(`Webhook payload exceeds ${MAX_WEBHOOK_BODY_BYTES} bytes.`));
-        return;
-      }
-      chunks.push(bufferChunk);
-    });
-    req.on('end', () => resolve());
-    req.on('error', (error: unknown) => reject(error));
-  });
-  return Buffer.concat(chunks).toString('utf-8');
-}
-
-function sanitizeStoredSource(raw: unknown): StoredWebhookGatewaySource | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const candidate = raw as Partial<StoredWebhookGatewaySource>;
-  const id = readOptionalString(candidate.id);
-  const key = readOptionalString(candidate.key);
-  const provider = normalizeProvider(candidate.provider);
-  const createdAt = readOptionalString(candidate.createdAt) ?? new Date(0).toISOString();
-  if (!id || !key || !provider) return null;
-  return {
-    id,
-    key,
-    provider,
-    createdAt,
-    enabled: candidate.enabled !== false,
-    ...(readOptionalString(candidate.secret) ? { secret: readOptionalString(candidate.secret)! } : {}),
-    ...(readOptionalString(candidate.actor) ? { actor: readOptionalString(candidate.actor)! } : {}),
-    ...(readOptionalString(candidate.eventPrefix) ? { eventPrefix: readOptionalString(candidate.eventPrefix)! } : {}),
-  };
-}
-
-function sanitizeWebhookGatewayLogEntry(raw: unknown): WebhookGatewayLogEntry | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const candidate = raw as Partial<WebhookGatewayLogEntry>;
-  const id = readOptionalString(candidate.id);
-  const ts = readOptionalString(candidate.ts);
-  const sourceKey = readOptionalString(candidate.sourceKey);
-  const provider = normalizeProvider(candidate.provider);
-  const eventType = readOptionalString(candidate.eventType);
-  const actor = readOptionalString(candidate.actor);
-  const status = candidate.status === 'accepted' || candidate.status === 'rejected'
-    ? candidate.status
-    : undefined;
-  const statusCode = Number.isFinite(Number(candidate.statusCode))
-    ? Number(candidate.statusCode)
-    : undefined;
-  const signatureVerified = Boolean(candidate.signatureVerified);
-  const message = readOptionalString(candidate.message);
-  const payloadDigest = readOptionalString(candidate.payloadDigest);
-  if (!id || !ts || !sourceKey || !provider || !eventType || !actor || !status || statusCode === undefined || !message || !payloadDigest) {
-    return null;
-  }
-  return {
-    id,
-    ts,
-    sourceKey,
-    provider,
-    eventType,
-    actor,
-    status,
-    statusCode,
-    signatureVerified,
-    message,
-    ...(readOptionalString(candidate.deliveryId) ? { deliveryId: readOptionalString(candidate.deliveryId)! } : {}),
-    payloadDigest,
-  };
-}
-
-function toWebhookGatewaySourceView(source: StoredWebhookGatewaySource): WebhookGatewaySourceView {
-  return {
-    id: source.id,
-    key: source.key,
-    provider: source.provider,
-    createdAt: source.createdAt,
-    enabled: source.enabled,
-    hasSecret: typeof source.secret === 'string' && source.secret.length > 0,
-    ...(source.actor ? { actor: source.actor } : {}),
-    ...(source.eventPrefix ? { eventPrefix: source.eventPrefix } : {}),
-  };
-}
-
-function safeSignaturesMatch(actual: string, candidates: string[]): boolean {
-  const normalizedActual = actual.trim();
-  for (const candidate of candidates) {
-    const normalizedCandidate = candidate.trim();
-    if (!normalizedCandidate) continue;
-    if (timingSafeEquals(normalizedActual, normalizedCandidate)) return true;
-  }
-  return false;
-}
-
-function timingSafeEquals(left: string, right: string): boolean {
-  const leftBuffer = Buffer.from(left);
-  const rightBuffer = Buffer.from(right);
-  if (leftBuffer.length !== rightBuffer.length) return false;
-  return crypto.timingSafeEqual(leftBuffer, rightBuffer);
-}
-
-function hmacSha256Hex(secret: string, payload: string): string {
-  return crypto.createHmac('sha256', secret).update(payload).digest('hex');
-}
-
-function hmacSha256Base64(secret: string, payload: string): string {
-  return crypto.createHmac('sha256', secret).update(payload).digest('base64');
-}
-
-function normalizeProvider(value: unknown): WebhookGatewayProvider | null {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (
-    normalized === 'github'
-    || normalized === 'linear'
-    || normalized === 'slack'
-    || normalized === 'generic'
-  ) {
-    return normalized;
-  }
-  return null;
-}
-
-function normalizeSourceKey(value: unknown): string {
-  const normalized = String(value ?? '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  if (!normalized) {
-    throw new Error('Webhook gateway source key is required.');
-  }
-  return normalized;
-}
-
-function normalizeEventPrefix(value: unknown): string {
-  const normalized = String(value ?? '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_.-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return normalized || 'generic';
-}
-
-function normalizeEventToken(value: unknown): string {
-  const normalized = String(value ?? '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_.-]+/g, '.')
-    .replace(/\.+/g, '.')
-    .replace(/^\.+|\.+$/g, '');
-  return normalized || 'unknown';
-}
-
-function normalizeEventType(value: unknown): string {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (!normalized) return 'webhook.unknown';
-  return normalized;
-}
-
-function normalizeDeliveryId(value: unknown): string | undefined {
-  const normalized = String(value ?? '')
-    .trim()
-    .replace(/[^a-zA-Z0-9._:-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return normalized || undefined;
-}
-
-function normalizeLogLimit(value: unknown): number {
-  const parsed = Number.parseInt(String(value ?? DEFAULT_LOG_LIMIT), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_LOG_LIMIT;
-  return Math.min(MAX_LOG_LIMIT, parsed);
-}
-
-function readHeader(headers: Record<string, unknown>, key: string): string | undefined {
-  const lowercaseKey = key.toLowerCase();
-  for (const [headerKey, headerValue] of Object.entries(headers ?? {})) {
-    if (headerKey.toLowerCase() !== lowercaseKey) continue;
-    if (Array.isArray(headerValue)) {
-      return readOptionalString(headerValue[0]);
-    }
-    return readOptionalString(headerValue);
-  }
-  return undefined;
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function readRecordString(value: unknown, key: string): string | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  return readOptionalString((value as Record<string, unknown>)[key]);
-}
-
-function readRecordValue(value: unknown, key: string): unknown {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  return (value as Record<string, unknown>)[key];
-}
-
-function isSlackChallengePayload(value: unknown): boolean {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const record = value as Record<string, unknown>;
-  return record.type === 'url_verification' && typeof record.challenge === 'string';
-}
-
-function safeParseJson(text: string): unknown {
-  const trimmed = text.trim();
-  if (!trimmed) return {};
-  try {
-    return JSON.parse(trimmed) as unknown;
-  } catch {
-    return {
-      raw: text,
-    };
-  }
-}
-
-function stringifyPayload(payload: unknown): string {
-  if (typeof payload === 'string') return payload;
-  try {
-    return JSON.stringify(payload);
-  } catch {
-    return '{}';
-  }
-}
-
-function deriveFallbackDeliveryId(seed: string): string {
-  return sha256Hex(seed).slice(0, 16);
-}
-
-function sha256Hex(value: string): string {
-  return crypto.createHash('sha256').update(value).digest('hex');
-}
-
-function ensureParentDirectory(filePath: string): void {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-function webhookGatewayStorePath(workspacePath: string): string {
-  return path.join(workspacePath, WEBHOOK_GATEWAY_STORE_PATH);
-}
-
-function webhookGatewayLogPath(workspacePath: string): string {
-  return path.join(workspacePath, WEBHOOK_GATEWAY_LOG_PATH);
-}
-
-function writeWebhookGatewayHttpResponse(
-  res: any,
-  status: number,
-  payload: Record<string, unknown>,
-): void {
-  res.status(status).json(payload);
-}
diff --git a/packages/control-api/tsconfig.json b/packages/control-api/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/control-api/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/kernel/package.json b/packages/kernel/package.json
index 47ec00b..ed4a93a 100644
--- a/packages/kernel/package.json
+++ b/packages/kernel/package.json
@@ -11,8 +11,5 @@
   "dependencies": {
     "gray-matter": "^4.0.3",
     "yaml": "^2.8.1"
-  },
-  "devDependencies": {
-    "@versatly/workgraph-mcp-server": "workspace:*"
   }
 }
diff --git a/packages/kernel/src/__snapshots__/context-graph-contract.test.ts.snap b/packages/kernel/src/__snapshots__/context-graph-contract.test.ts.snap
index 9c0df06..1f81ee6 100644
--- a/packages/kernel/src/__snapshots__/context-graph-contract.test.ts.snap
+++ b/packages/kernel/src/__snapshots__/context-graph-contract.test.ts.snap
@@ -3,7 +3,7 @@
 exports[`core context graph contract > enforces invariants for registry plus query/lens contracts 1`] = `
 {
   "ok": true,
-  "version": "1.1.0",
+  "version": "2.0.0",
   "violations": [],
 }
 `;
@@ -17,6 +17,7 @@ exports[`core context graph contract > locks a versioned primitive and relations
         "thread",
         "conversation",
         "plan-step",
+        "checkpoint",
       ],
     },
     {
@@ -25,28 +26,27 @@ exports[`core context graph contract > locks a versioned primitive and relations
         "thread",
         "conversation",
         "plan-step",
-        "incident",
-        "run",
+        "checkpoint",
       ],
     },
     {
       "id": "customer-health",
       "primitives": [
+        "org",
         "thread",
         "conversation",
-        "plan-step",
-        "incident",
-        "client",
+        "fact",
+        "decision",
       ],
     },
     {
       "id": "exec-brief",
       "primitives": [
+        "org",
         "thread",
         "conversation",
-        "plan-step",
         "decision",
-        "run",
+        "checkpoint",
       ],
     },
   ],
@@ -69,15 +69,6 @@ exports[`core context graph contract > locks a versioned primitive and relations
         "updated",
       ],
     },
-    {
-      "directory": "clients",
-      "name": "client",
-      "requiredFields": [
-        "name",
-        "created",
-        "updated",
-      ],
-    },
     {
       "directory": "conversations",
       "name": "conversation",
@@ -108,41 +99,14 @@ exports[`core context graph contract > locks a versioned primitive and relations
       ],
     },
     {
-      "directory": "incidents",
-      "name": "incident",
+      "directory": "orgs",
+      "name": "org",
       "requiredFields": [
         "title",
         "created",
         "updated",
       ],
     },
-    {
-      "directory": "lessons",
-      "name": "lesson",
-      "requiredFields": [
-        "title",
-        "date",
-      ],
-    },
-    {
-      "directory": "onboarding",
-      "name": "onboarding",
-      "requiredFields": [
-        "title",
-        "actor",
-        "created",
-        "updated",
-      ],
-    },
-    {
-      "directory": "people",
-      "name": "person",
-      "requiredFields": [
-        "name",
-        "created",
-        "updated",
-      ],
-    },
     {
       "directory": "plan-steps",
       "name": "plan-step",
@@ -163,38 +127,6 @@ exports[`core context graph contract > locks a versioned primitive and relations
         "updated",
       ],
     },
-    {
-      "directory": "projects",
-      "name": "project",
-      "requiredFields": [
-        "title",
-        "created",
-        "updated",
-      ],
-    },
-    {
-      "directory": "runs",
-      "name": "run",
-      "requiredFields": [
-        "title",
-        "objective",
-        "runtime",
-        "status",
-        "run_id",
-        "created",
-        "updated",
-      ],
-    },
-    {
-      "directory": "skills",
-      "name": "skill",
-      "requiredFields": [
-        "title",
-        "status",
-        "created",
-        "updated",
-      ],
-    },
     {
       "directory": "spaces",
       "name": "space",
@@ -215,16 +147,6 @@ exports[`core context graph contract > locks a versioned primitive and relations
         "updated",
       ],
     },
-    {
-      "directory": "triggers",
-      "name": "trigger",
-      "requiredFields": [
-        "title",
-        "action",
-        "created",
-        "updated",
-      ],
-    },
   ],
   "query": {
     "filterKeys": [
@@ -362,20 +284,13 @@ exports[`core context graph contract > locks a versioned primitive and relations
       "to": [
         "thread",
         "space",
-        "project",
-        "client",
         "conversation",
         "plan-step",
         "decision",
-        "lesson",
         "fact",
-        "incident",
         "policy",
-        "skill",
         "checkpoint",
-        "onboarding",
-        "run",
-        "trigger",
+        "org",
       ],
     },
     {
@@ -384,53 +299,13 @@ exports[`core context graph contract > locks a versioned primitive and relations
         "ref",
       ],
       "expectedRefTypes": [
-        "client",
-      ],
-      "field": "client",
-      "from": "project",
-      "id": "project.client",
-      "to": [
-        "client",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "member_refs",
-      "from": "project",
-      "id": "project.member_refs",
-      "to": [
-        "person",
-        "agent",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "thread_refs",
-      "from": "project",
-      "id": "project.thread_refs",
-      "to": [
-        "thread",
-      ],
-    },
-    {
-      "cardinality": "one",
-      "expectedFieldTypes": [
-        "ref",
-      ],
-      "expectedRefTypes": [
-        "client",
+        "decision",
       ],
-      "field": "client",
-      "from": "person",
-      "id": "person.client",
+      "field": "supersedes",
+      "from": "decision",
+      "id": "decision.supersedes",
       "to": [
-        "client",
+        "decision",
       ],
     },
     {
@@ -438,116 +313,19 @@ exports[`core context graph contract > locks a versioned primitive and relations
       "expectedFieldTypes": [
         "ref",
       ],
-      "expectedRefTypes": [
-        "person",
-      ],
-      "field": "contact_ref",
-      "from": "client",
-      "id": "client.contact_ref",
-      "to": [
-        "person",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "project_refs",
-      "from": "client",
-      "id": "client.project_refs",
-      "to": [
-        "project",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "context_refs",
-      "from": "decision",
-      "id": "decision.context_refs",
-      "to": [
-        "thread",
-        "project",
-        "client",
-        "conversation",
-        "plan-step",
-        "fact",
-        "lesson",
-        "incident",
-        "policy",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "context_refs",
-      "from": "lesson",
-      "id": "lesson.context_refs",
+      "field": "source",
+      "from": "fact",
+      "id": "fact.source",
       "to": [
         "thread",
-        "project",
-        "client",
         "conversation",
         "plan-step",
         "decision",
-        "fact",
-        "incident",
-      ],
-    },
-    {
-      "cardinality": "one",
-      "expectedFieldTypes": [
-        "ref",
-      ],
-      "field": "proposal_thread",
-      "from": "skill",
-      "id": "skill.proposal_thread",
-      "to": [
-        "thread",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "depends_on",
-      "from": "skill",
-      "id": "skill.depends_on",
-      "to": [
-        "skill",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "thread_refs",
-      "from": "onboarding",
-      "id": "onboarding.thread_refs",
-      "to": [
-        "thread",
-      ],
-    },
-    {
-      "cardinality": "many",
-      "expectedFieldTypes": [
-        "list",
-      ],
-      "field": "spaces",
-      "from": "onboarding",
-      "id": "onboarding.spaces",
-      "to": [
-        "space",
+        "checkpoint",
+        "org",
       ],
     },
   ],
-  "version": "1.1.0",
+  "version": "2.0.0",
 }
 `;
diff --git a/packages/kernel/src/adapter-claude-code.test.ts b/packages/kernel/src/adapter-claude-code.test.ts
deleted file mode 100644
index fe639b2..0000000
--- a/packages/kernel/src/adapter-claude-code.test.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { ClaudeCodeAdapter } from './adapter-claude-code.js';
-import { ShellWorkerAdapter } from './adapter-shell-worker.js';
-import type { DispatchAdapterExecutionInput, DispatchAdapterExecutionResult } from './runtime-adapter-contracts.js';
-
-const ENV_KEYS = ['WORKGRAPH_CLAUDE_COMMAND_TEMPLATE', 'WORKGRAPH_CLAUDE_TIMEOUT_MS'] as const;
-
-function makeInput(overrides: Partial<DispatchAdapterExecutionInput> = {}): DispatchAdapterExecutionInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run-123',
-    actor: 'agent-a',
-    objective: "Fix user's parser reliability issue",
-    ...overrides,
-  };
-}
-
-describe('ClaudeCodeAdapter', () => {
-  const envSnapshot: Record<string, string | undefined> = {};
-
-  beforeEach(() => {
-    for (const key of ENV_KEYS) {
-      envSnapshot[key] = process.env[key];
-      delete process.env[key];
-    }
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    for (const key of ENV_KEYS) {
-      if (envSnapshot[key] === undefined) {
-        delete process.env[key];
-      } else {
-        process.env[key] = envSnapshot[key];
-      }
-    }
-  });
-
-  it('delegates lifecycle methods to the shell worker adapter', async () => {
-    const createSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'create').mockResolvedValue({
-      runId: 'run-create',
-      status: 'queued',
-    });
-    const statusSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'status').mockResolvedValue({
-      runId: 'run-status',
-      status: 'running',
-    });
-    const followupSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'followup').mockResolvedValue({
-      runId: 'run-followup',
-      status: 'running',
-    });
-    const stopSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'stop').mockResolvedValue({
-      runId: 'run-stop',
-      status: 'cancelled',
-    });
-    const logsSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'logs').mockResolvedValue([
-      {
-        ts: '2026-01-01T00:00:00.000Z',
-        level: 'info',
-        message: 'mock log entry',
-      },
-    ]);
-
-    const adapter = new ClaudeCodeAdapter();
-    await expect(adapter.create({ actor: 'agent-a', objective: 'create run' })).resolves.toEqual({
-      runId: 'run-create',
-      status: 'queued',
-    });
-    await expect(adapter.status('run-status')).resolves.toEqual({
-      runId: 'run-status',
-      status: 'running',
-    });
-    await expect(adapter.followup('run-followup', 'agent-a', 'continue')).resolves.toEqual({
-      runId: 'run-followup',
-      status: 'running',
-    });
-    await expect(adapter.stop('run-stop', 'agent-a')).resolves.toEqual({
-      runId: 'run-stop',
-      status: 'cancelled',
-    });
-    await expect(adapter.logs('run-logs')).resolves.toEqual([
-      {
-        ts: '2026-01-01T00:00:00.000Z',
-        level: 'info',
-        message: 'mock log entry',
-      },
-    ]);
-
-    expect(createSpy).toHaveBeenCalledWith({ actor: 'agent-a', objective: 'create run' });
-    expect(statusSpy).toHaveBeenCalledWith('run-status');
-    expect(followupSpy).toHaveBeenCalledWith('run-followup', 'agent-a', 'continue');
-    expect(stopSpy).toHaveBeenCalledWith('run-stop', 'agent-a');
-    expect(logsSpy).toHaveBeenCalledWith('run-logs');
-  });
-
-  it('fails fast when no command template is configured', async () => {
-    const executeSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'execute');
-    const adapter = new ClaudeCodeAdapter();
-
-    const result = await adapter.execute(makeInput());
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('requires a command template');
-    expect(result.logs[0]?.level).toBe('error');
-    expect(executeSpy).not.toHaveBeenCalled();
-  });
-
-  it('renders template values and augments shell-worker output', async () => {
-    process.env.WORKGRAPH_CLAUDE_TIMEOUT_MS = '4567';
-    const shellWorkerResult: DispatchAdapterExecutionResult = {
-      status: 'succeeded',
-      output: 'shell worker output',
-      logs: [
-        {
-          ts: '2026-01-02T00:00:00.000Z',
-          level: 'info',
-          message: 'shell worker complete',
-        },
-      ],
-      metrics: {
-        existingMetric: true,
-      },
-    };
-    const executeSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'execute').mockResolvedValue(shellWorkerResult);
-
-    const adapter = new ClaudeCodeAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          claude_command_template:
-            'runner --workspace {workspace} --run {run_id} --actor {actor} --objective "{objective}" --prompt-shell {prompt_shell} --prompt "{prompt}"',
-          claude_instructions: 'Focus on maintainability and explicit tests.',
-          shell_cwd: '   /tmp/workgraph-shell   ',
-        },
-      }),
-    );
-
-    expect(executeSpy).toHaveBeenCalledTimes(1);
-    const shellInput = executeSpy.mock.calls[0][0];
-    const command = String(shellInput.context?.shell_command ?? '');
-    expect(command).toContain('--workspace /workspace/demo');
-    expect(command).toContain('--run run-123');
-    expect(command).toContain('--actor agent-a');
-    expect(command).toContain('--objective "Fix user\'s parser reliability issue"');
-    expect(command).toContain('Workgraph run id: run-123');
-    expect(command).toContain('Instructions: Focus on maintainability and explicit tests.');
-    expect(command).toContain("'\\''");
-    expect(command).not.toContain('{run_id}');
-    expect(shellInput.context?.shell_cwd).toBe('/tmp/workgraph-shell');
-    expect(shellInput.context?.shell_timeout_ms).toBe('4567');
-
-    expect(result.status).toBe('succeeded');
-    expect(result.logs[0]?.message).toContain('dispatched shell execution');
-    expect(result.logs).toHaveLength(2);
-    expect(result.metrics).toMatchObject({
-      existingMetric: true,
-      adapter: 'claude-code',
-    });
-  });
-
-  it('uses command template from environment when context template is missing', async () => {
-    process.env.WORKGRAPH_CLAUDE_COMMAND_TEMPLATE = 'echo {actor}:{run_id}:{workspace}';
-    const executeSpy = vi.spyOn(ShellWorkerAdapter.prototype, 'execute').mockResolvedValue({
-      status: 'succeeded',
-      output: 'ok',
-      logs: [],
-    });
-    const adapter = new ClaudeCodeAdapter();
-
-    await adapter.execute(makeInput());
-
-    const shellInput = executeSpy.mock.calls[0][0];
-    expect(String(shellInput.context?.shell_command)).toContain('echo agent-a:run-123:/workspace/demo');
-  });
-});
diff --git a/packages/kernel/src/adapter-claude-code.ts b/packages/kernel/src/adapter-claude-code.ts
deleted file mode 100644
index 3c43ba0..0000000
--- a/packages/kernel/src/adapter-claude-code.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { ClaudeCodeAdapter } from '../../adapter-claude-code/src/adapter.js';
diff --git a/packages/kernel/src/adapter-cursor-cloud.ts b/packages/kernel/src/adapter-cursor-cloud.ts
deleted file mode 100644
index bae00c2..0000000
--- a/packages/kernel/src/adapter-cursor-cloud.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { CursorCloudAdapter } from '../../adapter-cursor-cloud/src/adapter.js';
diff --git a/packages/kernel/src/adapter-http-webhook.test.ts b/packages/kernel/src/adapter-http-webhook.test.ts
deleted file mode 100644
index 0acd371..0000000
--- a/packages/kernel/src/adapter-http-webhook.test.ts
+++ /dev/null
@@ -1,289 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { HttpWebhookAdapter } from './adapter-http-webhook.js';
-import type { DispatchAdapterExecutionInput } from './runtime-adapter-contracts.js';
-
-const ENV_KEYS = [
-  'WORKGRAPH_DISPATCH_WEBHOOK_URL',
-  'WORKGRAPH_DISPATCH_WEBHOOK_TOKEN',
-  'WORKGRAPH_DISPATCH_WEBHOOK_STATUS_URL',
-] as const;
-
-function makeInput(overrides: Partial<DispatchAdapterExecutionInput> = {}): DispatchAdapterExecutionInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run-webhook-1',
-    actor: 'agent-webhook',
-    objective: 'Test webhook adapter',
-    context: {},
-    ...overrides,
-  };
-}
-
-function mockResponse(options: { ok: boolean; status: number; text: string; statusText?: string }): Response {
-  return {
-    ok: options.ok,
-    status: options.status,
-    statusText: options.statusText ?? '',
-    text: async () => options.text,
-  } as Response;
-}
-
-describe('HttpWebhookAdapter', () => {
-  const envSnapshot: Record<string, string | undefined> = {};
-  const fetchMock = vi.fn();
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-    for (const key of ENV_KEYS) {
-      envSnapshot[key] = process.env[key];
-      delete process.env[key];
-    }
-    fetchMock.mockReset();
-    vi.stubGlobal('fetch', fetchMock);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-    for (const key of ENV_KEYS) {
-      if (envSnapshot[key] === undefined) {
-        delete process.env[key];
-      } else {
-        process.env[key] = envSnapshot[key];
-      }
-    }
-  });
-
-  it('returns failed when webhook URL is missing', async () => {
-    const adapter = new HttpWebhookAdapter();
-    const result = await adapter.execute(makeInput());
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('requires context.webhook_url');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('posts payload with headers and returns immediate terminal response', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: true,
-        status: 200,
-        text: JSON.stringify({
-          status: 'succeeded',
-          output: 'remote success',
-        }),
-      }),
-    );
-    const adapter = new HttpWebhookAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-          webhook_token: 'token-123',
-          webhook_headers: {
-            'X-Trace-Id': 'trace-1',
-            priority: 5,
-          },
-        },
-      }),
-    );
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(fetchMock).toHaveBeenCalledWith('https://dispatch.example/runs', {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'x-trace-id': 'trace-1',
-        priority: '5',
-        authorization: 'Bearer token-123',
-      },
-      body: expect.any(String),
-    });
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toBe('remote success');
-    expect(result.metrics).toMatchObject({
-      adapter: 'http-webhook',
-      httpStatus: 200,
-    });
-  });
-
-  it('returns failed result for non-2xx webhook responses', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: false,
-        status: 502,
-        statusText: 'Bad Gateway',
-        text: 'upstream down',
-      }),
-    );
-    const adapter = new HttpWebhookAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-        },
-      }),
-    );
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('http-webhook request failed (502)');
-    expect(result.error).toContain('upstream down');
-    expect(result.logs.some((entry) => entry.level === 'error')).toBe(true);
-  });
-
-  it('treats acknowledged non-terminal response as synchronous success when no poll URL is provided', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: true,
-        status: 202,
-        text: JSON.stringify({
-          status: 'running',
-          accepted: true,
-        }),
-      }),
-    );
-    const adapter = new HttpWebhookAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-        },
-      }),
-    );
-
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('"accepted":true');
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('polls status endpoint until a terminal result is returned', async () => {
-    vi.useFakeTimers();
-    fetchMock
-      .mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          status: 202,
-          text: JSON.stringify({
-            status: 'running',
-            pollUrl: 'https://dispatch.example/runs/run-webhook-1/status',
-          }),
-        }),
-      )
-      .mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          status: 200,
-          text: JSON.stringify({
-            status: 'running',
-          }),
-        }),
-      )
-      .mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          status: 200,
-          text: JSON.stringify({
-            status: 'succeeded',
-            output: 'poll-complete',
-          }),
-        }),
-      );
-
-    const adapter = new HttpWebhookAdapter();
-    const execution = adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-          webhook_poll_ms: 250,
-          webhook_max_wait_ms: 2_000,
-        },
-      }),
-    );
-
-    await vi.advanceTimersByTimeAsync(300);
-    const result = await execution;
-
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      2,
-      'https://dispatch.example/runs/run-webhook-1/status',
-      expect.objectContaining({
-        method: 'GET',
-      }),
-    );
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toBe('poll-complete');
-    expect(result.metrics).toMatchObject({
-      adapter: 'http-webhook',
-      pollUrl: 'https://dispatch.example/runs/run-webhook-1/status',
-      pollHttpStatus: 200,
-    });
-  });
-
-  it('returns cancelled when cancellation is requested during polling', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: true,
-        status: 202,
-        text: JSON.stringify({
-          status: 'running',
-          pollUrl: 'https://dispatch.example/runs/run-webhook-1/status',
-        }),
-      }),
-    );
-    const adapter = new HttpWebhookAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-        },
-        isCancelled: () => true,
-      }),
-    );
-
-    expect(result.status).toBe('cancelled');
-    expect(result.output).toContain('polling cancelled');
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('fails when polling exceeds timeout window', async () => {
-    vi.useFakeTimers();
-    fetchMock.mockImplementation(async (_url: string, requestInit?: RequestInit) => {
-      if (requestInit?.method === 'POST') {
-        return mockResponse({
-          ok: true,
-          status: 202,
-          text: JSON.stringify({
-            status: 'running',
-            pollUrl: 'https://dispatch.example/runs/run-webhook-1/status',
-          }),
-        });
-      }
-      return mockResponse({
-        ok: true,
-        status: 200,
-        text: JSON.stringify({
-          status: 'running',
-        }),
-      });
-    });
-
-    const adapter = new HttpWebhookAdapter();
-    const execution = adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-          webhook_poll_ms: 200,
-          webhook_max_wait_ms: 1_000,
-        },
-      }),
-    );
-
-    await vi.advanceTimersByTimeAsync(2_000);
-    const result = await execution;
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('polling exceeded timeout');
-  });
-});
diff --git a/packages/kernel/src/adapter-http-webhook.ts b/packages/kernel/src/adapter-http-webhook.ts
deleted file mode 100644
index 0efb1f4..0000000
--- a/packages/kernel/src/adapter-http-webhook.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { HttpWebhookAdapter } from '../../adapter-http-webhook/src/adapter.js';
diff --git a/packages/kernel/src/adapter-shell-worker.test.ts b/packages/kernel/src/adapter-shell-worker.test.ts
deleted file mode 100644
index eb47107..0000000
--- a/packages/kernel/src/adapter-shell-worker.test.ts
+++ /dev/null
@@ -1,212 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DispatchAdapterExecutionInput } from './runtime-adapter-contracts.js';
-import { CursorCloudAdapter } from './adapter-cursor-cloud.js';
-import { ShellWorkerAdapter } from './adapter-shell-worker.js';
-
-vi.mock('node:child_process', () => ({
-  spawn: vi.fn(),
-}));
-
-import { spawn } from 'node:child_process';
-
-interface FakeChildProcess extends EventEmitter {
-  stdout: EventEmitter;
-  stderr: EventEmitter;
-  kill: ReturnType<typeof vi.fn>;
-}
-
-function makeInput(overrides: Partial<DispatchAdapterExecutionInput> = {}): DispatchAdapterExecutionInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run-shell-1',
-    actor: 'agent-shell',
-    objective: 'Test shell worker adapter',
-    context: {},
-    ...overrides,
-  };
-}
-
-function createFakeChildProcess(): FakeChildProcess {
-  const child = new EventEmitter() as FakeChildProcess;
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  child.kill = vi.fn(() => true) as any;
-  return child;
-}
-
-describe('ShellWorkerAdapter', () => {
-  const spawnMock = vi.mocked(spawn);
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-    spawnMock.mockReset();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('falls back to cursor-cloud adapter when shell_command is not configured', async () => {
-    const fallbackSpy = vi.spyOn(CursorCloudAdapter.prototype, 'execute').mockResolvedValue({
-      status: 'succeeded',
-      output: 'fallback result',
-      logs: [],
-      metrics: {
-        adapter: 'cursor-cloud',
-      },
-    });
-    const adapter = new ShellWorkerAdapter();
-
-    const result = await adapter.execute(makeInput());
-
-    expect(spawnMock).not.toHaveBeenCalled();
-    expect(fallbackSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        runId: 'run-shell-1',
-      }),
-    );
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toBe('fallback result');
-  });
-
-  it('executes shell command successfully and captures stdout/stderr', async () => {
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      queueMicrotask(() => {
-        child.stdout.emit('data', Buffer.from('hello shell\n'));
-        child.stderr.emit('data', Buffer.from('warning line\n'));
-        child.emit('close', 0);
-      });
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    const adapter = new ShellWorkerAdapter();
-
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'echo hello shell',
-          shell_cwd: '/tmp/shell-worker',
-          shell_timeout_ms: 5000,
-          shell_env: {
-            TEST_FLAG: 'enabled',
-          },
-        },
-      }),
-    );
-
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    expect(spawnMock).toHaveBeenCalledWith(
-      'echo hello shell',
-      expect.objectContaining({
-        cwd: '/tmp/shell-worker',
-        shell: true,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: expect.objectContaining({
-          TEST_FLAG: 'enabled',
-        }),
-      }),
-    );
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('hello shell');
-    expect(result.output).toContain('warning line');
-    expect(result.metrics).toMatchObject({
-      adapter: 'shell-worker',
-      exitCode: 0,
-    });
-    expect(result.logs.some((entry) => entry.message.includes('[stdout] hello shell'))).toBe(true);
-    expect(result.logs.some((entry) => entry.message.includes('[stderr] warning line'))).toBe(true);
-  });
-
-  it('returns failed result when command exits non-zero', async () => {
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      queueMicrotask(() => {
-        child.stderr.emit('data', Buffer.from('boom\n'));
-        child.emit('close', 7);
-      });
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    const adapter = new ShellWorkerAdapter();
-
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'false',
-        },
-      }),
-    );
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('Exit code: 7');
-    expect(result.error).toContain('boom');
-    expect(result.logs.some((entry) => entry.level === 'error')).toBe(true);
-  });
-
-  it('marks command as failed when execution times out', async () => {
-    let childRef: FakeChildProcess | undefined;
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      child.kill.mockImplementation(() => {
-        setTimeout(() => {
-          child.emit('close', 143);
-        }, 0);
-        return true;
-      });
-      childRef = child;
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    const adapter = new ShellWorkerAdapter();
-
-    const execution = adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'sleep 999',
-          shell_timeout_ms: 10,
-        },
-      }),
-    );
-    const result = await execution;
-
-    expect(childRef?.kill).toHaveBeenCalledWith('SIGTERM');
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('Command: sleep 999');
-    expect(result.error).toContain('Cancelled: no');
-  });
-
-  it('marks command as cancelled when cancellation signal is raised', async () => {
-    vi.useFakeTimers();
-    let childRef: FakeChildProcess | undefined;
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      child.kill.mockImplementation(() => {
-        queueMicrotask(() => {
-          child.emit('close', 143);
-        });
-        return true;
-      });
-      childRef = child;
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    let cancelled = false;
-    const adapter = new ShellWorkerAdapter();
-
-    const execution = adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'sleep 999',
-          shell_timeout_ms: 2000,
-        },
-        isCancelled: () => cancelled,
-      }),
-    );
-    cancelled = true;
-    await vi.advanceTimersByTimeAsync(250);
-    const result = await execution;
-
-    expect(childRef?.kill).toHaveBeenCalledWith('SIGTERM');
-    expect(result.status).toBe('cancelled');
-    expect(result.output).toContain('Cancelled: yes');
-  });
-});
diff --git a/packages/kernel/src/adapter-shell-worker.ts b/packages/kernel/src/adapter-shell-worker.ts
deleted file mode 100644
index e857007..0000000
--- a/packages/kernel/src/adapter-shell-worker.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { ShellWorkerAdapter } from '../../adapter-shell-worker/src/adapter.js';
diff --git a/packages/kernel/src/adapters.test.ts b/packages/kernel/src/adapters.test.ts
deleted file mode 100644
index a33ded7..0000000
--- a/packages/kernel/src/adapters.test.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import http from 'node:http';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as dispatch from './dispatch.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-adapters-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('dispatch production adapters', () => {
-  it('executes shell-worker adapter commands successfully', async () => {
-    const shellSuccessCommand = `"${process.execPath}" -e "process.stdout.write('shell-worker-ok')"`;
-    const run = dispatch.createRun(workspacePath, {
-      actor: 'adapter-tester',
-      adapter: 'shell-worker',
-      objective: 'Run shell adapter command',
-      context: {
-        shell_command: shellSuccessCommand,
-      },
-    });
-
-    const result = await dispatch.executeRun(workspacePath, run.id, {
-      actor: 'adapter-tester',
-    });
-
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('shell-worker-ok');
-  });
-
-  it('executes http-webhook adapter against third-party endpoint', async () => {
-    const server = http.createServer((req, res) => {
-      if (req.method === 'POST' && req.url === '/dispatch') {
-        res.setHeader('content-type', 'application/json');
-        res.writeHead(200);
-        res.end(JSON.stringify({
-          status: 'succeeded',
-          output: 'remote system executed run successfully',
-        }));
-        return;
-      }
-      res.writeHead(404);
-      res.end('not found');
-    });
-
-    await new Promise<void>((resolve) => {
-      server.listen(0, '127.0.0.1', () => resolve());
-    });
-    const address = server.address();
-    const port = typeof address === 'object' && address ? address.port : 0;
-    const webhookUrl = `http://127.0.0.1:${port}/dispatch`;
-
-    try {
-      const run = dispatch.createRun(workspacePath, {
-        actor: 'adapter-tester',
-        adapter: 'http-webhook',
-        objective: 'Run webhook adapter command',
-        context: {
-          webhook_url: webhookUrl,
-        },
-      });
-      const result = await dispatch.executeRun(workspacePath, run.id, {
-        actor: 'adapter-tester',
-      });
-      expect(result.status).toBe('succeeded');
-      expect(result.output).toContain('remote system executed run successfully');
-    } finally {
-      await new Promise<void>((resolve) => {
-        server.close(() => resolve());
-      });
-    }
-  });
-
-  it('executes claude-code adapter through configured command template', async () => {
-    const claudeSuccessCommandTemplate = `"${process.execPath}" -e "process.stdout.write('claude_adapter_ok')"`;
-    const run = dispatch.createRun(workspacePath, {
-      actor: 'adapter-tester',
-      adapter: 'claude-code',
-      objective: 'Run claude adapter command template',
-      context: {
-        claude_command_template: claudeSuccessCommandTemplate,
-      },
-    });
-
-    const result = await dispatch.executeRun(workspacePath, run.id, {
-      actor: 'adapter-tester',
-    });
-
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('claude_adapter_ok');
-  });
-});
diff --git a/packages/kernel/src/agent-self-assembly.test.ts b/packages/kernel/src/agent-self-assembly.test.ts
deleted file mode 100644
index 0720a90..0000000
--- a/packages/kernel/src/agent-self-assembly.test.ts
+++ /dev/null
@@ -1,206 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as auth from './auth.js';
-import * as agent from './agent.js';
-import { assembleAgent } from './agent-self-assembly.js';
-import * as conversation from './conversation.js';
-import * as policy from './policy.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import { initWorkspace } from './workspace.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-agent-self-assembly-'));
-  initWorkspace(workspacePath, { createReadme: false });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('agent self-assembly', () => {
-  it('runs auth -> discovery -> claim -> plan-step activation end-to-end', () => {
-    const initResult = initWorkspace(workspacePath, { createReadme: false });
-    const registration = agent.registerAgent(workspacePath, 'ops-agent', {
-      token: initResult.bootstrapTrustToken,
-      role: 'roles/ops.md',
-      capabilities: ['thread:claim'],
-    });
-    expect(registration.apiKey).toBeDefined();
-
-    const workThread = thread.createThread(
-      workspacePath,
-      'Investigate elevated error rate',
-      'Locate root cause and propose remediation',
-      'ops-agent',
-    );
-    const executionConversation = conversation.createConversation(
-      workspacePath,
-      'Ops execution',
-      'ops-agent',
-      { threadRefs: [workThread.path] },
-    );
-    const seededStep = conversation.createPlanStep(
-      workspacePath,
-      'Run first triage pass',
-      'ops-agent',
-      {
-        conversationRef: executionConversation.conversation.path,
-        threadRef: workThread.path,
-      },
-    );
-    setStrictAuthMode(workspacePath);
-
-    const result = assembleAgent(workspacePath, 'ops-agent', {
-      credentialToken: registration.apiKey,
-      advertise: {
-        capabilities: ['domain:ops'],
-        skills: ['incident-triage'],
-        adapters: ['shell-worker'],
-      },
-    });
-
-    expect(result.authenticated).toBe(true);
-    expect(result.identityVerified).toBe(true);
-    expect(result.claimedThread?.path).toBe(workThread.path);
-    expect(result.planStep?.path).toBe(seededStep.path);
-    expect(result.planStep?.fields.status).toBe('active');
-    expect(String(result.planStep?.fields.assignee)).toBe('ops-agent');
-    expect(String(result.claimedThread?.fields.status)).toBe('active');
-    expect(result.brief.actor).toBe('ops-agent');
-    expect(result.capabilityProfile.skills).toContain('incident-triage');
-    expect(result.capabilityProfile.adapters).toContain('shell-worker');
-    expect(result.warnings).toEqual([]);
-  });
-
-  it('matches advertised skills/adapters/capabilities to the right thread', () => {
-    const initResult = initWorkspace(workspacePath, { createReadme: false });
-    const registration = agent.registerAgent(workspacePath, 'router-agent', {
-      token: initResult.bootstrapTrustToken,
-      role: 'roles/ops.md',
-      capabilities: ['thread:claim'],
-    });
-    expect(registration.apiKey).toBeDefined();
-
-    const unmatchedThread = thread.createThread(
-      workspacePath,
-      'Requires code specialist',
-      'Task requiring code-specialized profile',
-      'router-agent',
-      { priority: 'urgent' },
-    );
-    store.update(
-      workspacePath,
-      unmatchedThread.path,
-      {
-        required_skills: ['deep-typescript'],
-        required_adapters: ['claude-code'],
-      },
-      undefined,
-      'system',
-    );
-
-    const matchedThread = thread.createThread(
-      workspacePath,
-      'Requires ops triage',
-      'Task requiring ops triage profile',
-      'router-agent',
-      { priority: 'high' },
-    );
-    store.update(
-      workspacePath,
-      matchedThread.path,
-      {
-        required_capabilities: ['domain:ops'],
-        required_skills: ['incident-triage'],
-        required_adapters: ['shell-worker'],
-      },
-      undefined,
-      'system',
-    );
-    setStrictAuthMode(workspacePath);
-
-    const result = assembleAgent(workspacePath, 'router-agent', {
-      credentialToken: registration.apiKey,
-      advertise: {
-        capabilities: ['domain:ops'],
-        skills: ['incident-triage'],
-        adapters: ['shell-worker'],
-      },
-      createPlanStepIfMissing: false,
-    });
-
-    expect(result.claimedThread?.path).toBe(matchedThread.path);
-    const unmatched = result.candidates.find((candidate) => candidate.thread.path === unmatchedThread.path);
-    expect(unmatched).toBeDefined();
-    expect(unmatched?.matched).toBe(false);
-    expect(unmatched?.missing.skills).toContain('deep-typescript');
-    expect(unmatched?.missing.adapters).toContain('claude-code');
-  });
-
-  it('recovers stale claims and lets another agent take over', () => {
-    const initResult = initWorkspace(workspacePath, { createReadme: false });
-    const firstAgent = agent.registerAgent(workspacePath, 'owner-agent', {
-      token: initResult.bootstrapTrustToken,
-      role: 'roles/ops.md',
-      capabilities: ['thread:claim', 'policy:manage'],
-    });
-    expect(firstAgent.apiKey).toBeDefined();
-
-    const leasedThread = thread.createThread(
-      workspacePath,
-      'Recoverable work item',
-      'Must be reclaimed after stale lease',
-      'owner-agent',
-    );
-    const takeoverAgent = provisionOpsCredential(workspacePath, 'takeover-agent');
-    setStrictAuthMode(workspacePath);
-    auth.runWithAuthContext({ credentialToken: firstAgent.apiKey, source: 'cli' }, () => {
-      thread.claim(workspacePath, leasedThread.path, 'owner-agent', { leaseTtlMinutes: 0 });
-    });
-
-    const result = assembleAgent(workspacePath, 'takeover-agent', {
-      credentialToken: takeoverAgent.apiKey,
-      recoverStaleClaims: true,
-      recoveryRequired: true,
-      createPlanStepIfMissing: false,
-    });
-
-    expect(result.recovery?.reaped.map((entry) => entry.threadPath)).toContain(leasedThread.path);
-    expect(result.claimedThread?.path).toBe(leasedThread.path);
-    expect(String(result.claimedThread?.fields.owner)).toBe('takeover-agent');
-  });
-});
-
-function setStrictAuthMode(targetWorkspacePath: string): void {
-  const configPath = path.join(targetWorkspacePath, '.workgraph', 'server.json');
-  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8')) as Record<string, unknown>;
-  config.auth = {
-    mode: 'strict',
-    allowUnauthenticatedFallback: false,
-  };
-  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
-}
-
-function provisionOpsCredential(
-  targetWorkspacePath: string,
-  actor: string,
-): auth.IssueAgentCredentialResult {
-  const capabilities = ['thread:claim', 'thread:manage', 'dispatch:run', 'policy:manage', 'agent:register'];
-  policy.upsertParty(targetWorkspacePath, actor, {
-    roles: ['ops'],
-    capabilities,
-  }, {
-    actor: 'system',
-    skipAuthorization: true,
-  });
-  return auth.issueAgentCredential(targetWorkspacePath, {
-    actor,
-    scopes: capabilities,
-    issuedBy: 'system',
-  });
-}
diff --git a/packages/kernel/src/agent-self-assembly.ts b/packages/kernel/src/agent-self-assembly.ts
deleted file mode 100644
index 5c2e8f6..0000000
--- a/packages/kernel/src/agent-self-assembly.ts
+++ /dev/null
@@ -1,424 +0,0 @@
-/**
- * Agent self-assembly orchestration.
- *
- * Flow:
- * 1) Optional bootstrap registration.
- * 2) Authenticate actor identity/governance context.
- * 3) Advertise capabilities + refresh presence heartbeat.
- * 4) Discover workspace orientation + claimable threads.
- * 5) Capability-match and claim a thread.
- * 6) Begin plan-step execution for the claimed thread.
- */
-
-import * as auth from './auth.js';
-import * as agent from './agent.js';
-import * as capability from './capability.js';
-import * as conversation from './conversation.js';
-import * as dispatch from './dispatch.js';
-import * as orientation from './orientation.js';
-import * as policy from './policy.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import type { PrimitiveInstance, WorkgraphBrief, WorkgraphStatusSnapshot } from './types.js';
-
-export interface AgentCapabilityAdvertisement {
-  capabilities?: string[];
-  skills?: string[];
-  adapters?: string[];
-}
-
-export interface AgentCapabilityProfile {
-  agentName: string;
-  capabilities: string[];
-  skills: string[];
-  adapters: string[];
-  advertisedCapabilityTokens: string[];
-}
-
-export interface ThreadCapabilityRequirements {
-  capabilities: string[];
-  skills: string[];
-  adapters: string[];
-}
-
-export interface ThreadCapabilityMatch {
-  thread: PrimitiveInstance;
-  requirements: ThreadCapabilityRequirements;
-  missing: ThreadCapabilityRequirements;
-  matched: boolean;
-}
-
-export interface AgentSelfAssemblyOptions {
-  credentialToken?: string;
-  bootstrapToken?: string;
-  role?: string;
-  registerActor?: string;
-  recoverStaleClaims?: boolean;
-  recoveryActor?: string;
-  recoveryLimit?: number;
-  recoveryRequired?: boolean;
-  spaceRef?: string;
-  leaseTtlMinutes?: number;
-  advertise?: AgentCapabilityAdvertisement;
-  createPlanStepIfMissing?: boolean;
-}
-
-export interface AgentSelfAssemblyResult {
-  agentName: string;
-  authenticated: boolean;
-  identityVerified: boolean;
-  registration?: agent.AgentRegistrationResult;
-  presence?: PrimitiveInstance;
-  capabilityProfile: AgentCapabilityProfile;
-  status: WorkgraphStatusSnapshot;
-  brief: WorkgraphBrief;
-  candidates: ThreadCapabilityMatch[];
-  claimedThread?: PrimitiveInstance;
-  planStep?: PrimitiveInstance;
-  conversationPath?: string;
-  recovery?: thread.ReapStaleClaimsResult;
-  warnings: string[];
-}
-
-export function assembleAgent(
-  workspacePath: string,
-  agentName: string,
-  options: AgentSelfAssemblyOptions = {},
-): AgentSelfAssemblyResult {
-  const normalizedAgent = normalizeActorId(agentName);
-  if (!normalizedAgent) {
-    throw new Error(`Invalid agent name "${agentName}".`);
-  }
-
-  const warnings: string[] = [];
-  const registration = maybeBootstrapRegister(workspacePath, normalizedAgent, options);
-  const effectiveCredential = readOptionalString(options.credentialToken) ?? registration?.apiKey;
-
-  return withCredentialContext(effectiveCredential, () => {
-    const decision = auth.authorizeMutation(workspacePath, {
-      actor: normalizedAgent,
-      action: 'agent.self-assembly',
-      target: '.workgraph/self-assembly',
-      requiredCapabilities: ['thread:claim', 'thread:manage', 'dispatch:run'],
-    });
-    if (!decision.allowed) {
-      throw new Error(decision.reason ?? `Self-assembly denied for "${normalizedAgent}".`);
-    }
-
-    const capabilityProfile = buildCapabilityProfile(workspacePath, normalizedAgent, options, registration);
-    const presence = advertisePresence(workspacePath, normalizedAgent, capabilityProfile, warnings);
-    const recovery = maybeRecoverStaleClaims(workspacePath, normalizedAgent, options, warnings);
-    const status = orientation.statusSnapshot(workspacePath);
-    const brief = orientation.brief(workspacePath, normalizedAgent, { nextCount: 10, recentCount: 20 });
-
-    const readyThreads = options.spaceRef
-      ? thread.listReadyThreadsInSpace(workspacePath, options.spaceRef)
-      : thread.listReadyThreads(workspacePath);
-    const candidates = readyThreads.map((readyThread) => matchThreadToAgent(readyThread, capabilityProfile));
-    const matchedCandidates = candidates.filter((candidate) => candidate.matched);
-
-    const claimedThread = claimFirstMatchedThread(
-      workspacePath,
-      normalizedAgent,
-      matchedCandidates,
-      options.leaseTtlMinutes,
-      warnings,
-    );
-    const stepStart = claimedThread
-      ? beginPlanStepExecution(workspacePath, claimedThread, normalizedAgent, options)
-      : undefined;
-
-    return {
-      agentName: normalizedAgent,
-      authenticated: true,
-      identityVerified: decision.identityVerified,
-      ...(registration ? { registration } : {}),
-      ...(presence ? { presence } : {}),
-      capabilityProfile,
-      status,
-      brief,
-      candidates,
-      ...(claimedThread ? { claimedThread } : {}),
-      ...(stepStart?.planStep ? { planStep: stepStart.planStep } : {}),
-      ...(stepStart?.conversationPath ? { conversationPath: stepStart.conversationPath } : {}),
-      ...(recovery ? { recovery } : {}),
-      warnings,
-    };
-  });
-}
-
-export function matchThreadToAgent(
-  threadInstance: PrimitiveInstance,
-  capabilityProfile: AgentCapabilityProfile,
-): ThreadCapabilityMatch {
-  return capability.matchThreadToCapabilityProfile(threadInstance, capabilityProfile);
-}
-
-function maybeBootstrapRegister(
-  workspacePath: string,
-  agentName: string,
-  options: AgentSelfAssemblyOptions,
-): agent.AgentRegistrationResult | undefined {
-  const bootstrapToken = readOptionalString(options.bootstrapToken);
-  if (!bootstrapToken) return undefined;
-  return agent.registerAgent(workspacePath, agentName, {
-    token: bootstrapToken,
-    ...(options.role ? { role: options.role } : {}),
-    ...(options.advertise?.capabilities ? { capabilities: options.advertise.capabilities } : {}),
-    actor: readOptionalString(options.registerActor) ?? agentName,
-  });
-}
-
-function buildCapabilityProfile(
-  workspacePath: string,
-  agentName: string,
-  options: AgentSelfAssemblyOptions,
-  registration: agent.AgentRegistrationResult | undefined,
-): AgentCapabilityProfile {
-  const existingPresence = agent.getPresence(workspacePath, agentName);
-  const policyParty = policy.getParty(workspacePath, agentName);
-  const advertised = options.advertise ?? {};
-
-  const mergedCapabilities = dedupeStrings([
-    ...asStringList(existingPresence?.fields.capabilities),
-    ...(registration?.capabilities ?? []),
-    ...(policyParty?.capabilities ?? []),
-    ...asStringList(advertised.capabilities),
-  ]);
-  const mergedSkills = dedupeStrings([
-    ...extractScopedValues(mergedCapabilities, 'skill:'),
-    ...asStringList(advertised.skills),
-  ]);
-  const mergedAdapters = dedupeStrings([
-    ...extractScopedValues(mergedCapabilities, 'adapter:'),
-    ...asStringList(advertised.adapters),
-  ]);
-  const advertisedCapabilityTokens = dedupeStrings([
-    ...mergedCapabilities,
-    ...mergedSkills.map((skillName) => `skill:${skillName}`),
-    ...mergedAdapters.map((adapterName) => `adapter:${adapterName}`),
-  ]);
-
-  return {
-    agentName,
-    capabilities: mergedCapabilities,
-    skills: mergedSkills,
-    adapters: mergedAdapters,
-    advertisedCapabilityTokens,
-  };
-}
-
-function advertisePresence(
-  workspacePath: string,
-  agentName: string,
-  capabilityProfile: AgentCapabilityProfile,
-  warnings: string[],
-): PrimitiveInstance | undefined {
-  try {
-    return agent.heartbeat(workspacePath, agentName, {
-      actor: agentName,
-      status: 'online',
-      capabilities: capabilityProfile.advertisedCapabilityTokens,
-    });
-  } catch (error) {
-    warnings.push(`Presence advertisement failed: ${errorMessage(error)}`);
-    return undefined;
-  }
-}
-
-function maybeRecoverStaleClaims(
-  workspacePath: string,
-  agentName: string,
-  options: AgentSelfAssemblyOptions,
-  warnings: string[],
-): thread.ReapStaleClaimsResult | undefined {
-  if (options.recoverStaleClaims === false) return undefined;
-  const recoveryActor = readOptionalString(options.recoveryActor) ?? agentName;
-  try {
-    return thread.reapStaleClaims(workspacePath, recoveryActor, {
-      ...(typeof options.recoveryLimit === 'number' ? { limit: options.recoveryLimit } : {}),
-    });
-  } catch (error) {
-    if (options.recoveryRequired) {
-      throw error;
-    }
-    warnings.push(`Stale-claim recovery skipped: ${errorMessage(error)}`);
-    return undefined;
-  }
-}
-
-function claimFirstMatchedThread(
-  workspacePath: string,
-  actor: string,
-  candidates: ThreadCapabilityMatch[],
-  leaseTtlMinutes: number | undefined,
-  warnings: string[],
-): PrimitiveInstance | undefined {
-  for (const candidate of candidates) {
-    try {
-      const claimed = dispatch.claimThread(workspacePath, candidate.thread.path, actor).thread;
-      if (typeof leaseTtlMinutes === 'number') {
-        thread.heartbeatClaim(workspacePath, actor, claimed.path, { ttlMinutes: leaseTtlMinutes });
-      }
-      return claimed;
-    } catch (error) {
-      warnings.push(`Claim failed for ${candidate.thread.path}: ${errorMessage(error)}`);
-    }
-  }
-  return undefined;
-}
-
-function beginPlanStepExecution(
-  workspacePath: string,
-  claimedThread: PrimitiveInstance,
-  actor: string,
-  options: AgentSelfAssemblyOptions,
-): { planStep?: PrimitiveInstance; conversationPath?: string } {
-  const createPlanStepIfMissing = options.createPlanStepIfMissing !== false;
-  let conversationPath: string | undefined = findConversationForThread(workspacePath, claimedThread.path);
-
-  if (!conversationPath && createPlanStepIfMissing) {
-    const createdConversation = conversation.createConversation(
-      workspacePath,
-      `Execution: ${String(claimedThread.fields.title ?? claimedThread.path)}`,
-      actor,
-      {
-        threadRefs: [claimedThread.path],
-      },
-    );
-    conversationPath = createdConversation.conversation.path;
-  }
-
-  let selectedStep = findPlanStepForExecution(workspacePath, claimedThread.path, actor);
-  if (!selectedStep && createPlanStepIfMissing && conversationPath) {
-    selectedStep = conversation.createPlanStep(
-      workspacePath,
-      `Execute ${String(claimedThread.fields.title ?? claimedThread.path)}`,
-      actor,
-      {
-        conversationRef: conversationPath,
-        threadRef: claimedThread.path,
-        assignee: actor,
-      },
-    );
-  }
-
-  if (selectedStep && !readOptionalString(selectedStep.fields.assignee)) {
-    selectedStep = store.update(
-      workspacePath,
-      selectedStep.path,
-      { assignee: actor },
-      undefined,
-      actor,
-    );
-  }
-
-  if (selectedStep && String(selectedStep.fields.status ?? '').toLowerCase() !== 'active') {
-    selectedStep = conversation.updatePlanStepStatus(
-      workspacePath,
-      selectedStep.path,
-      'active',
-      actor,
-    );
-  }
-
-  if (conversationPath) {
-    conversation.appendConversationMessage(
-      workspacePath,
-      conversationPath,
-      actor,
-      `Self-assembly claimed ${claimedThread.path} and started execution.`,
-      {
-        kind: 'system',
-        eventType: 'self-assembly',
-        threadRef: claimedThread.path,
-      },
-    );
-  }
-
-  return {
-    ...(selectedStep ? { planStep: selectedStep } : {}),
-    ...(conversationPath ? { conversationPath } : {}),
-  };
-}
-
-function findConversationForThread(workspacePath: string, threadPath: string): string | undefined {
-  const conversations = conversation.listConversations(workspacePath, { threadRef: threadPath });
-  return conversations[0]?.conversation.path;
-}
-
-function findPlanStepForExecution(
-  workspacePath: string,
-  threadPath: string,
-  actor: string,
-): PrimitiveInstance | undefined {
-  const candidates = conversation.listPlanSteps(workspacePath, { threadRef: threadPath });
-  return candidates.find((step) => {
-    const status = String(step.fields.status ?? '').trim().toLowerCase();
-    if (status !== 'open' && status !== 'active') return false;
-    const assignee = readOptionalString(step.fields.assignee);
-    return !assignee || assignee === actor;
-  });
-}
-
-function withCredentialContext<T>(credentialToken: string | undefined, fn: () => T): T {
-  const token = readOptionalString(credentialToken);
-  if (!token) return fn();
-  return auth.runWithAuthContext({ credentialToken: token, source: 'internal' }, fn);
-}
-
-function normalizeActorId(value: unknown): string {
-  return String(value ?? '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, '-')
-    .replace(/^-|-$/g, '');
-}
-
-function normalizeToken(value: unknown): string {
-  return String(value ?? '')
-    .trim()
-    .toLowerCase();
-}
-
-function extractScopedValues(tokens: string[], prefix: string): string[] {
-  return tokens
-    .filter((token) => token.startsWith(prefix))
-    .map((token) => token.slice(prefix.length))
-    .filter(Boolean);
-}
-
-function asStringList(value: unknown): string[] {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => normalizeToken(entry))
-      .filter(Boolean);
-  }
-  if (typeof value === 'string') {
-    return value
-      .split(',')
-      .map((entry) => normalizeToken(entry))
-      .filter(Boolean);
-  }
-  return [];
-}
-
-function dedupeStrings(values: string[]): string[] {
-  const unique = new Set<string>();
-  for (const value of values) {
-    const normalized = normalizeToken(value);
-    if (!normalized) continue;
-    unique.add(normalized);
-  }
-  return [...unique];
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
diff --git a/packages/kernel/src/autonomy-daemon.test.ts b/packages/kernel/src/autonomy-daemon.test.ts
deleted file mode 100644
index db9b573..0000000
--- a/packages/kernel/src/autonomy-daemon.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import * as daemon from './autonomy-daemon.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-daemon-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('autonomy daemon process model', () => {
-  it('reports default status paths and parses heartbeat', () => {
-    const statusBefore = daemon.readAutonomyDaemonStatus(workspacePath);
-    const normalizedPidPath = statusBefore.pidPath.replace(/\\/g, '/');
-    expect(statusBefore.running).toBe(false);
-    expect(statusBefore.pid).toBeUndefined();
-    expect(normalizedPidPath).toContain('.workgraph/daemon/autonomy.pid');
-
-    const heartbeatPath = statusBefore.heartbeatPath;
-    fs.writeFileSync(heartbeatPath, JSON.stringify({
-      ts: new Date().toISOString(),
-      cycle: 3,
-      driftOk: true,
-    }, null, 2), 'utf-8');
-
-    const statusAfter = daemon.readAutonomyDaemonStatus(workspacePath);
-    expect(statusAfter.heartbeat?.cycle).toBe(3);
-    expect(statusAfter.heartbeat?.driftOk).toBe(true);
-  });
-
-  it('stops tracked pid processes using pid-file lifecycle', async () => {
-    const status = daemon.readAutonomyDaemonStatus(workspacePath);
-    const pidPath = status.pidPath;
-    const heartbeatPath = status.heartbeatPath;
-    fs.writeFileSync(heartbeatPath, JSON.stringify({ ts: new Date().toISOString() }) + '\n', 'utf-8');
-
-    const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000);'], {
-      stdio: 'ignore',
-    });
-    if (!child.pid) throw new Error('Failed to spawn child process for daemon test.');
-    fs.writeFileSync(pidPath, `${child.pid}\n`, 'utf-8');
-
-    const runningStatus = daemon.readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: false });
-    expect(runningStatus.running).toBe(true);
-    expect(runningStatus.pid).toBe(child.pid);
-
-    const stopResult = await daemon.stopAutonomyDaemon(workspacePath, {
-      timeoutMs: 4000,
-    });
-    expect(stopResult.previouslyRunning).toBe(true);
-    expect(stopResult.stopped).toBe(true);
-
-    const finalStatus = daemon.readAutonomyDaemonStatus(workspacePath);
-    expect(finalStatus.running).toBe(false);
-  });
-});
diff --git a/packages/kernel/src/autonomy-daemon.ts b/packages/kernel/src/autonomy-daemon.ts
deleted file mode 100644
index bb6b2ec..0000000
--- a/packages/kernel/src/autonomy-daemon.ts
+++ /dev/null
@@ -1,309 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-
-const DAEMON_DIR = '.workgraph/daemon';
-const AUTONOMY_PID_FILE = 'autonomy.pid';
-const AUTONOMY_HEARTBEAT_FILE = 'autonomy-heartbeat.json';
-const AUTONOMY_LOG_FILE = 'autonomy.log';
-const AUTONOMY_META_FILE = 'autonomy-process.json';
-
-export interface AutonomyDaemonStartInput {
-  cliEntrypointPath: string;
-  actor: string;
-  adapter?: string;
-  agents?: string[];
-  pollMs?: number;
-  maxCycles?: number;
-  maxIdleCycles?: number;
-  maxSteps?: number;
-  stepDelayMs?: number;
-  space?: string;
-  executeTriggers?: boolean;
-  executeReadyThreads?: boolean;
-  logPath?: string;
-  heartbeatPath?: string;
-}
-
-export interface AutonomyDaemonStopInput {
-  signal?: NodeJS.Signals;
-  timeoutMs?: number;
-}
-
-export interface AutonomyDaemonHeartbeat {
-  ts: string;
-  cycle?: number;
-  readyThreads?: number;
-  triggerActions?: number;
-  runStatus?: string;
-  driftOk?: boolean;
-  driftIssues?: number;
-  finalReadyThreads?: number;
-  finalDriftOk?: boolean;
-}
-
-export interface AutonomyDaemonStatus {
-  running: boolean;
-  pid?: number;
-  pidPath: string;
-  logPath: string;
-  heartbeatPath: string;
-  heartbeat?: AutonomyDaemonHeartbeat;
-}
-
-export interface AutonomyDaemonStopResult {
-  stopped: boolean;
-  previouslyRunning: boolean;
-  pid?: number;
-  status: AutonomyDaemonStatus;
-}
-
-export function startAutonomyDaemon(
-  workspacePath: string,
-  input: AutonomyDaemonStartInput,
-): AutonomyDaemonStatus {
-  const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path.join(daemonDir, AUTONOMY_PID_FILE);
-  const heartbeatPath = input.heartbeatPath
-    ? resolvePathWithinWorkspace(workspacePath, input.heartbeatPath)
-    : path.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
-  const logPath = input.logPath
-    ? resolvePathWithinWorkspace(workspacePath, input.logPath)
-    : path.join(daemonDir, AUTONOMY_LOG_FILE);
-  const metaPath = path.join(daemonDir, AUTONOMY_META_FILE);
-
-  const existing = readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true });
-  if (existing.running) {
-    throw new Error(`Autonomy daemon already running (pid=${existing.pid}). Stop it before starting a new one.`);
-  }
-
-  const logFd = fs.openSync(logPath, 'a');
-  const args = buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath);
-  const child = spawn(process.execPath, args, {
-    detached: true,
-    stdio: ['ignore', logFd, logFd],
-    env: process.env,
-  });
-  fs.closeSync(logFd);
-  child.unref();
-  if (!child.pid) {
-    throw new Error('Failed to start autonomy daemon: missing child process pid.');
-  }
-
-  fs.writeFileSync(pidPath, `${child.pid}\n`, 'utf-8');
-  fs.writeFileSync(metaPath, JSON.stringify({
-    startedAt: new Date().toISOString(),
-    pid: child.pid,
-    args,
-    actor: input.actor,
-    adapter: input.adapter ?? 'cursor-cloud',
-    logPath,
-    heartbeatPath,
-  }, null, 2) + '\n', 'utf-8');
-
-  return readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true });
-}
-
-export async function stopAutonomyDaemon(
-  workspacePath: string,
-  input: AutonomyDaemonStopInput = {},
-): Promise<AutonomyDaemonStopResult> {
-  const status = readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: false });
-  if (!status.pid) {
-    return {
-      stopped: true,
-      previouslyRunning: false,
-      status: readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true }),
-    };
-  }
-
-  const pid = status.pid;
-  const signal = input.signal ?? 'SIGTERM';
-  const timeoutMs = clampInt(input.timeoutMs, 5000, 250, 60_000);
-  const previouslyRunning = isProcessAlive(pid);
-  if (previouslyRunning) {
-    process.kill(pid, signal);
-  }
-  await waitForProcessExit(pid, timeoutMs);
-  let stopped = !isProcessAlive(pid);
-  if (!stopped && signal !== 'SIGKILL') {
-    process.kill(pid, 'SIGKILL');
-    await waitForProcessExit(pid, 1500);
-    stopped = !isProcessAlive(pid);
-  }
-
-  const pidPath = path.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
-  if (stopped && fs.existsSync(pidPath)) {
-    fs.rmSync(pidPath, { force: true });
-  }
-  return {
-    stopped,
-    previouslyRunning,
-    pid,
-    status: readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true }),
-  };
-}
-
-export function readAutonomyDaemonStatus(
-  workspacePath: string,
-  options: { cleanupStalePidFile?: boolean } = {},
-): AutonomyDaemonStatus {
-  const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path.join(daemonDir, AUTONOMY_PID_FILE);
-  const meta = readDaemonMeta(path.join(daemonDir, AUTONOMY_META_FILE));
-  const logPath = meta?.logPath ? String(meta.logPath) : path.join(daemonDir, AUTONOMY_LOG_FILE);
-  const heartbeatPath = meta?.heartbeatPath ? String(meta.heartbeatPath) : path.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
-  const pid = readPid(pidPath);
-  const running = pid ? isProcessAlive(pid) : false;
-
-  if (!running && pid && options.cleanupStalePidFile !== false && fs.existsSync(pidPath)) {
-    fs.rmSync(pidPath, { force: true });
-  }
-
-  return {
-    running,
-    pid: running ? pid : undefined,
-    pidPath,
-    logPath,
-    heartbeatPath,
-    heartbeat: readHeartbeat(heartbeatPath),
-  };
-}
-
-function buildAutonomyDaemonArgs(
-  workspacePath: string,
-  input: AutonomyDaemonStartInput,
-  heartbeatPath: string,
-): string[] {
-  const args = [
-    path.resolve(input.cliEntrypointPath),
-    'autonomy',
-    'run',
-    '-w',
-    workspacePath,
-    '--actor',
-    input.actor,
-    '--adapter',
-    input.adapter ?? 'cursor-cloud',
-    '--watch',
-    '--poll-ms',
-    String(clampInt(input.pollMs, 2000, 100, 60_000)),
-    '--max-idle-cycles',
-    String(clampInt(input.maxIdleCycles, 2, 1, 10_000)),
-    '--max-steps',
-    String(clampInt(input.maxSteps, 200, 1, 5000)),
-    '--step-delay-ms',
-    String(clampInt(input.stepDelayMs, 25, 0, 5000)),
-    '--heartbeat-file',
-    heartbeatPath,
-    '--json',
-  ];
-  if (typeof input.maxCycles === 'number') {
-    args.push('--max-cycles', String(clampInt(input.maxCycles, 1, 1, Number.MAX_SAFE_INTEGER)));
-  }
-  if (input.agents && input.agents.length > 0) {
-    args.push('--agents', input.agents.join(','));
-  }
-  if (input.space) {
-    args.push('--space', input.space);
-  }
-  if (input.executeTriggers === false) {
-    args.push('--no-execute-triggers');
-  }
-  if (input.executeReadyThreads === false) {
-    args.push('--no-execute-ready-threads');
-  }
-  return args;
-}
-
-function waitForProcessExit(pid: number, timeoutMs: number): Promise<void> {
-  return new Promise((resolve) => {
-    const startedAt = Date.now();
-    const timer = setInterval(() => {
-      if (!isProcessAlive(pid)) {
-        clearInterval(timer);
-        resolve();
-        return;
-      }
-      if (Date.now() - startedAt >= timeoutMs) {
-        clearInterval(timer);
-        resolve();
-      }
-    }, 100);
-  });
-}
-
-function ensureDaemonDir(workspacePath: string): string {
-  const daemonDir = path.join(workspacePath, DAEMON_DIR);
-  if (!fs.existsSync(daemonDir)) fs.mkdirSync(daemonDir, { recursive: true });
-  return daemonDir;
-}
-
-function readPid(pidPath: string): number | undefined {
-  if (!fs.existsSync(pidPath)) return undefined;
-  const raw = fs.readFileSync(pidPath, 'utf-8').trim();
-  if (!raw) return undefined;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed <= 0) return undefined;
-  return parsed;
-}
-
-function readHeartbeat(heartbeatPath: string): AutonomyDaemonHeartbeat | undefined {
-  if (!fs.existsSync(heartbeatPath)) return undefined;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(heartbeatPath, 'utf-8')) as AutonomyDaemonHeartbeat;
-    if (!parsed || typeof parsed !== 'object') return undefined;
-    return parsed;
-  } catch {
-    return undefined;
-  }
-}
-
-function readDaemonMeta(metaPath: string): Record<string, unknown> | undefined {
-  if (!fs.existsSync(metaPath)) return undefined;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(metaPath, 'utf-8')) as unknown;
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
-    return parsed as Record<string, unknown>;
-  } catch {
-    return undefined;
-  }
-}
-
-function isProcessAlive(pid: number): boolean {
-  if (isZombieProcess(pid)) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isZombieProcess(pid: number): boolean {
-  const statPath = `/proc/${pid}/stat`;
-  if (!fs.existsSync(statPath)) return false;
-  try {
-    const stat = fs.readFileSync(statPath, 'utf-8');
-    const closingIdx = stat.indexOf(')');
-    if (closingIdx === -1 || closingIdx + 2 >= stat.length) return false;
-    const state = stat.slice(closingIdx + 2, closingIdx + 3);
-    return state === 'Z';
-  } catch {
-    return false;
-  }
-}
-
-function resolvePathWithinWorkspace(workspacePath: string, filePath: string): string {
-  const base = path.resolve(workspacePath);
-  const resolved = path.resolve(base, filePath);
-  if (!resolved.startsWith(base + path.sep) && resolved !== base) {
-    throw new Error(`Invalid path outside workspace: ${filePath}`);
-  }
-  return resolved;
-}
-
-function clampInt(value: number | undefined, fallback: number, min: number, max: number): number {
-  const raw = typeof value === 'number' && Number.isFinite(value) ? Math.trunc(value) : fallback;
-  return Math.min(max, Math.max(min, raw));
-}
diff --git a/packages/kernel/src/autonomy.test.ts b/packages/kernel/src/autonomy.test.ts
deleted file mode 100644
index 89faffd..0000000
--- a/packages/kernel/src/autonomy.test.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import * as autonomy from './autonomy.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-autonomy-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('autonomy loop', () => {
-  it('runs long-running collaboration cycles without leaving ready work behind', async () => {
-    const a = thread.createThread(workspacePath, 'Task A', 'first', 'lead', { priority: 'high' });
-    const b = thread.createThread(workspacePath, 'Task B', 'second', 'lead', { deps: [a.path], priority: 'medium' });
-    const c = thread.createThread(workspacePath, 'Task C', 'third', 'lead', { deps: [b.path], priority: 'low' });
-
-    const result = await autonomy.runAutonomyLoop(workspacePath, {
-      actor: 'autonomy-lead',
-      agents: ['auto-1', 'auto-2'],
-      watch: false,
-      maxCycles: 10,
-      maxIdleCycles: 1,
-      pollMs: 1,
-      maxSteps: 100,
-      stepDelayMs: 0,
-      executeTriggers: true,
-      executeReadyThreads: true,
-    });
-
-    expect(result.finalReadyThreads).toBe(0);
-    expect(result.finalDriftOk).toBe(true);
-    expect(store.read(workspacePath, a.path)?.fields.status).toBe('done');
-    expect(store.read(workspacePath, b.path)?.fields.status).toBe('done');
-    expect(store.read(workspacePath, c.path)?.fields.status).toBe('done');
-    expect(result.cycles.length).toBeGreaterThanOrEqual(1);
-  });
-});
diff --git a/packages/kernel/src/autonomy.ts b/packages/kernel/src/autonomy.ts
deleted file mode 100644
index d5ff9c5..0000000
--- a/packages/kernel/src/autonomy.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import * as dispatch from './dispatch.js';
-import * as missionOrchestrator from './mission-orchestrator.js';
-import * as thread from './thread.js';
-import * as triggerEngine from './trigger-engine.js';
-
-export interface AutonomyLoopOptions {
-  actor: string;
-  adapter?: string;
-  agents?: string[];
-  space?: string;
-  pollMs?: number;
-  watch?: boolean;
-  maxCycles?: number;
-  maxIdleCycles?: number;
-  maxSteps?: number;
-  stepDelayMs?: number;
-  executeTriggers?: boolean;
-  executeReadyThreads?: boolean;
-  heartbeatFile?: string;
-}
-
-export interface AutonomyCycleReport {
-  cycle: number;
-  readyThreads: number;
-  triggerActions: number;
-  missionActions: number;
-  repairedRuns: number;
-  requeuedRuns: number;
-  runId?: string;
-  runStatus?: string;
-  driftOk: boolean;
-  driftIssues: number;
-}
-
-export interface AutonomyLoopResult {
-  cycles: AutonomyCycleReport[];
-  finalReadyThreads: number;
-  finalDriftOk: boolean;
-}
-
-export async function runAutonomyLoop(
-  workspacePath: string,
-  options: AutonomyLoopOptions,
-): Promise<AutonomyLoopResult> {
-  const watch = options.watch === true;
-  const pollMs = clampInt(options.pollMs, 2000, 100, 60_000);
-  const maxCycles = clampInt(options.maxCycles, watch ? Number.MAX_SAFE_INTEGER : 20, 1, Number.MAX_SAFE_INTEGER);
-  const maxIdleCycles = clampInt(options.maxIdleCycles, watch ? Number.MAX_SAFE_INTEGER : 2, 1, Number.MAX_SAFE_INTEGER);
-  const cycles: AutonomyCycleReport[] = [];
-  let idleCycles = 0;
-
-  for (let cycle = 1; cycle <= maxCycles; cycle++) {
-    const dispatchRecovery = dispatch.recoverDispatchState(workspacePath, options.actor);
-    const leaseReconcile = dispatch.reconcileExpiredLeases(workspacePath, options.actor);
-    const threadRecovery = thread.recoverThreadState(workspacePath, options.actor, {
-      staleClaimLimit: 100,
-    });
-    const preExecutionMissionCycles = missionOrchestrator.runMissionOrchestratorForActiveMissions(
-      workspacePath,
-      options.actor,
-    );
-    const triggerResult = options.executeTriggers === false
-      ? null
-      : triggerEngine.runTriggerEngineCycle(workspacePath, {
-          actor: options.actor,
-        });
-
-    const readyNow = options.space
-      ? thread.listReadyThreadsInSpace(workspacePath, options.space)
-      : thread.listReadyThreads(workspacePath);
-
-    let runId: string | undefined;
-    let runStatus: string | undefined;
-    if (options.executeReadyThreads !== false && readyNow.length > 0) {
-      const run = await dispatch.createAndExecuteRun(
-        workspacePath,
-        {
-          actor: options.actor,
-          adapter: options.adapter ?? 'cursor-cloud',
-          objective: `Autonomy cycle ${cycle}: coordinate ${readyNow.length} ready thread(s)`,
-          context: {
-            autonomy_cycle: cycle,
-            autonomy_ready_count: readyNow.length,
-          },
-        },
-        {
-          agents: options.agents,
-          maxSteps: options.maxSteps,
-          stepDelayMs: options.stepDelayMs,
-          space: options.space,
-          createCheckpoint: true,
-        },
-      );
-      runId = run.id;
-      runStatus = run.status;
-    }
-
-    const postExecutionMissionCycles = missionOrchestrator.runMissionOrchestratorForActiveMissions(
-      workspacePath,
-      options.actor,
-    );
-    const missionActions = [...preExecutionMissionCycles, ...postExecutionMissionCycles]
-      .reduce((total, entry) => total + entry.actions.length, 0);
-    const driftIssues =
-      dispatchRecovery.repairedRuns.length +
-      dispatchRecovery.removedCorruptRuns +
-      dispatchRecovery.warnings.length +
-      leaseReconcile.requeuedRuns.length +
-      threadRecovery.leaseState.repaired +
-      threadRecovery.leaseState.removed +
-      threadRecovery.leaseState.issues.length +
-      threadRecovery.staleClaims.reaped.length +
-      threadRecovery.staleClaims.skipped.length +
-      threadRecovery.brokenReferences.length +
-      (triggerResult?.errors ?? 0);
-
-    const report: AutonomyCycleReport = {
-      cycle,
-      readyThreads: readyNow.length,
-      triggerActions: triggerResult?.fired ?? 0,
-      missionActions,
-      repairedRuns: dispatchRecovery.repairedRuns.length,
-      requeuedRuns: leaseReconcile.requeuedRuns.length,
-      runId,
-      runStatus,
-      driftOk: driftIssues === 0,
-      driftIssues,
-    };
-    cycles.push(report);
-    writeHeartbeat(options.heartbeatFile, {
-      ts: new Date().toISOString(),
-      ...report,
-    });
-
-    const isIdle = report.readyThreads === 0 && report.triggerActions === 0;
-    if (isIdle) {
-      idleCycles += 1;
-    } else {
-      idleCycles = 0;
-    }
-
-    if (!watch && idleCycles >= maxIdleCycles) {
-      break;
-    }
-    if (cycle >= maxCycles) {
-      break;
-    }
-    await sleep(pollMs);
-  }
-
-  const finalReadyThreads = (options.space
-    ? thread.listReadyThreadsInSpace(workspacePath, options.space)
-    : thread.listReadyThreads(workspacePath)).length;
-  writeHeartbeat(options.heartbeatFile, {
-    ts: new Date().toISOString(),
-    finalReadyThreads,
-    finalDriftOk: cycles.every((entry) => entry.driftOk),
-  });
-  return {
-    cycles,
-    finalReadyThreads,
-    finalDriftOk: cycles.every((entry) => entry.driftOk),
-  };
-}
-
-function clampInt(value: number | undefined, fallback: number, min: number, max: number): number {
-  const raw = typeof value === 'number' && Number.isFinite(value) ? Math.trunc(value) : fallback;
-  return Math.min(max, Math.max(min, raw));
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-function writeHeartbeat(filePath: string | undefined, payload: Record<string, unknown>): void {
-  if (!filePath) return;
-  const absolutePath = path.resolve(filePath);
-  const dir = path.dirname(absolutePath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(absolutePath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
-}
diff --git a/packages/kernel/src/bases.test.ts b/packages/kernel/src/bases.test.ts
index 733e0de..b81f0d3 100644
--- a/packages/kernel/src/bases.test.ts
+++ b/packages/kernel/src/bases.test.ts
@@ -28,7 +28,7 @@ describe('bases generation', () => {
     const manifestPath = primitiveRegistryManifestPath(workspacePath);
     expect(fs.existsSync(manifestPath)).toBe(true);
     expect(manifest.primitives.some((primitive) => primitive.name === 'thread')).toBe(true);
-    expect(manifest.primitives.some((primitive) => primitive.name === 'skill')).toBe(true);
+    expect(manifest.primitives.some((primitive) => primitive.name === 'relationship')).toBe(true);
 
     const parsed = readPrimitiveRegistryManifest(workspacePath);
     const thread = parsed.primitives.find((primitive) => primitive.name === 'thread');
@@ -41,7 +41,7 @@ describe('bases generation', () => {
     const result = generateBasesFromPrimitiveRegistry(workspacePath);
 
     expect(result.generated.some((filePath) => filePath.endsWith('/thread.base'))).toBe(true);
-    expect(result.generated.some((filePath) => filePath.endsWith('/skill.base'))).toBe(true);
+    expect(result.generated.some((filePath) => filePath.endsWith('/relationship.base'))).toBe(true);
 
     const threadBase = path.join(workspacePath, '.workgraph/bases/thread.base');
     expect(fs.existsSync(threadBase)).toBe(true);
diff --git a/packages/kernel/src/board.test.ts b/packages/kernel/src/board.test.ts
deleted file mode 100644
index 315ee85..0000000
--- a/packages/kernel/src/board.test.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { generateKanbanBoard, syncKanbanBoard } from './board.js';
-import * as thread from './thread.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-board-core-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('board core module', () => {
-  it('groups thread statuses into board counts and default lanes', () => {
-    thread.createThread(workspacePath, 'Backlog item', 'pending', 'agent-a');
-
-    thread.createThread(workspacePath, 'Active item', 'doing', 'agent-a');
-    thread.claim(workspacePath, 'threads/active-item.md', 'agent-a');
-
-    thread.createThread(workspacePath, 'Blocked item', 'waiting', 'agent-a');
-    thread.claim(workspacePath, 'threads/blocked-item.md', 'agent-a');
-    thread.block(workspacePath, 'threads/blocked-item.md', 'agent-a', 'external/dependency');
-
-    thread.createThread(workspacePath, 'Done item', 'done', 'agent-a');
-    thread.claim(workspacePath, 'threads/done-item.md', 'agent-a');
-    thread.done(workspacePath, 'threads/done-item.md', 'agent-a', 'finished https://github.com/versatly/workgraph/pull/26');
-
-    thread.createThread(workspacePath, 'Cancelled item', 'cancelled', 'agent-a');
-    thread.cancel(workspacePath, 'threads/cancelled-item.md', 'agent-a', 'not needed');
-
-    const result = generateKanbanBoard(workspacePath, {
-      outputPath: 'ops/Board.md',
-    });
-
-    expect(result.counts).toEqual({
-      backlog: 1,
-      inProgress: 1,
-      blocked: 1,
-      done: 1,
-      cancelled: 1,
-    });
-    expect(result.content).toContain('## Backlog');
-    expect(result.content).toContain('## In Progress');
-    expect(result.content).toContain('## Blocked');
-    expect(result.content).toContain('## Done');
-    expect(result.content).not.toContain('## Cancelled');
-    expect(fs.existsSync(path.join(workspacePath, 'ops/Board.md'))).toBe(true);
-  });
-
-  it('includes cancelled lane when includeCancelled is enabled', () => {
-    thread.createThread(workspacePath, 'Cancelled item', 'cancel me', 'agent-a');
-    thread.cancel(workspacePath, 'threads/cancelled-item.md', 'agent-a', 'out of scope');
-
-    const result = generateKanbanBoard(workspacePath, {
-      includeCancelled: true,
-      outputPath: 'ops/BoardWithCancelled.md',
-    });
-
-    expect(result.content).toContain('## Cancelled');
-    expect(result.content).toContain('- [x] [[threads/cancelled-item.md|Cancelled item]]');
-  });
-
-  it('orders lane items by priority rank and title fallback', () => {
-    thread.createThread(workspacePath, 'Low task', 'low', 'agent-a', { priority: 'low' });
-    thread.createThread(workspacePath, 'High task', 'high', 'agent-a', { priority: 'high' });
-    thread.createThread(workspacePath, 'Urgent task', 'urgent', 'agent-a', { priority: 'urgent' });
-
-    const result = generateKanbanBoard(workspacePath, {
-      outputPath: 'ops/PriorityBoard.md',
-    });
-
-    const urgentIndex = result.content.indexOf('Urgent task');
-    const highIndex = result.content.indexOf('High task');
-    const lowIndex = result.content.indexOf('Low task');
-    expect(urgentIndex).toBeGreaterThanOrEqual(0);
-    expect(highIndex).toBeGreaterThanOrEqual(0);
-    expect(lowIndex).toBeGreaterThanOrEqual(0);
-    expect(urgentIndex).toBeLessThan(highIndex);
-    expect(highIndex).toBeLessThan(lowIndex);
-  });
-
-  it('syncKanbanBoard delegates to generation and writes output', () => {
-    thread.createThread(workspacePath, 'Sync item', 'sync this board', 'agent-a');
-
-    const result = syncKanbanBoard(workspacePath, {
-      outputPath: 'ops/SyncBoard.md',
-    });
-    const boardPath = path.join(workspacePath, 'ops/SyncBoard.md');
-
-    expect(result.outputPath).toBe('ops/SyncBoard.md');
-    expect(fs.existsSync(boardPath)).toBe(true);
-    expect(fs.readFileSync(boardPath, 'utf-8')).toContain('Sync item');
-  });
-
-  it('defaults output path to ops/Workgraph Board.md', () => {
-    thread.createThread(workspacePath, 'Default path item', 'default output', 'agent-a');
-
-    const result = generateKanbanBoard(workspacePath);
-    expect(result.outputPath).toBe('ops/Workgraph Board.md');
-    expect(fs.existsSync(path.join(workspacePath, 'ops/Workgraph Board.md'))).toBe(true);
-  });
-
-  it('rejects output paths that escape workspace root', () => {
-    expect(() =>
-      generateKanbanBoard(workspacePath, {
-        outputPath: '../outside-board.md',
-      }),
-    ).toThrow('Invalid board output path');
-  });
-});
diff --git a/packages/kernel/src/board.ts b/packages/kernel/src/board.ts
deleted file mode 100644
index 529ffd3..0000000
--- a/packages/kernel/src/board.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Obsidian Kanban board generation and sync helpers.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import * as store from './store.js';
-import type { PrimitiveInstance } from './types.js';
-
-export interface BoardOptions {
-  outputPath?: string;
-  includeCancelled?: boolean;
-}
-
-export interface BoardResult {
-  outputPath: string;
-  generatedAt: string;
-  counts: {
-    backlog: number;
-    inProgress: number;
-    blocked: number;
-    done: number;
-    cancelled: number;
-  };
-  content: string;
-}
-
-export function generateKanbanBoard(workspacePath: string, options: BoardOptions = {}): BoardResult {
-  const threads = store.list(workspacePath, 'thread');
-  const grouped = groupThreads(threads);
-  const includeCancelled = options.includeCancelled === true;
-
-  const lanes: Array<{ title: string; items: PrimitiveInstance[]; checkChar: string }> = [
-    { title: 'Backlog', items: grouped.open, checkChar: ' ' },
-    { title: 'In Progress', items: grouped.active, checkChar: ' ' },
-    { title: 'Blocked', items: grouped.blocked, checkChar: ' ' },
-    { title: 'Done', items: grouped.done, checkChar: 'x' },
-  ];
-  if (includeCancelled) {
-    lanes.push({ title: 'Cancelled', items: grouped.cancelled, checkChar: 'x' });
-  }
-
-  const content = renderKanbanMarkdown(lanes);
-  const relOutputPath = options.outputPath ?? 'ops/Workgraph Board.md';
-  const absOutputPath = resolvePathWithinWorkspace(workspacePath, relOutputPath);
-  const parentDir = path.dirname(absOutputPath);
-  if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
-  fs.writeFileSync(absOutputPath, content, 'utf-8');
-
-  return {
-    outputPath: path.relative(workspacePath, absOutputPath).replace(/\\/g, '/'),
-    generatedAt: new Date().toISOString(),
-    counts: {
-      backlog: grouped.open.length,
-      inProgress: grouped.active.length,
-      blocked: grouped.blocked.length,
-      done: grouped.done.length,
-      cancelled: grouped.cancelled.length,
-    },
-    content,
-  };
-}
-
-export function syncKanbanBoard(workspacePath: string, options: BoardOptions = {}): BoardResult {
-  return generateKanbanBoard(workspacePath, options);
-}
-
-function groupThreads(threads: PrimitiveInstance[]): Record<'open' | 'active' | 'blocked' | 'done' | 'cancelled', PrimitiveInstance[]> {
-  const groups = {
-    open: [] as PrimitiveInstance[],
-    active: [] as PrimitiveInstance[],
-    blocked: [] as PrimitiveInstance[],
-    done: [] as PrimitiveInstance[],
-    cancelled: [] as PrimitiveInstance[],
-  };
-
-  for (const thread of threads) {
-    const status = String(thread.fields.status ?? 'open');
-    switch (status) {
-      case 'active':
-        groups.active.push(thread);
-        break;
-      case 'blocked':
-        groups.blocked.push(thread);
-        break;
-      case 'done':
-        groups.done.push(thread);
-        break;
-      case 'cancelled':
-        groups.cancelled.push(thread);
-        break;
-      case 'open':
-      default:
-        groups.open.push(thread);
-        break;
-    }
-  }
-
-  const byPriority = (a: PrimitiveInstance, b: PrimitiveInstance): number => {
-    const rank = (value: unknown): number => {
-      switch (String(value ?? 'medium')) {
-        case 'urgent': return 0;
-        case 'high': return 1;
-        case 'medium': return 2;
-        case 'low': return 3;
-        default: return 4;
-      }
-    };
-    return rank(a.fields.priority) - rank(b.fields.priority) || String(a.fields.title).localeCompare(String(b.fields.title));
-  };
-
-  groups.open.sort(byPriority);
-  groups.active.sort(byPriority);
-  groups.blocked.sort(byPriority);
-  groups.done.sort(byPriority);
-  groups.cancelled.sort(byPriority);
-  return groups;
-}
-
-function renderKanbanMarkdown(lanes: Array<{ title: string; items: PrimitiveInstance[]; checkChar: string }>): string {
-  const settings = {
-    'kanban-plugin': 'board',
-  };
-  const lines: string[] = [
-    '---',
-    'kanban-plugin: board',
-    '---',
-    '',
-  ];
-
-  for (const lane of lanes) {
-    lines.push(`## ${lane.title}`);
-    lines.push('');
-    for (const thread of lane.items) {
-      const title = String(thread.fields.title ?? thread.path);
-      const priority = String(thread.fields.priority ?? 'medium');
-      lines.push(`- [${lane.checkChar}] [[${thread.path}|${title}]] (#${priority})`);
-    }
-    lines.push('');
-    lines.push('');
-    lines.push('');
-  }
-
-  lines.push('%% kanban:settings');
-  lines.push('```');
-  lines.push(JSON.stringify(settings));
-  lines.push('```');
-  lines.push('%%');
-  lines.push('');
-  return lines.join('\n');
-}
-
-function resolvePathWithinWorkspace(workspacePath: string, outputPath: string): string {
-  const base = path.resolve(workspacePath);
-  const resolved = path.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path.sep) && resolved !== base) {
-    throw new Error(`Invalid board output path: ${outputPath}`);
-  }
-  return resolved;
-}
diff --git a/packages/kernel/src/capability.test.ts b/packages/kernel/src/capability.test.ts
deleted file mode 100644
index 0310f84..0000000
--- a/packages/kernel/src/capability.test.ts
+++ /dev/null
@@ -1,186 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as agent from './agent.js';
-import {
-  buildAgentCapabilityRegistry,
-  matchThreadToAgent,
-  matchThreadToCapabilityProfile,
-  readThreadCapabilityRequirements,
-  searchCapabilityRegistry,
-} from './capability.js';
-import * as policy from './policy.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import { initWorkspace } from './workspace.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-capability-'));
-  initWorkspace(workspacePath, { createReadme: false });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('capability registry and matching', () => {
-  it('builds a merged agent capability registry from policy and presence', () => {
-    policy.upsertParty(
-      workspacePath,
-      'ops-agent',
-      {
-        roles: ['ops'],
-        capabilities: ['thread:claim', 'skill:incident-triage', 'adapter:shell-worker'],
-      },
-      {
-        actor: 'system',
-        skipAuthorization: true,
-      },
-    );
-    agent.heartbeat(workspacePath, 'ops-agent', {
-      actor: 'system',
-      capabilities: ['domain:ops', 'skill:incident-triage'],
-    });
-
-    const registry = buildAgentCapabilityRegistry(workspacePath);
-    const opsAgent = registry.agents.find((entry) => entry.agentName === 'ops-agent');
-
-    expect(opsAgent).toBeDefined();
-    expect(opsAgent?.capabilities).toEqual([
-      'adapter:shell-worker',
-      'domain:ops',
-      'skill:incident-triage',
-      'thread:claim',
-    ]);
-    expect(opsAgent?.skills).toEqual(['incident-triage']);
-    expect(opsAgent?.adapters).toEqual(['shell-worker']);
-    expect(opsAgent?.sources).toEqual(['policy', 'presence']);
-    expect(registry.capabilities.find((entry) => entry.capability === 'domain:ops')?.agents).toEqual(['ops-agent']);
-  });
-
-  it('supports capability search by token or agent identifier', () => {
-    policy.upsertParty(
-      workspacePath,
-      'router-agent',
-      {
-        roles: ['ops'],
-        capabilities: ['dispatch:run', 'thread:claim'],
-      },
-      {
-        actor: 'system',
-        skipAuthorization: true,
-      },
-    );
-
-    const dispatchMatches = searchCapabilityRegistry(workspacePath, 'dispatch');
-    expect(dispatchMatches).toHaveLength(1);
-    expect(dispatchMatches[0].capability).toBe('dispatch:run');
-    expect(dispatchMatches[0].agents).toContain('router-agent');
-
-    const agentMatches = searchCapabilityRegistry(workspacePath, 'router');
-    expect(agentMatches.map((entry) => entry.capability)).toContain('dispatch:run');
-    expect(agentMatches.map((entry) => entry.capability)).toContain('thread:claim');
-  });
-
-  it('reads thread requirements and computes missing capability dimensions', () => {
-    const createdThread = thread.createThread(
-      workspacePath,
-      'Ops triage',
-      'Perform triage using shell tooling',
-      'system',
-    );
-    const updatedThread = store.update(
-      workspacePath,
-      createdThread.path,
-      {
-        required_capabilities: ['domain:ops'],
-        required_skills: ['incident-triage'],
-        required_adapters: ['shell-worker'],
-        tags: [
-          'requires:capability:dispatch:run',
-          'requires:skill:postmortem-writing',
-          'requires:adapter:cursor-cloud',
-        ],
-      },
-      undefined,
-      'system',
-    );
-
-    const requirements = readThreadCapabilityRequirements(updatedThread);
-    expect(requirements.capabilities).toEqual(['domain:ops', 'dispatch:run']);
-    expect(requirements.skills).toEqual(['incident-triage', 'postmortem-writing']);
-    expect(requirements.adapters).toEqual(['shell-worker', 'cursor-cloud']);
-
-    const matched = matchThreadToCapabilityProfile(updatedThread, {
-      capabilities: [
-        'domain:*',
-        'dispatch:run',
-        'skill:incident-triage',
-        'skill:postmortem-writing',
-        'adapter:shell-worker',
-        'adapter:cursor-cloud',
-      ],
-    });
-    expect(matched.matched).toBe(true);
-    expect(matched.missing).toEqual({
-      capabilities: [],
-      skills: [],
-      adapters: [],
-    });
-
-    const unmatched = matchThreadToCapabilityProfile(updatedThread, {
-      capabilities: ['domain:ops'],
-      skills: ['incident-triage'],
-      adapters: ['shell-worker'],
-    });
-    expect(unmatched.matched).toBe(false);
-    expect(unmatched.missing.capabilities).toEqual(['dispatch:run']);
-    expect(unmatched.missing.skills).toEqual(['postmortem-writing']);
-    expect(unmatched.missing.adapters).toEqual(['cursor-cloud']);
-  });
-
-  it('matches a thread to an agent profile resolved from registry', () => {
-    policy.upsertParty(
-      workspacePath,
-      'router-agent',
-      {
-        roles: ['ops'],
-        capabilities: ['domain:ops', 'dispatch:run', 'skill:incident-triage', 'adapter:shell-worker'],
-      },
-      {
-        actor: 'system',
-        skipAuthorization: true,
-      },
-    );
-    agent.heartbeat(workspacePath, 'router-agent', {
-      actor: 'system',
-      capabilities: ['domain:ops', 'dispatch:run', 'skill:incident-triage', 'adapter:shell-worker'],
-    });
-
-    const createdThread = thread.createThread(
-      workspacePath,
-      'Route incident',
-      'Dispatch and triage',
-      'system',
-    );
-    store.update(
-      workspacePath,
-      createdThread.path,
-      {
-        required_capabilities: ['domain:ops', 'dispatch:run'],
-        required_skills: ['incident-triage'],
-        required_adapters: ['shell-worker'],
-      },
-      undefined,
-      'system',
-    );
-
-    const match = matchThreadToAgent(workspacePath, 'route-incident', 'router-agent');
-    expect(match.matched).toBe(true);
-    expect(match.profile.agentName).toBe('router-agent');
-    expect(match.profile.capabilities).toContain('dispatch:run');
-  });
-});
diff --git a/packages/kernel/src/capability.ts b/packages/kernel/src/capability.ts
deleted file mode 100644
index c4c6bd4..0000000
--- a/packages/kernel/src/capability.ts
+++ /dev/null
@@ -1,342 +0,0 @@
-/**
- * Agent capability registry and thread requirement matching.
- */
-
-import * as policy from './policy.js';
-import * as store from './store.js';
-import type { PrimitiveInstance } from './types.js';
-
-export const REQUIREMENT_TAG_PREFIXES = {
-  capability: 'requires:capability:',
-  skill: 'requires:skill:',
-  adapter: 'requires:adapter:',
-} as const;
-
-export type CapabilitySource = 'policy' | 'presence';
-
-export interface AgentCapabilityProfile {
-  agentName: string;
-  capabilities: string[];
-  skills: string[];
-  adapters: string[];
-  sources: CapabilitySource[];
-}
-
-export interface CapabilityRegistryEntry {
-  capability: string;
-  agents: string[];
-}
-
-export interface AgentCapabilityRegistry {
-  generatedAt: string;
-  agents: AgentCapabilityProfile[];
-  capabilities: CapabilityRegistryEntry[];
-}
-
-export interface ThreadCapabilityRequirements {
-  capabilities: string[];
-  skills: string[];
-  adapters: string[];
-}
-
-export interface CapabilityMatchProfile {
-  capabilities?: string[];
-  skills?: string[];
-  adapters?: string[];
-}
-
-export interface ThreadCapabilityMatch {
-  thread: PrimitiveInstance;
-  requirements: ThreadCapabilityRequirements;
-  missing: ThreadCapabilityRequirements;
-  matched: boolean;
-}
-
-export interface ThreadAgentCapabilityMatch extends ThreadCapabilityMatch {
-  profile: AgentCapabilityProfile;
-}
-
-export function buildAgentCapabilityRegistry(workspacePath: string): AgentCapabilityRegistry {
-  const byAgent = new Map<string, {
-    capabilities: Set<string>;
-    sources: Set<CapabilitySource>;
-  }>();
-
-  const ensureAgent = (agentName: string) => {
-    const normalizedAgent = normalizeToken(agentName);
-    if (!normalizedAgent) return null;
-    const existing = byAgent.get(normalizedAgent);
-    if (existing) return existing;
-    const created = {
-      capabilities: new Set<string>(),
-      sources: new Set<CapabilitySource>(),
-    };
-    byAgent.set(normalizedAgent, created);
-    return created;
-  };
-
-  const policyRegistry = policy.loadPolicyRegistry(workspacePath);
-  for (const party of Object.values(policyRegistry.parties)) {
-    const agent = ensureAgent(party.id);
-    if (!agent) continue;
-    for (const capability of asStringList(party.capabilities)) {
-      agent.capabilities.add(capability);
-    }
-    if (agent.capabilities.size > 0) {
-      agent.sources.add('policy');
-    }
-  }
-
-  const presenceEntries = store.list(workspacePath, 'presence');
-  for (const presence of presenceEntries) {
-    const fallbackName = basenameWithoutExtension(presence.path);
-    const agent = ensureAgent(String(presence.fields.name ?? fallbackName));
-    if (!agent) continue;
-    const capabilities = asStringList(presence.fields.capabilities);
-    for (const capability of capabilities) {
-      agent.capabilities.add(capability);
-    }
-    if (capabilities.length > 0) {
-      agent.sources.add('presence');
-    }
-  }
-
-  const agents: AgentCapabilityProfile[] = [...byAgent.entries()]
-    .map(([agentName, value]) => {
-      const capabilities = [...value.capabilities].sort((a, b) => a.localeCompare(b));
-      const skills = extractScopedValues(capabilities, 'skill:');
-      const adapters = extractScopedValues(capabilities, 'adapter:');
-      return {
-        agentName,
-        capabilities,
-        skills,
-        adapters,
-        sources: [...value.sources].sort((a, b) => a.localeCompare(b)),
-      };
-    })
-    .sort((a, b) => a.agentName.localeCompare(b.agentName));
-
-  const capabilityMap = new Map<string, Set<string>>();
-  for (const agent of agents) {
-    for (const capability of agent.capabilities) {
-      const existing = capabilityMap.get(capability);
-      if (existing) {
-        existing.add(agent.agentName);
-      } else {
-        capabilityMap.set(capability, new Set([agent.agentName]));
-      }
-    }
-  }
-  const capabilities: CapabilityRegistryEntry[] = [...capabilityMap.entries()]
-    .map(([capability, agentsWithCapability]) => ({
-      capability,
-      agents: [...agentsWithCapability].sort((a, b) => a.localeCompare(b)),
-    }))
-    .sort((a, b) => a.capability.localeCompare(b.capability));
-
-  return {
-    generatedAt: new Date().toISOString(),
-    agents,
-    capabilities,
-  };
-}
-
-export function searchCapabilityRegistry(
-  workspacePath: string,
-  query: string,
-): CapabilityRegistryEntry[] {
-  const registry = buildAgentCapabilityRegistry(workspacePath);
-  const normalizedQuery = normalizeToken(query);
-  if (!normalizedQuery) return registry.capabilities;
-  return registry.capabilities.filter((entry) =>
-    entry.capability.includes(normalizedQuery) ||
-    entry.agents.some((agentName) => agentName.includes(normalizedQuery))
-  );
-}
-
-export function resolveAgentCapabilityProfile(
-  workspacePath: string,
-  agentName: string,
-): AgentCapabilityProfile {
-  const normalizedAgent = normalizeToken(agentName);
-  if (!normalizedAgent) {
-    throw new Error('Agent name is required.');
-  }
-  const registry = buildAgentCapabilityRegistry(workspacePath);
-  const existing = registry.agents.find((entry) => entry.agentName === normalizedAgent);
-  if (existing) return existing;
-  return {
-    agentName: normalizedAgent,
-    capabilities: [],
-    skills: [],
-    adapters: [],
-    sources: [],
-  };
-}
-
-export function resolveThreadInstance(
-  workspacePath: string,
-  threadRef: string,
-): PrimitiveInstance | null {
-  const normalizedRef = normalizeThreadRef(threadRef);
-  if (!normalizedRef) return null;
-  const direct = store.read(workspacePath, normalizedRef);
-  if (direct?.type === 'thread') return direct;
-  const slug = basenameWithoutExtension(normalizedRef);
-  if (!slug) return null;
-  return store.list(workspacePath, 'thread')
-    .find((candidate) => basenameWithoutExtension(candidate.path) === slug) ?? null;
-}
-
-export function matchThreadToAgent(
-  workspacePath: string,
-  threadRef: string,
-  agentName: string,
-): ThreadAgentCapabilityMatch {
-  const threadInstance = resolveThreadInstance(workspacePath, threadRef);
-  if (!threadInstance) {
-    throw new Error(`Thread not found: ${threadRef}`);
-  }
-  const profile = resolveAgentCapabilityProfile(workspacePath, agentName);
-  return {
-    ...matchThreadToCapabilityProfile(threadInstance, profile),
-    profile,
-  };
-}
-
-export function readThreadCapabilityRequirements(
-  threadInstance: PrimitiveInstance,
-): ThreadCapabilityRequirements {
-  const capabilityRequirements = dedupeStrings([
-    ...asStringList(threadInstance.fields.required_capabilities),
-    ...asStringList(threadInstance.fields.requiredCapabilities),
-    ...extractTagRequirements(threadInstance.fields.tags, REQUIREMENT_TAG_PREFIXES.capability),
-  ]);
-  const skillRequirements = dedupeStrings([
-    ...asStringList(threadInstance.fields.required_skills),
-    ...asStringList(threadInstance.fields.requiredSkills),
-    ...extractTagRequirements(threadInstance.fields.tags, REQUIREMENT_TAG_PREFIXES.skill),
-  ]);
-  const adapterRequirements = dedupeStrings([
-    ...asStringList(threadInstance.fields.required_adapters),
-    ...asStringList(threadInstance.fields.requiredAdapters),
-    ...extractTagRequirements(threadInstance.fields.tags, REQUIREMENT_TAG_PREFIXES.adapter),
-  ]);
-
-  return {
-    capabilities: capabilityRequirements,
-    skills: skillRequirements,
-    adapters: adapterRequirements,
-  };
-}
-
-export function matchThreadToCapabilityProfile(
-  threadInstance: PrimitiveInstance,
-  profile: CapabilityMatchProfile,
-): ThreadCapabilityMatch {
-  const normalizedCapabilities = dedupeStrings(asStringList(profile.capabilities));
-  const normalizedSkills = dedupeStrings([
-    ...extractScopedValues(normalizedCapabilities, 'skill:'),
-    ...asStringList(profile.skills),
-  ]);
-  const normalizedAdapters = dedupeStrings([
-    ...extractScopedValues(normalizedCapabilities, 'adapter:'),
-    ...asStringList(profile.adapters),
-  ]);
-  const requirements = readThreadCapabilityRequirements(threadInstance);
-  const missingCapabilities = requirements.capabilities
-    .filter((requiredCapability) => !capabilitySatisfied(normalizedCapabilities, requiredCapability));
-  const missingSkills = requirements.skills
-    .filter((requiredSkill) => !normalizedSkills.includes(requiredSkill));
-  const missingAdapters = requirements.adapters
-    .filter((requiredAdapter) => !normalizedAdapters.includes(requiredAdapter));
-
-  return {
-    thread: threadInstance,
-    requirements,
-    missing: {
-      capabilities: missingCapabilities,
-      skills: missingSkills,
-      adapters: missingAdapters,
-    },
-    matched: missingCapabilities.length === 0 && missingSkills.length === 0 && missingAdapters.length === 0,
-  };
-}
-
-export function capabilitySatisfied(grantedCapabilities: string[], requiredCapability: string): boolean {
-  const normalizedRequired = normalizeToken(requiredCapability);
-  if (!normalizedRequired) return true;
-  for (const grantedCapability of asStringList(grantedCapabilities)) {
-    if (grantedCapability === '*') return true;
-    if (grantedCapability === normalizedRequired) return true;
-    if (
-      grantedCapability.endsWith(':*') &&
-      normalizedRequired.startsWith(`${grantedCapability.slice(0, -2)}:`)
-    ) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function normalizeThreadRef(value: unknown): string {
-  const raw = String(value ?? '').trim();
-  if (!raw) return '';
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]')
-    ? raw.slice(2, -2)
-    : raw;
-  const primary = unwrapped.split('|')[0].trim().split('#')[0].trim();
-  if (!primary) return '';
-  if (primary.startsWith('threads/')) {
-    return primary.endsWith('.md') ? primary : `${primary}.md`;
-  }
-  if (primary.includes('/')) {
-    return primary.endsWith('.md') ? primary : `${primary}.md`;
-  }
-  return `threads/${primary}.md`;
-}
-
-function extractTagRequirements(value: unknown, prefix: string): string[] {
-  return asStringList(value)
-    .filter((tag) => tag.startsWith(prefix))
-    .map((tag) => tag.slice(prefix.length))
-    .filter(Boolean);
-}
-
-function extractScopedValues(tokens: string[], prefix: string): string[] {
-  return dedupeStrings(tokens
-    .filter((token) => token.startsWith(prefix))
-    .map((token) => token.slice(prefix.length))
-    .filter(Boolean));
-}
-
-function asStringList(value: unknown): string[] {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => normalizeToken(entry))
-      .filter(Boolean);
-  }
-  if (typeof value === 'string') {
-    return value
-      .split(',')
-      .map((entry) => normalizeToken(entry))
-      .filter(Boolean);
-  }
-  return [];
-}
-
-function dedupeStrings(values: string[]): string[] {
-  return [...new Set(values.map((value) => normalizeToken(value)).filter(Boolean))];
-}
-
-function basenameWithoutExtension(value: string): string {
-  const normalized = String(value ?? '').replace(/\\/g, '/');
-  const basename = normalized.slice(normalized.lastIndexOf('/') + 1);
-  return basename.replace(/\.md$/i, '').trim().toLowerCase();
-}
-
-function normalizeToken(value: unknown): string {
-  return String(value ?? '')
-    .trim()
-    .toLowerCase();
-}
diff --git a/packages/kernel/src/clawdapus.test.ts b/packages/kernel/src/clawdapus.test.ts
deleted file mode 100644
index 025397c..0000000
--- a/packages/kernel/src/clawdapus.test.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { loadRegistry, saveRegistry } from './registry.js';
-import {
-  DEFAULT_CLAWDAPUS_SKILL_URL,
-  installClawdapusSkill,
-} from './clawdapus.js';
-import { loadSkill } from './skill.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-clawdapus-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('clawdapus optional integration', () => {
-  it('installs clawdapus skill into workspace via injected source loader', async () => {
-    const result = await installClawdapusSkill(workspacePath, {
-      actor: 'agent-ops',
-      fetchSkillMarkdown: async (sourceUrl) => {
-        expect(sourceUrl).toBe(DEFAULT_CLAWDAPUS_SKILL_URL);
-        return '# Clawdapus\n\nImported content.';
-      },
-    });
-
-    expect(result.provider).toBe('clawdapus');
-    expect(result.replacedExisting).toBe(false);
-    expect(result.skill.path).toBe('skills/clawdapus/SKILL.md');
-    expect(result.skill.fields.distribution).toBe('clawdapus-optional-integration');
-    expect(result.skill.fields.owner).toBe('agent-ops');
-    expect(result.skill.fields.tags).toEqual(
-      expect.arrayContaining(['clawdapus', 'optional-integration']),
-    );
-
-    const loaded = loadSkill(workspacePath, 'clawdapus');
-    expect(loaded.body).toContain('Imported content.');
-  });
-
-  it('refuses to overwrite an existing imported skill unless force is set', async () => {
-    await installClawdapusSkill(workspacePath, {
-      actor: 'agent-ops',
-      fetchSkillMarkdown: async () => '# v1',
-    });
-
-    await expect(
-      installClawdapusSkill(workspacePath, {
-        actor: 'agent-ops',
-        fetchSkillMarkdown: async () => '# v2',
-      }),
-    ).rejects.toThrow('Use --force to refresh it from source.');
-  });
-
-  it('refreshes existing skill content when force is true', async () => {
-    await installClawdapusSkill(workspacePath, {
-      actor: 'agent-ops',
-      fetchSkillMarkdown: async () => '# v1',
-    });
-
-    const refreshed = await installClawdapusSkill(workspacePath, {
-      actor: 'agent-ops',
-      force: true,
-      fetchSkillMarkdown: async () => '# v2',
-    });
-
-    expect(refreshed.replacedExisting).toBe(true);
-    expect(loadSkill(workspacePath, 'clawdapus').body).toContain('# v2');
-  });
-
-  it('propagates source fetch errors with context', async () => {
-    await expect(
-      installClawdapusSkill(workspacePath, {
-        actor: 'agent-ops',
-        fetchSkillMarkdown: async () => {
-          throw new Error('network down');
-        },
-      }),
-    ).rejects.toThrow('network down');
-  });
-});
diff --git a/packages/kernel/src/clawdapus.ts b/packages/kernel/src/clawdapus.ts
deleted file mode 100644
index 6108d31..0000000
--- a/packages/kernel/src/clawdapus.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import {
-  fetchSkillMarkdownFromUrl,
-  installSkillIntegration,
-  type InstallSkillIntegrationOptions,
-  type InstallSkillIntegrationResult,
-  type SkillIntegrationProvider,
-} from './integration-core.js';
-
-export const DEFAULT_CLAWDAPUS_SKILL_URL =
-  'https://raw.githubusercontent.com/mostlydev/clawdapus/master/skills/clawdapus/SKILL.md';
-
-export const CLAWDAPUS_INTEGRATION_PROVIDER: SkillIntegrationProvider = {
-  id: 'clawdapus',
-  defaultTitle: 'clawdapus',
-  defaultSourceUrl: DEFAULT_CLAWDAPUS_SKILL_URL,
-  distribution: 'clawdapus-optional-integration',
-  defaultTags: ['clawdapus'],
-  userAgent: '@versatly/workgraph clawdapus-optional-integration',
-};
-
-export type InstallClawdapusSkillOptions = InstallSkillIntegrationOptions;
-export type InstallClawdapusSkillResult = InstallSkillIntegrationResult;
-
-export async function installClawdapusSkill(
-  workspacePath: string,
-  options: InstallClawdapusSkillOptions,
-): Promise<InstallClawdapusSkillResult> {
-  return installSkillIntegration(
-    workspacePath,
-    CLAWDAPUS_INTEGRATION_PROVIDER,
-    options,
-  );
-}
-
-export async function fetchClawdapusSkillMarkdown(sourceUrl: string): Promise<string> {
-  return fetchSkillMarkdownFromUrl(sourceUrl, CLAWDAPUS_INTEGRATION_PROVIDER.userAgent);
-}
diff --git a/packages/kernel/src/command-center.test.ts b/packages/kernel/src/command-center.test.ts
deleted file mode 100644
index 6a5051b..0000000
--- a/packages/kernel/src/command-center.test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { createThread, claim, done, block } from './thread.js';
-import { generateCommandCenter } from './command-center.js';
-import { readAll } from './ledger.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-command-center-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('command-center', () => {
-  it('generates a markdown operational snapshot with thread and claim state', () => {
-    createThread(workspacePath, 'Open task', 'open', 'agent-lead');
-    createThread(workspacePath, 'Active task', 'active', 'agent-lead');
-    claim(workspacePath, 'threads/active-task.md', 'agent-worker');
-
-    createThread(workspacePath, 'Blocked task', 'blocked', 'agent-lead');
-    claim(workspacePath, 'threads/blocked-task.md', 'agent-worker');
-    block(workspacePath, 'threads/blocked-task.md', 'agent-worker', 'external/api', 'waiting');
-
-    createThread(workspacePath, 'Done task', 'done', 'agent-lead');
-    claim(workspacePath, 'threads/done-task.md', 'agent-worker');
-    done(workspacePath, 'threads/done-task.md', 'agent-worker', 'complete https://github.com/versatly/workgraph/pull/25');
-
-    const result = generateCommandCenter(workspacePath, {
-      actor: 'agent-observer',
-      outputPath: 'ops/Command Center.md',
-      recentCount: 10,
-    });
-
-    const absOutputPath = path.join(workspacePath, 'ops/Command Center.md');
-    expect(fs.existsSync(absOutputPath)).toBe(true);
-    expect(result.outputPath).toBe('ops/Command Center.md');
-    expect(result.stats.totalThreads).toBe(4);
-    expect(result.stats.openThreads).toBe(1);
-    expect(result.stats.activeThreads).toBe(1);
-    expect(result.stats.blockedThreads).toBe(1);
-    expect(result.stats.doneThreads).toBe(1);
-
-    const content = fs.readFileSync(absOutputPath, 'utf-8');
-    expect(content).toContain('# Workgraph Command Center');
-    expect(content).toContain('## Open Threads');
-    expect(content).toContain('## Active Claims');
-    expect(content).toContain('## Recent Ledger Activity');
-    expect(content).toContain('Open task');
-
-    const entries = readAll(workspacePath);
-    const ccEntries = entries.filter((entry) => entry.type === 'command-center');
-    expect(ccEntries).toHaveLength(1);
-    expect(ccEntries[0].target).toBe('ops/Command Center.md');
-  });
-
-  it('rejects output paths outside of workspace', () => {
-    expect(() => generateCommandCenter(workspacePath, { outputPath: '../outside.md' }))
-      .toThrow('Invalid command-center output path');
-  });
-});
diff --git a/packages/kernel/src/command-center.ts b/packages/kernel/src/command-center.ts
deleted file mode 100644
index 337ad0c..0000000
--- a/packages/kernel/src/command-center.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-/**
- * Command center generator for human + agent operational visibility.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import * as ledger from './ledger.js';
-import * as store from './store.js';
-
-export interface CommandCenterOptions {
-  outputPath?: string;
-  actor?: string;
-  recentCount?: number;
-}
-
-export interface CommandCenterResult {
-  outputPath: string;
-  stats: {
-    totalThreads: number;
-    openThreads: number;
-    activeThreads: number;
-    blockedThreads: number;
-    doneThreads: number;
-    activeClaims: number;
-    recentEvents: number;
-  };
-  content: string;
-}
-
-export function generateCommandCenter(workspacePath: string, options: CommandCenterOptions = {}): CommandCenterResult {
-  const actor = options.actor ?? 'system';
-  const recentCount = options.recentCount ?? 15;
-  const relOutputPath = options.outputPath ?? 'Command Center.md';
-  const absOutputPath = resolvePathWithinWorkspace(workspacePath, relOutputPath);
-  const normalizedOutputPath = path.relative(workspacePath, absOutputPath).replace(/\\/g, '/');
-
-  const allThreads = store.list(workspacePath, 'thread');
-  const openThreads = allThreads.filter(thread => thread.fields.status === 'open');
-  const activeThreads = allThreads.filter(thread => thread.fields.status === 'active');
-  const blockedThreads = allThreads.filter(thread => thread.fields.status === 'blocked');
-  const doneThreads = allThreads.filter(thread => thread.fields.status === 'done');
-  const claims = ledger.allClaims(workspacePath);
-  const recentEvents = ledger.recent(workspacePath, recentCount);
-
-  const content = renderCommandCenter({
-    generatedAt: new Date().toISOString(),
-    openThreads,
-    activeThreads,
-    blockedThreads,
-    doneThreads,
-    claims: [...claims.entries()].map(([target, owner]) => ({ target, owner })),
-    recentEvents,
-  });
-
-  const parentDir = path.dirname(absOutputPath);
-  if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
-  const existed = fs.existsSync(absOutputPath);
-  fs.writeFileSync(absOutputPath, content, 'utf-8');
-
-  ledger.append(
-    workspacePath,
-    actor,
-    existed ? 'update' : 'create',
-    normalizedOutputPath,
-    'command-center',
-    {
-      generated: true,
-      open_threads: openThreads.length,
-      active_claims: claims.size,
-      recent_events: recentEvents.length,
-    }
-  );
-
-  return {
-    outputPath: normalizedOutputPath,
-    stats: {
-      totalThreads: allThreads.length,
-      openThreads: openThreads.length,
-      activeThreads: activeThreads.length,
-      blockedThreads: blockedThreads.length,
-      doneThreads: doneThreads.length,
-      activeClaims: claims.size,
-      recentEvents: recentEvents.length,
-    },
-    content,
-  };
-}
-
-function resolvePathWithinWorkspace(workspacePath: string, outputPath: string): string {
-  const base = path.resolve(workspacePath);
-  const resolved = path.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path.sep) && resolved !== base) {
-    throw new Error(`Invalid command-center output path: ${outputPath}`);
-  }
-  return resolved;
-}
-
-function renderCommandCenter(input: {
-  generatedAt: string;
-  openThreads: Array<{ path: string; fields: Record<string, unknown> }>;
-  activeThreads: Array<{ path: string; fields: Record<string, unknown> }>;
-  blockedThreads: Array<{ path: string; fields: Record<string, unknown> }>;
-  doneThreads: Array<{ path: string; fields: Record<string, unknown> }>;
-  claims: Array<{ target: string; owner: string }>;
-  recentEvents: Array<{ ts: string; op: string; actor: string; target: string }>;
-}): string {
-  const header = [
-    '# Workgraph Command Center',
-    '',
-    `Generated: ${input.generatedAt}`,
-    '',
-  ];
-
-  const statusBlock = [
-    '## Thread Status',
-    '',
-    `- Open: ${input.openThreads.length}`,
-    `- Active: ${input.activeThreads.length}`,
-    `- Blocked: ${input.blockedThreads.length}`,
-    `- Done: ${input.doneThreads.length}`,
-    '',
-  ];
-
-  const openTable = [
-    '## Open Threads',
-    '',
-    '| Priority | Title | Path |',
-    '|---|---|---|',
-    ...(input.openThreads.length > 0
-      ? input.openThreads.map(thread =>
-          `| ${String(thread.fields.priority ?? 'medium')} | ${String(thread.fields.title ?? 'Untitled')} | \`${thread.path}\` |`)
-      : ['| - | None | - |']),
-    '',
-  ];
-
-  const claimsSection = [
-    '## Active Claims',
-    '',
-    ...(input.claims.length > 0
-      ? input.claims.map(claim => `- ${claim.owner} -> \`${claim.target}\``)
-      : ['- None']),
-    '',
-  ];
-
-  const blockedSection = [
-    '## Blocked Threads',
-    '',
-    ...(input.blockedThreads.length > 0
-      ? input.blockedThreads.map(thread => {
-          const deps = Array.isArray(thread.fields.deps) ? thread.fields.deps.join(', ') : '';
-          return `- ${String(thread.fields.title ?? thread.path)} (\`${thread.path}\`)${deps ? ` blocked by: ${deps}` : ''}`;
-        })
-      : ['- None']),
-    '',
-  ];
-
-  const recentSection = [
-    '## Recent Ledger Activity',
-    '',
-    ...(input.recentEvents.length > 0
-      ? input.recentEvents.map(event => `- ${event.ts} ${event.op} ${event.actor} -> \`${event.target}\``)
-      : ['- No activity']),
-    '',
-  ];
-
-  return [
-    ...header,
-    ...statusBlock,
-    ...openTable,
-    ...claimsSection,
-    ...blockedSection,
-    ...recentSection,
-  ].join('\n');
-}
diff --git a/packages/kernel/src/context-graph-contract-definitions.ts b/packages/kernel/src/context-graph-contract-definitions.ts
index 80a28a0..bc77525 100644
--- a/packages/kernel/src/context-graph-contract-definitions.ts
+++ b/packages/kernel/src/context-graph-contract-definitions.ts
@@ -4,27 +4,19 @@ import type {
   WorkgraphLensId,
 } from './types.js';
 
-export const CORE_CONTEXT_GRAPH_CONTRACT_VERSION = '1.1.0';
+export const CORE_CONTEXT_GRAPH_CONTRACT_VERSION = '2.0.0';
 
 const CORE_CONTEXT_PRIMITIVE_ORDER = [
   'agent',
   'checkpoint',
-  'client',
   'conversation',
   'decision',
   'fact',
-  'incident',
-  'lesson',
-  'onboarding',
-  'person',
+  'org',
   'plan-step',
   'policy',
-  'project',
-  'run',
-  'skill',
   'space',
   'thread',
-  'trigger',
 ] as const;
 
 export type CoreContextPrimitiveName = (typeof CORE_CONTEXT_PRIMITIVE_ORDER)[number];
@@ -80,19 +72,19 @@ export const CORE_CONTEXT_QUERY_FILTER_KEYS = [
 export const CORE_CONTEXT_LENS_CONTRACT: ReadonlyArray<CoreContextLensContract> = [
   {
     id: 'my-work',
-    primitives: ['thread', 'conversation', 'plan-step'],
+    primitives: ['thread', 'conversation', 'plan-step', 'checkpoint'],
   },
   {
     id: 'team-risk',
-    primitives: ['thread', 'conversation', 'plan-step', 'incident', 'run'],
+    primitives: ['thread', 'conversation', 'plan-step', 'checkpoint'],
   },
   {
     id: 'customer-health',
-    primitives: ['thread', 'conversation', 'plan-step', 'incident', 'client'],
+    primitives: ['org', 'thread', 'conversation', 'fact', 'decision'],
   },
   {
     id: 'exec-brief',
-    primitives: ['thread', 'conversation', 'plan-step', 'decision', 'run'],
+    primitives: ['org', 'thread', 'conversation', 'decision', 'checkpoint'],
   },
 ];
 
@@ -105,10 +97,6 @@ const CORE_CONTEXT_PRIMITIVES: Readonly<Record<CoreContextPrimitiveName, Omit<Co
     directory: 'checkpoints',
     requiredFields: ['title', 'actor', 'summary', 'created', 'updated'],
   },
-  client: {
-    directory: 'clients',
-    requiredFields: ['name', 'created', 'updated'],
-  },
   conversation: {
     directory: 'conversations',
     requiredFields: ['title', 'status', 'created', 'updated'],
@@ -121,22 +109,10 @@ const CORE_CONTEXT_PRIMITIVES: Readonly<Record<CoreContextPrimitiveName, Omit<Co
     directory: 'facts',
     requiredFields: ['subject', 'predicate', 'object', 'created', 'updated'],
   },
-  incident: {
-    directory: 'incidents',
+  org: {
+    directory: 'orgs',
     requiredFields: ['title', 'created', 'updated'],
   },
-  lesson: {
-    directory: 'lessons',
-    requiredFields: ['title', 'date'],
-  },
-  onboarding: {
-    directory: 'onboarding',
-    requiredFields: ['title', 'actor', 'created', 'updated'],
-  },
-  person: {
-    directory: 'people',
-    requiredFields: ['name', 'created', 'updated'],
-  },
   'plan-step': {
     directory: 'plan-steps',
     requiredFields: ['title', 'status', 'progress', 'created', 'updated'],
@@ -145,18 +121,6 @@ const CORE_CONTEXT_PRIMITIVES: Readonly<Record<CoreContextPrimitiveName, Omit<Co
     directory: 'policies',
     requiredFields: ['title', 'created', 'updated'],
   },
-  project: {
-    directory: 'projects',
-    requiredFields: ['title', 'created', 'updated'],
-  },
-  run: {
-    directory: 'runs',
-    requiredFields: ['title', 'objective', 'runtime', 'status', 'run_id', 'created', 'updated'],
-  },
-  skill: {
-    directory: 'skills',
-    requiredFields: ['title', 'status', 'created', 'updated'],
-  },
   space: {
     directory: 'spaces',
     requiredFields: ['title', 'created', 'updated'],
@@ -165,10 +129,6 @@ const CORE_CONTEXT_PRIMITIVES: Readonly<Record<CoreContextPrimitiveName, Omit<Co
     directory: 'threads',
     requiredFields: ['title', 'goal', 'status', 'created', 'updated'],
   },
-  trigger: {
-    directory: 'triggers',
-    requiredFields: ['title', 'action', 'created', 'updated'],
-  },
 };
 
 const CORE_CONTEXT_RELATIONSHIPS: ReadonlyArray<CoreContextRelationshipContract> = [
@@ -246,110 +206,28 @@ const CORE_CONTEXT_RELATIONSHIPS: ReadonlyArray<CoreContextRelationshipContract>
     field: 'context_refs',
     cardinality: 'many',
     expectedFieldTypes: ['list'],
-    to: ['thread', 'space', 'project', 'client', 'conversation', 'plan-step', 'decision', 'lesson', 'fact', 'incident', 'policy', 'skill', 'checkpoint', 'onboarding', 'run', 'trigger'],
-  },
-  {
-    id: 'project.client',
-    from: 'project',
-    field: 'client',
-    cardinality: 'one',
-    expectedFieldTypes: ['ref'],
-    expectedRefTypes: ['client'],
-    to: ['client'],
+    to: ['thread', 'space', 'conversation', 'plan-step', 'decision', 'fact', 'policy', 'checkpoint', 'org'],
   },
   {
-    id: 'project.member_refs',
-    from: 'project',
-    field: 'member_refs',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['person', 'agent'],
-  },
-  {
-    id: 'project.thread_refs',
-    from: 'project',
-    field: 'thread_refs',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['thread'],
-  },
-  {
-    id: 'person.client',
-    from: 'person',
-    field: 'client',
-    cardinality: 'one',
-    expectedFieldTypes: ['ref'],
-    expectedRefTypes: ['client'],
-    to: ['client'],
-  },
-  {
-    id: 'client.contact_ref',
-    from: 'client',
-    field: 'contact_ref',
+    id: 'decision.supersedes',
+    from: 'decision',
+    field: 'supersedes',
     cardinality: 'one',
     expectedFieldTypes: ['ref'],
-    expectedRefTypes: ['person'],
-    to: ['person'],
-  },
-  {
-    id: 'client.project_refs',
-    from: 'client',
-    field: 'project_refs',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['project'],
-  },
-  {
-    id: 'decision.context_refs',
-    from: 'decision',
-    field: 'context_refs',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['thread', 'project', 'client', 'conversation', 'plan-step', 'fact', 'lesson', 'incident', 'policy'],
-  },
-  {
-    id: 'lesson.context_refs',
-    from: 'lesson',
-    field: 'context_refs',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['thread', 'project', 'client', 'conversation', 'plan-step', 'decision', 'fact', 'incident'],
+    expectedRefTypes: ['decision'],
+    to: ['decision'],
   },
   {
-    id: 'skill.proposal_thread',
-    from: 'skill',
-    field: 'proposal_thread',
+    id: 'fact.source',
+    from: 'fact',
+    field: 'source',
     cardinality: 'one',
     expectedFieldTypes: ['ref'],
-    to: ['thread'],
-  },
-  {
-    id: 'skill.depends_on',
-    from: 'skill',
-    field: 'depends_on',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['skill'],
-  },
-  {
-    id: 'onboarding.thread_refs',
-    from: 'onboarding',
-    field: 'thread_refs',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['thread'],
-  },
-  {
-    id: 'onboarding.spaces',
-    from: 'onboarding',
-    field: 'spaces',
-    cardinality: 'many',
-    expectedFieldTypes: ['list'],
-    to: ['space'],
+    to: ['thread', 'conversation', 'plan-step', 'decision', 'checkpoint', 'org'],
   },
 ];
 
-export const CORE_CONTEXT_GRAPH_CONTRACT: Readonly<CoreContextGraphContract> = {
+export const CORE_CONTEXT_GRAPH_CONTRACT: CoreContextGraphContract = {
   version: CORE_CONTEXT_GRAPH_CONTRACT_VERSION,
   primitives: CORE_CONTEXT_PRIMITIVE_ORDER.map((name) => ({
     name,
diff --git a/packages/kernel/src/cron.test.ts b/packages/kernel/src/cron.test.ts
deleted file mode 100644
index 3f21501..0000000
--- a/packages/kernel/src/cron.test.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseCronExpression, matchesCronSchedule, nextCronMatch } from './cron.js';
-
-describe('cron parser', () => {
-  it('parses 5-field cron expressions and matches date values', () => {
-    const schedule = parseCronExpression('*/15 9-17 * * 1-5');
-    const matching = new Date('2026-03-02T09:30:00.000Z'); // Monday
-    const notMatchingMinute = new Date('2026-03-02T09:31:00.000Z');
-    const notMatchingDow = new Date('2026-03-01T09:30:00.000Z'); // Sunday
-
-    expect(matchesCronSchedule(schedule, matching)).toBe(true);
-    expect(matchesCronSchedule(schedule, notMatchingMinute)).toBe(false);
-    expect(matchesCronSchedule(schedule, notMatchingDow)).toBe(false);
-  });
-
-  it('supports Sunday as 0 or 7 and computes next match', () => {
-    const schedule = parseCronExpression('0 0 * * 7');
-    const sunday = new Date('2026-03-01T00:00:00.000Z');
-    expect(matchesCronSchedule(schedule, sunday)).toBe(true);
-
-    const next = nextCronMatch(schedule, new Date('2026-03-01T00:00:00.000Z'));
-    expect(next).toBeDefined();
-    expect(next?.toISOString().startsWith('2026-03-08T00:00:00.000Z')).toBe(true);
-  });
-
-  it('rejects malformed expressions', () => {
-    expect(() => parseCronExpression('* * * *')).toThrow('Expected 5 fields');
-    expect(() => parseCronExpression('61 * * * *')).toThrow('out of range');
-    expect(() => parseCronExpression('*/0 * * * *')).toThrow('step');
-  });
-});
diff --git a/packages/kernel/src/cron.ts b/packages/kernel/src/cron.ts
deleted file mode 100644
index a802875..0000000
--- a/packages/kernel/src/cron.ts
+++ /dev/null
@@ -1,197 +0,0 @@
-/**
- * Lightweight 5-field cron parsing and matching utilities.
- *
- * Supported field syntax:
- * - "*" (any value)
- * - step syntax (for example, star-slash-5 to mean every 5 units)
- * - "a,b,c" (list)
- * - "a-b" (range)
- * - "a-b/n" (range with step)
- * - "n" (single value)
- */
-
-export interface CronField {
-  all: boolean;
-  values: Set<number>;
-}
-
-export interface CronSchedule {
-  expression: string;
-  minute: CronField;
-  hour: CronField;
-  dayOfMonth: CronField;
-  month: CronField;
-  dayOfWeek: CronField;
-}
-
-export function parseCronExpression(expression: string): CronSchedule {
-  const normalized = String(expression ?? '').trim().replace(/\s+/g, ' ');
-  const parts = normalized.split(' ');
-  if (parts.length !== 5) {
-    throw new Error(`Invalid cron expression "${expression}". Expected 5 fields.`);
-  }
-
-  return {
-    expression: normalized,
-    minute: parseField(parts[0], 0, 59, 'minute'),
-    hour: parseField(parts[1], 0, 23, 'hour'),
-    dayOfMonth: parseField(parts[2], 1, 31, 'day-of-month'),
-    month: parseField(parts[3], 1, 12, 'month'),
-    dayOfWeek: parseField(parts[4], 0, 7, 'day-of-week', (value) => (value === 7 ? 0 : value)),
-  };
-}
-
-export function matchesCronSchedule(schedule: CronSchedule, date: Date): boolean {
-  const minuteMatch = fieldMatches(schedule.minute, date.getUTCMinutes());
-  const hourMatch = fieldMatches(schedule.hour, date.getUTCHours());
-  const monthMatch = fieldMatches(schedule.month, date.getUTCMonth() + 1);
-  if (!minuteMatch || !hourMatch || !monthMatch) {
-    return false;
-  }
-
-  const dayOfMonthMatch = fieldMatches(schedule.dayOfMonth, date.getUTCDate());
-  const dayOfWeekMatch = fieldMatches(schedule.dayOfWeek, date.getUTCDay());
-
-  // Cron semantics: when both DOM and DOW are restricted, either may match.
-  if (schedule.dayOfMonth.all && schedule.dayOfWeek.all) {
-    return true;
-  }
-  if (schedule.dayOfMonth.all) {
-    return dayOfWeekMatch;
-  }
-  if (schedule.dayOfWeek.all) {
-    return dayOfMonthMatch;
-  }
-  return dayOfMonthMatch || dayOfWeekMatch;
-}
-
-export function nextCronMatch(
-  scheduleOrExpression: CronSchedule | string,
-  after: Date,
-  maxSearchMinutes: number = 366 * 24 * 60,
-): Date | null {
-  const schedule = typeof scheduleOrExpression === 'string'
-    ? parseCronExpression(scheduleOrExpression)
-    : scheduleOrExpression;
-
-  const cursor = new Date(after.getTime());
-  cursor.setSeconds(0, 0);
-  cursor.setUTCMinutes(cursor.getUTCMinutes() + 1);
-
-  for (let idx = 0; idx < maxSearchMinutes; idx += 1) {
-    if (matchesCronSchedule(schedule, cursor)) {
-      return new Date(cursor.getTime());
-    }
-    cursor.setUTCMinutes(cursor.getUTCMinutes() + 1);
-  }
-  return null;
-}
-
-function fieldMatches(field: CronField, value: number): boolean {
-  return field.all || field.values.has(value);
-}
-
-function parseField(
-  rawField: string,
-  min: number,
-  max: number,
-  fieldLabel: string,
-  normalizeValue: (value: number) => number = (value) => value,
-): CronField {
-  const field = String(rawField ?? '').trim();
-  if (!field) {
-    throw new Error(`Invalid cron ${fieldLabel} field: empty value.`);
-  }
-  if (field === '*') {
-    return {
-      all: true,
-      values: new Set(buildRange(min, max)),
-    };
-  }
-
-  const values = new Set<number>();
-  const segments = field.split(',');
-  for (const segment of segments) {
-    parseFieldSegment(segment.trim(), min, max, fieldLabel, values, normalizeValue);
-  }
-
-  if (values.size === 0) {
-    throw new Error(`Invalid cron ${fieldLabel} field "${field}".`);
-  }
-
-  return { all: false, values };
-}
-
-function parseFieldSegment(
-  rawSegment: string,
-  min: number,
-  max: number,
-  fieldLabel: string,
-  values: Set<number>,
-  normalizeValue: (value: number) => number,
-): void {
-  if (!rawSegment) {
-    throw new Error(`Invalid cron ${fieldLabel} field: empty segment.`);
-  }
-
-  const [base, stepRaw] = rawSegment.split('/');
-  const step = stepRaw === undefined ? 1 : parseIntStrict(stepRaw, fieldLabel, rawSegment);
-  if (step <= 0) {
-    throw new Error(`Invalid cron ${fieldLabel} step "${stepRaw}" in segment "${rawSegment}".`);
-  }
-
-  if (base === '*') {
-    for (let value = min; value <= max; value += step) {
-      values.add(normalizeAndValidateValue(value, min, max, fieldLabel, normalizeValue));
-    }
-    return;
-  }
-
-  if (base.includes('-')) {
-    const [startRaw, endRaw] = base.split('-');
-    const start = parseIntStrict(startRaw, fieldLabel, rawSegment);
-    const end = parseIntStrict(endRaw, fieldLabel, rawSegment);
-    if (start > end) {
-      throw new Error(`Invalid cron ${fieldLabel} range "${base}" in segment "${rawSegment}".`);
-    }
-    for (let value = start; value <= end; value += step) {
-      values.add(normalizeAndValidateValue(value, min, max, fieldLabel, normalizeValue));
-    }
-    return;
-  }
-
-  const value = parseIntStrict(base, fieldLabel, rawSegment);
-  values.add(normalizeAndValidateValue(value, min, max, fieldLabel, normalizeValue));
-}
-
-function normalizeAndValidateValue(
-  rawValue: number,
-  min: number,
-  max: number,
-  fieldLabel: string,
-  normalizeValue: (value: number) => number,
-): number {
-  if (rawValue < min || rawValue > max) {
-    throw new Error(`Cron ${fieldLabel} value ${rawValue} out of range (${min}-${max}).`);
-  }
-  const normalized = normalizeValue(rawValue);
-  if (normalized < min || normalized > max) {
-    throw new Error(`Cron ${fieldLabel} normalized value ${normalized} out of range (${min}-${max}).`);
-  }
-  return normalized;
-}
-
-function parseIntStrict(raw: string, fieldLabel: string, segment: string): number {
-  if (!/^-?\d+$/.test(String(raw))) {
-    throw new Error(`Invalid cron ${fieldLabel} token "${raw}" in segment "${segment}".`);
-  }
-  return Number.parseInt(raw, 10);
-}
-
-function buildRange(min: number, max: number): number[] {
-  const values: number[] = [];
-  for (let value = min; value <= max; value += 1) {
-    values.push(value);
-  }
-  return values;
-}
diff --git a/packages/kernel/src/cursor-bridge.test.ts b/packages/kernel/src/cursor-bridge.test.ts
deleted file mode 100644
index 90da9c1..0000000
--- a/packages/kernel/src/cursor-bridge.test.ts
+++ /dev/null
@@ -1,188 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import {
-  createCursorBridgeWebhookSignature,
-  dispatchCursorAutomationEvent,
-  getCursorBridgeStatus,
-  listCursorBridgeEvents,
-  receiveCursorAutomationWebhook,
-  setupCursorBridge,
-} from './cursor-bridge.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-cursor-bridge-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('cursor bridge', () => {
-  it('persists setup and reports status with webhook/dispatch defaults', () => {
-    setupCursorBridge(workspacePath, {
-      actor: 'cursor-ops',
-      enabled: true,
-      secret: 'bridge-secret',
-      allowedEventTypes: ['cursor.automation.*'],
-      dispatch: {
-        adapter: 'shell-worker',
-        execute: true,
-        maxSteps: 42,
-      },
-    });
-
-    const status = getCursorBridgeStatus(workspacePath, { recentEventsLimit: 3 });
-    expect(status.configured).toBe(true);
-    expect(status.enabled).toBe(true);
-    expect(status.webhook.hasSecret).toBe(true);
-    expect(status.webhook.allowedEventTypes).toEqual(['cursor.automation.*']);
-    expect(status.dispatch.actor).toBe('cursor-ops');
-    expect(status.dispatch.adapter).toBe('shell-worker');
-    expect(status.dispatch.execute).toBe(true);
-    expect(status.dispatch.maxSteps).toBe(42);
-    expect(status.recentEvents).toEqual([]);
-  });
-
-  it('creates queued dispatch runs and logs event bridge metadata', async () => {
-    setupCursorBridge(workspacePath, {
-      actor: 'cursor-ops',
-      enabled: true,
-      allowedEventTypes: ['cursor.automation.*'],
-      dispatch: {
-        adapter: 'cursor-cloud',
-        execute: false,
-      },
-    });
-
-    const result = await dispatchCursorAutomationEvent(workspacePath, {
-      source: 'cli-dispatch',
-      eventType: 'cursor.automation.run.completed',
-      eventId: 'evt_queued_1',
-      objective: 'Sync Cursor completion into queued dispatch run',
-      context: {
-        cursor_job_id: 'job_123',
-      },
-    });
-
-    expect(result.run.status).toBe('queued');
-    expect(result.run.context?.cursor_bridge).toMatchObject({
-      event_type: 'cursor.automation.run.completed',
-      event_id: 'evt_queued_1',
-      source: 'cli-dispatch',
-    });
-    const events = listCursorBridgeEvents(workspacePath, { limit: 5 });
-    expect(events).toHaveLength(1);
-    expect(events[0].runId).toBe(result.run.id);
-    expect(events[0].runStatus).toBe('queued');
-    expect(events[0].error).toBeUndefined();
-  });
-
-  it('can execute bridged runs via dispatch integration defaults', async () => {
-    setupCursorBridge(workspacePath, {
-      actor: 'cursor-ops',
-      enabled: true,
-      allowedEventTypes: ['*'],
-      dispatch: {
-        adapter: 'shell-worker',
-        execute: true,
-      },
-    });
-    const shellCommand = `"${process.execPath}" -e "process.stdout.write('cursor_bridge_ok')"`;
-
-    const result = await dispatchCursorAutomationEvent(workspacePath, {
-      eventType: 'cursor.automation.run.completed',
-      eventId: 'evt_exec_1',
-      objective: 'Execute bridged run',
-      context: {
-        shell_command: shellCommand,
-      },
-    });
-
-    expect(result.run.status).toBe('succeeded');
-    expect(result.run.output).toContain('cursor_bridge_ok');
-    const latest = listCursorBridgeEvents(workspacePath, { limit: 1 })[0];
-    expect(latest.runId).toBe(result.run.id);
-    expect(latest.runStatus).toBe('succeeded');
-  });
-
-  it('rejects signed webhooks when signature verification fails', async () => {
-    setupCursorBridge(workspacePath, {
-      actor: 'cursor-ops',
-      enabled: true,
-      secret: 'bridge-secret',
-      allowedEventTypes: ['cursor.automation.*'],
-      dispatch: {
-        adapter: 'cursor-cloud',
-        execute: false,
-      },
-    });
-    const body = JSON.stringify({
-      id: 'evt_bad_sig',
-      type: 'cursor.automation.run.completed',
-      objective: 'Dispatch should not happen',
-    });
-
-    await expect(receiveCursorAutomationWebhook(workspacePath, {
-      body,
-      headers: {
-        'x-cursor-signature': 'sha256=deadbeef',
-      },
-    })).rejects.toThrow('Invalid Cursor webhook signature.');
-  });
-
-  it('accepts valid signed webhooks and enforces allowed event patterns', async () => {
-    setupCursorBridge(workspacePath, {
-      actor: 'cursor-ops',
-      enabled: true,
-      secret: 'bridge-secret',
-      allowedEventTypes: ['cursor.automation.run.*'],
-      dispatch: {
-        adapter: 'cursor-cloud',
-        execute: false,
-      },
-    });
-    const body = JSON.stringify({
-      id: 'evt_webhook_ok',
-      type: 'cursor.automation.run.completed',
-      objective: 'Webhook to dispatch',
-    });
-    const signature = createCursorBridgeWebhookSignature({
-      secret: 'bridge-secret',
-      body,
-    });
-    const accepted = await receiveCursorAutomationWebhook(workspacePath, {
-      body,
-      headers: {
-        'x-cursor-signature': signature,
-      },
-    });
-    expect(accepted.run.status).toBe('queued');
-    expect(accepted.event.source).toBe('webhook');
-    expect(accepted.event.eventType).toBe('cursor.automation.run.completed');
-
-    const disallowedBody = JSON.stringify({
-      id: 'evt_webhook_denied',
-      type: 'cursor.automation.workflow.started',
-      objective: 'Should be rejected',
-    });
-    const disallowedSignature = createCursorBridgeWebhookSignature({
-      secret: 'bridge-secret',
-      body: disallowedBody,
-    });
-    await expect(receiveCursorAutomationWebhook(workspacePath, {
-      body: disallowedBody,
-      headers: {
-        'x-cursor-signature': disallowedSignature,
-      },
-    })).rejects.toThrow('is not allowed by bridge configuration');
-  });
-});
diff --git a/packages/kernel/src/cursor-bridge.ts b/packages/kernel/src/cursor-bridge.ts
deleted file mode 100644
index 7613bf8..0000000
--- a/packages/kernel/src/cursor-bridge.ts
+++ /dev/null
@@ -1,760 +0,0 @@
-import crypto, { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import * as dispatch from './dispatch.js';
-import * as transport from './transport/index.js';
-import type { DispatchRun, RunStatus } from './types.js';
-
-const CURSOR_BRIDGE_CONFIG_FILE = '.workgraph/cursor-bridge.json';
-const CURSOR_BRIDGE_EVENTS_FILE = '.workgraph/cursor-bridge-events.jsonl';
-const CURSOR_BRIDGE_VERSION = 1;
-const DEFAULT_ALLOWED_EVENT_TYPES = ['*'];
-const DEFAULT_DISPATCH_ADAPTER = 'cursor-cloud';
-const DEFAULT_DISPATCH_ACTOR = 'cursor-bridge';
-
-export interface CursorBridgeConfig {
-  version: number;
-  enabled: boolean;
-  provider: 'cursor-automations';
-  createdAt: string;
-  updatedAt: string;
-  webhook: {
-    secret?: string;
-    allowedEventTypes: string[];
-  };
-  dispatch: {
-    actor: string;
-    adapter: string;
-    execute: boolean;
-    agents?: string[];
-    maxSteps?: number;
-    stepDelayMs?: number;
-    space?: string;
-    createCheckpoint: boolean;
-    timeoutMs?: number;
-    dispatchMode?: 'direct' | 'self-assembly';
-  };
-}
-
-export interface CursorBridgeStatus {
-  configured: boolean;
-  enabled: boolean;
-  provider: CursorBridgeConfig['provider'];
-  configPath: string;
-  eventsPath: string;
-  webhook: {
-    hasSecret: boolean;
-    allowedEventTypes: string[];
-  };
-  dispatch: CursorBridgeConfig['dispatch'];
-  recentEvents: CursorBridgeEventRecord[];
-}
-
-export interface CursorBridgeSetupInput {
-  actor?: string;
-  enabled?: boolean;
-  secret?: string;
-  allowedEventTypes?: string[];
-  dispatch?: Partial<CursorBridgeConfig['dispatch']>;
-}
-
-export interface CursorBridgeDispatchInput {
-  source?: CursorBridgeEventSource;
-  eventId?: string;
-  eventType?: string;
-  objective?: string;
-  actor?: string;
-  adapter?: string;
-  execute?: boolean;
-  context?: Record<string, unknown>;
-  idempotencyKey?: string;
-  agents?: string[];
-  maxSteps?: number;
-  stepDelayMs?: number;
-  space?: string;
-  createCheckpoint?: boolean;
-  timeoutMs?: number;
-  dispatchMode?: 'direct' | 'self-assembly';
-}
-
-export interface CursorAutomationWebhookInput {
-  body: string;
-  headers?: Record<string, string | string[] | undefined>;
-  signature?: string;
-  timestamp?: string;
-}
-
-export interface CursorBridgeDispatchResult {
-  run: DispatchRun;
-  event: CursorBridgeEventRecord;
-}
-
-export type CursorBridgeEventSource = 'webhook' | 'cli-dispatch';
-
-export interface CursorBridgeEventRecord {
-  id: string;
-  ts: string;
-  source: CursorBridgeEventSource;
-  eventId?: string;
-  eventType: string;
-  objective: string;
-  runId?: string;
-  runStatus?: RunStatus;
-  adapter?: string;
-  actor?: string;
-  error?: string;
-}
-
-interface CursorAutomationEventPayload {
-  id?: unknown;
-  type?: unknown;
-  event_type?: unknown;
-  objective?: unknown;
-  actor?: unknown;
-  adapter?: unknown;
-  execute?: unknown;
-  context?: unknown;
-  metadata?: unknown;
-}
-
-interface CursorBridgeEventRecordFile extends CursorBridgeEventRecord {
-  runStatus?: RunStatus;
-}
-
-export function cursorBridgeConfigPath(workspacePath: string): string {
-  return path.join(workspacePath, CURSOR_BRIDGE_CONFIG_FILE);
-}
-
-export function cursorBridgeEventsPath(workspacePath: string): string {
-  return path.join(workspacePath, CURSOR_BRIDGE_EVENTS_FILE);
-}
-
-export function setupCursorBridge(workspacePath: string, input: CursorBridgeSetupInput = {}): CursorBridgeConfig {
-  const now = new Date().toISOString();
-  const existing = loadCursorBridgeConfig(workspacePath);
-  const actor = readNonEmptyString(input.actor) ?? existing.dispatch.actor ?? DEFAULT_DISPATCH_ACTOR;
-  const dispatchDefaults = {
-    ...(existing.dispatch ?? defaultCursorBridgeConfig().dispatch),
-    ...(normalizeDispatchDefaults(input.dispatch) ?? {}),
-  };
-  const allowedEventTypes = input.allowedEventTypes
-    ? normalizeAllowedEventTypes(input.allowedEventTypes)
-    : existing.webhook.allowedEventTypes;
-  const secret = input.secret !== undefined
-    ? readNonEmptyString(input.secret)
-    : existing.webhook.secret;
-
-  const next: CursorBridgeConfig = {
-    ...existing,
-    enabled: input.enabled ?? existing.enabled,
-    updatedAt: now,
-    webhook: {
-      secret,
-      allowedEventTypes,
-    },
-    dispatch: {
-      ...dispatchDefaults,
-      actor,
-    },
-  };
-  writeCursorBridgeConfig(workspacePath, next);
-  return next;
-}
-
-export function loadCursorBridgeConfig(workspacePath: string): CursorBridgeConfig {
-  const cfgPath = cursorBridgeConfigPath(workspacePath);
-  if (!fs.existsSync(cfgPath)) {
-    return defaultCursorBridgeConfig();
-  }
-  try {
-    const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf-8')) as unknown;
-    return normalizeCursorBridgeConfig(raw);
-  } catch {
-    return defaultCursorBridgeConfig();
-  }
-}
-
-export function getCursorBridgeStatus(
-  workspacePath: string,
-  options: { recentEventsLimit?: number } = {},
-): CursorBridgeStatus {
-  const configPath = cursorBridgeConfigPath(workspacePath);
-  const configured = fs.existsSync(configPath);
-  const config = loadCursorBridgeConfig(workspacePath);
-  return {
-    configured,
-    enabled: config.enabled,
-    provider: config.provider,
-    configPath,
-    eventsPath: cursorBridgeEventsPath(workspacePath),
-    webhook: {
-      hasSecret: typeof config.webhook.secret === 'string' && config.webhook.secret.length > 0,
-      allowedEventTypes: [...config.webhook.allowedEventTypes],
-    },
-    dispatch: {
-      ...config.dispatch,
-      ...(config.dispatch.agents ? { agents: [...config.dispatch.agents] } : {}),
-    },
-    recentEvents: listCursorBridgeEvents(workspacePath, {
-      limit: options.recentEventsLimit ?? 5,
-    }),
-  };
-}
-
-export async function receiveCursorAutomationWebhook(
-  workspacePath: string,
-  input: CursorAutomationWebhookInput,
-): Promise<CursorBridgeDispatchResult> {
-  const config = loadCursorBridgeConfig(workspacePath);
-  if (!config.enabled) {
-    throw new Error('Cursor bridge is disabled. Run `workgraph cursor setup --enabled true` to enable it.');
-  }
-  const payload = parseCursorAutomationWebhookBody(input.body);
-  const eventType = readNonEmptyString(payload.type) ?? readNonEmptyString(payload.event_type);
-  if (!eventType) {
-    throw new Error('Cursor webhook payload is missing required "type".');
-  }
-  if (!eventTypeMatches(config.webhook.allowedEventTypes, eventType)) {
-    throw new Error(`Cursor webhook event type "${eventType}" is not allowed by bridge configuration.`);
-  }
-  const webhookSecret = readNonEmptyString(config.webhook.secret);
-  if (webhookSecret) {
-    const headers = normalizeHeaderMap(input.headers);
-    const signature = readNonEmptyString(input.signature)
-      ?? readHeader(headers, 'x-cursor-signature')
-      ?? readHeader(headers, 'x-workgraph-signature');
-    if (!signature) {
-      throw new Error('Cursor webhook is missing required signature header.');
-    }
-    const timestamp = readNonEmptyString(input.timestamp)
-      ?? readHeader(headers, 'x-cursor-timestamp')
-      ?? readHeader(headers, 'x-workgraph-timestamp');
-    const verified = verifyCursorBridgeWebhookSignature({
-      secret: webhookSecret,
-      body: input.body,
-      signature,
-      timestamp,
-    });
-    if (!verified) {
-      throw new Error('Invalid Cursor webhook signature.');
-    }
-  }
-  const context = asRecord(payload.context);
-  const metadata = asRecord(payload.metadata);
-  return dispatchCursorAutomationEvent(workspacePath, {
-    source: 'webhook',
-    eventId: readNonEmptyString(payload.id),
-    eventType,
-    objective: readNonEmptyString(payload.objective),
-    actor: readNonEmptyString(payload.actor),
-    adapter: readNonEmptyString(payload.adapter),
-    execute: normalizeOptionalBoolean(payload.execute),
-    context: {
-      ...context,
-      ...(Object.keys(metadata).length > 0 ? { cursor_metadata: metadata } : {}),
-    },
-  });
-}
-
-export async function dispatchCursorAutomationEvent(
-  workspacePath: string,
-  input: CursorBridgeDispatchInput,
-): Promise<CursorBridgeDispatchResult> {
-  const config = loadCursorBridgeConfig(workspacePath);
-  if (!config.enabled) {
-    throw new Error('Cursor bridge is disabled. Run `workgraph cursor setup --enabled true` to enable it.');
-  }
-
-  const source = input.source ?? 'cli-dispatch';
-  const eventType = readNonEmptyString(input.eventType) ?? 'cursor.automation.manual';
-  if (!eventTypeMatches(config.webhook.allowedEventTypes, eventType)) {
-    throw new Error(`Cursor event type "${eventType}" is not allowed by bridge configuration.`);
-  }
-  const eventId = readNonEmptyString(input.eventId);
-  const objective = readNonEmptyString(input.objective) ?? defaultObjectiveForEvent(eventType, eventId);
-  const actor = readNonEmptyString(input.actor) ?? config.dispatch.actor;
-  const adapter = readNonEmptyString(input.adapter) ?? config.dispatch.adapter;
-  const execute = input.execute ?? config.dispatch.execute;
-  const bridgeContext = buildBridgeDispatchContext({
-    eventType,
-    eventId,
-    source,
-    objective,
-    context: input.context,
-  });
-  const idempotencyKey = readNonEmptyString(input.idempotencyKey)
-    ?? (eventId ? `cursor-bridge:${eventType}:${eventId}` : undefined);
-  const envelope = transport.createTransportEnvelope({
-    direction: 'outbound',
-    channel: 'runtime-bridge',
-    topic: eventType,
-    source: `cursor-bridge:${source}`,
-    target: adapter,
-    provider: 'cursor-automations',
-    correlationId: eventId,
-    dedupKeys: [
-      ...(eventId ? [`cursor-event:${eventId}`] : []),
-      `cursor-topic:${eventType}:${objective}`,
-    ],
-    payload: {
-      source,
-      eventId,
-      eventType,
-      objective,
-      actor,
-      adapter,
-      execute,
-      context: bridgeContext,
-    },
-  });
-  const outbox = transport.createTransportOutboxRecord(workspacePath, {
-    envelope,
-    deliveryHandler: 'runtime-bridge',
-    deliveryTarget: adapter,
-    message: `Dispatching cursor bridge event ${eventType} to adapter ${adapter}.`,
-  });
-
-  let run: DispatchRun | undefined;
-  try {
-    run = dispatch.createRun(workspacePath, {
-      actor,
-      adapter,
-      objective,
-      idempotencyKey,
-      context: bridgeContext,
-    });
-    if (execute) {
-      run = await dispatch.executeRun(workspacePath, run.id, {
-        actor,
-        agents: input.agents ?? config.dispatch.agents,
-        maxSteps: input.maxSteps ?? config.dispatch.maxSteps,
-        stepDelayMs: input.stepDelayMs ?? config.dispatch.stepDelayMs,
-        space: input.space ?? config.dispatch.space,
-        createCheckpoint: input.createCheckpoint ?? config.dispatch.createCheckpoint,
-        timeoutMs: input.timeoutMs ?? config.dispatch.timeoutMs,
-        dispatchMode: input.dispatchMode ?? config.dispatch.dispatchMode,
-      });
-    }
-    const record: CursorBridgeEventRecord = {
-      id: `cbe_${randomUUID()}`,
-      ts: new Date().toISOString(),
-      source,
-      eventId,
-      eventType,
-      objective,
-      runId: run.id,
-      runStatus: run.status,
-      adapter,
-      actor,
-    };
-    appendCursorBridgeEvent(workspacePath, record);
-    transport.markTransportOutboxDelivered(workspacePath, outbox.id, `Cursor bridge event ${eventType} dispatched successfully.`);
-    return { run, event: record };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    appendCursorBridgeEvent(workspacePath, {
-      id: `cbe_${randomUUID()}`,
-      ts: new Date().toISOString(),
-      source,
-      eventId,
-      eventType,
-      objective,
-      runId: run?.id,
-      runStatus: run?.status,
-      adapter,
-      actor,
-      error: message,
-    });
-    transport.markTransportOutboxFailed(workspacePath, outbox.id, {
-      message,
-      context: {
-        eventType,
-        eventId,
-        adapter,
-        runId: run?.id,
-      },
-    });
-    throw error;
-  }
-}
-
-export function listCursorBridgeEvents(
-  workspacePath: string,
-  options: { limit?: number } = {},
-): CursorBridgeEventRecord[] {
-  const eventsPath = cursorBridgeEventsPath(workspacePath);
-  if (!fs.existsSync(eventsPath)) return [];
-  const lines = fs.readFileSync(eventsPath, 'utf-8')
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean);
-  const parsed = lines
-    .map((line) => {
-      try {
-        return normalizeCursorBridgeEventRecord(JSON.parse(line) as unknown);
-      } catch {
-        return null;
-      }
-    })
-    .filter((entry): entry is CursorBridgeEventRecord => entry !== null);
-  parsed.sort((a, b) => b.ts.localeCompare(a.ts));
-  const limit = clampPositiveInt(options.limit, parsed.length);
-  return parsed.slice(0, limit);
-}
-
-export function createCursorBridgeWebhookSignature(input: {
-  secret: string;
-  body: string;
-  timestamp?: string;
-}): string {
-  const payload = signaturePayload(input.body, input.timestamp);
-  const digest = crypto.createHmac('sha256', input.secret).update(payload).digest('hex');
-  return `sha256=${digest}`;
-}
-
-export function verifyCursorBridgeWebhookSignature(input: {
-  secret: string;
-  body: string;
-  signature: string;
-  timestamp?: string;
-}): boolean {
-  const provided = normalizeSignature(input.signature);
-  if (!provided) return false;
-  const expected = createCursorBridgeWebhookSignature({
-    secret: input.secret,
-    body: input.body,
-    timestamp: input.timestamp,
-  });
-  return timingSafeEqual(provided, expected);
-}
-
-function defaultCursorBridgeConfig(now: string = new Date().toISOString()): CursorBridgeConfig {
-  return {
-    version: CURSOR_BRIDGE_VERSION,
-    enabled: false,
-    provider: 'cursor-automations',
-    createdAt: now,
-    updatedAt: now,
-    webhook: {
-      allowedEventTypes: [...DEFAULT_ALLOWED_EVENT_TYPES],
-    },
-    dispatch: {
-      actor: DEFAULT_DISPATCH_ACTOR,
-      adapter: DEFAULT_DISPATCH_ADAPTER,
-      execute: false,
-      createCheckpoint: true,
-    },
-  };
-}
-
-function writeCursorBridgeConfig(workspacePath: string, config: CursorBridgeConfig): void {
-  const normalized = normalizeCursorBridgeConfig(config);
-  const cfgPath = cursorBridgeConfigPath(workspacePath);
-  const dir = path.dirname(cfgPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(cfgPath, JSON.stringify(normalized, null, 2) + '\n', 'utf-8');
-}
-
-function appendCursorBridgeEvent(workspacePath: string, event: CursorBridgeEventRecord): void {
-  const normalized = normalizeCursorBridgeEventRecord(event);
-  if (!normalized) return;
-  const filePath = cursorBridgeEventsPath(workspacePath);
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const payload = JSON.stringify(normalized) + '\n';
-  fs.appendFileSync(filePath, payload, 'utf-8');
-}
-
-function normalizeCursorBridgeConfig(raw: unknown): CursorBridgeConfig {
-  const defaults = defaultCursorBridgeConfig();
-  const root = asRecord(raw);
-  const createdAt = readNonEmptyString(root.createdAt) ?? defaults.createdAt;
-  const updatedAt = readNonEmptyString(root.updatedAt) ?? createdAt;
-  const webhookRoot = asRecord(root.webhook);
-  const dispatchRoot = asRecord(root.dispatch);
-  const dispatchDefaults = normalizeDispatchDefaults(dispatchRoot) ?? {};
-
-  return {
-    version: CURSOR_BRIDGE_VERSION,
-    enabled: asBoolean(root.enabled, defaults.enabled),
-    provider: 'cursor-automations',
-    createdAt,
-    updatedAt,
-    webhook: {
-      secret: readNonEmptyString(webhookRoot.secret),
-      allowedEventTypes: normalizeAllowedEventTypes(
-        asStringArray(webhookRoot.allowedEventTypes).length > 0
-          ? asStringArray(webhookRoot.allowedEventTypes)
-          : defaults.webhook.allowedEventTypes,
-      ),
-    },
-    dispatch: {
-      ...defaults.dispatch,
-      ...dispatchDefaults,
-      actor: readNonEmptyString(dispatchRoot.actor) ?? dispatchDefaults.actor ?? defaults.dispatch.actor,
-      adapter: readNonEmptyString(dispatchRoot.adapter) ?? dispatchDefaults.adapter ?? defaults.dispatch.adapter,
-      createCheckpoint: asBoolean(
-        dispatchRoot.createCheckpoint,
-        dispatchDefaults.createCheckpoint ?? defaults.dispatch.createCheckpoint,
-      ),
-      execute: asBoolean(dispatchRoot.execute, dispatchDefaults.execute ?? defaults.dispatch.execute),
-    },
-  };
-}
-
-function normalizeDispatchDefaults(
-  value: unknown,
-): Partial<CursorBridgeConfig['dispatch']> | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const root = value as Record<string, unknown>;
-  const actor = readNonEmptyString(root.actor);
-  const adapter = readNonEmptyString(root.adapter);
-  const execute = normalizeOptionalBoolean(root.execute);
-  const agents = normalizeStringArray(root.agents);
-  const maxSteps = normalizePositiveInt(root.maxSteps);
-  const stepDelayMs = normalizeNonNegativeInt(root.stepDelayMs);
-  const space = readNonEmptyString(root.space);
-  const createCheckpoint = normalizeOptionalBoolean(root.createCheckpoint);
-  const timeoutMs = normalizePositiveInt(root.timeoutMs);
-  const dispatchMode = normalizeDispatchMode(root.dispatchMode);
-
-  return {
-    ...(actor ? { actor } : {}),
-    ...(adapter ? { adapter } : {}),
-    ...(typeof execute === 'boolean' ? { execute } : {}),
-    ...(agents ? { agents } : {}),
-    ...(typeof maxSteps === 'number' ? { maxSteps } : {}),
-    ...(typeof stepDelayMs === 'number' ? { stepDelayMs } : {}),
-    ...(space ? { space } : {}),
-    ...(typeof createCheckpoint === 'boolean' ? { createCheckpoint } : {}),
-    ...(typeof timeoutMs === 'number' ? { timeoutMs } : {}),
-    ...(dispatchMode ? { dispatchMode } : {}),
-  };
-}
-
-function normalizeAllowedEventTypes(value: string[]): string[] {
-  const normalized = value
-    .map((item) => String(item).trim())
-    .filter(Boolean);
-  if (normalized.length === 0) return [...DEFAULT_ALLOWED_EVENT_TYPES];
-  return [...new Set(normalized)];
-}
-
-function normalizeStringArray(value: unknown): string[] | undefined {
-  const values = asStringArray(value)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-  if (values.length === 0) return undefined;
-  return [...new Set(values)];
-}
-
-function normalizeCursorBridgeEventRecord(raw: unknown): CursorBridgeEventRecord | null {
-  const root = asRecord(raw);
-  const id = readNonEmptyString(root.id);
-  const ts = readNonEmptyString(root.ts);
-  const source = normalizeSource(root.source);
-  const eventType = readNonEmptyString(root.eventType);
-  const objective = readNonEmptyString(root.objective);
-  if (!id || !ts || !source || !eventType || !objective) {
-    return null;
-  }
-  const runStatus = normalizeRunStatus(root.runStatus);
-  return {
-    id,
-    ts,
-    source,
-    eventType,
-    objective,
-    ...(readNonEmptyString(root.eventId) ? { eventId: readNonEmptyString(root.eventId) } : {}),
-    ...(readNonEmptyString(root.runId) ? { runId: readNonEmptyString(root.runId) } : {}),
-    ...(runStatus ? { runStatus } : {}),
-    ...(readNonEmptyString(root.adapter) ? { adapter: readNonEmptyString(root.adapter) } : {}),
-    ...(readNonEmptyString(root.actor) ? { actor: readNonEmptyString(root.actor) } : {}),
-    ...(readNonEmptyString(root.error) ? { error: readNonEmptyString(root.error) } : {}),
-  };
-}
-
-function parseCursorAutomationWebhookBody(body: string): CursorAutomationEventPayload {
-  const raw = String(body ?? '').trim();
-  if (!raw) throw new Error('Cursor webhook body is empty.');
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error('Cursor webhook body must be valid JSON.');
-  }
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error('Cursor webhook payload must be a JSON object.');
-  }
-  return parsed as CursorAutomationEventPayload;
-}
-
-function normalizeHeaderMap(
-  value: Record<string, string | string[] | undefined> | undefined,
-): Record<string, string> {
-  const normalized: Record<string, string> = {};
-  if (!value) return normalized;
-  for (const [key, raw] of Object.entries(value)) {
-    const normalizedKey = key.trim().toLowerCase();
-    if (!normalizedKey) continue;
-    if (Array.isArray(raw)) {
-      const joined = raw.map((item) => String(item).trim()).filter(Boolean).join(',');
-      if (joined) normalized[normalizedKey] = joined;
-      continue;
-    }
-    const text = String(raw ?? '').trim();
-    if (text) normalized[normalizedKey] = text;
-  }
-  return normalized;
-}
-
-function readHeader(headers: Record<string, string>, name: string): string | undefined {
-  const value = headers[name.trim().toLowerCase()];
-  return readNonEmptyString(value);
-}
-
-function buildBridgeDispatchContext(input: {
-  eventType: string;
-  eventId?: string;
-  source: CursorBridgeEventSource;
-  objective: string;
-  context?: Record<string, unknown>;
-}): Record<string, unknown> {
-  return {
-    ...(input.context ?? {}),
-    cursor_bridge: {
-      event_type: input.eventType,
-      event_id: input.eventId,
-      source: input.source,
-      objective: input.objective,
-      received_at: new Date().toISOString(),
-    },
-  };
-}
-
-function defaultObjectiveForEvent(eventType: string, eventId?: string): string {
-  return eventId
-    ? `Cursor automation event ${eventType} (${eventId})`
-    : `Cursor automation event ${eventType}`;
-}
-
-function signaturePayload(body: string, timestamp?: string): string {
-  const normalizedBody = String(body ?? '');
-  const normalizedTimestamp = readNonEmptyString(timestamp);
-  return normalizedTimestamp ? `${normalizedTimestamp}.${normalizedBody}` : normalizedBody;
-}
-
-function normalizeSignature(value: string): string | null {
-  const raw = String(value ?? '').trim();
-  if (!raw) return null;
-  const normalized = raw.toLowerCase().startsWith('sha256=') ? raw : `sha256=${raw}`;
-  return normalized;
-}
-
-function timingSafeEqual(a: string, b: string): boolean {
-  const left = Buffer.from(a);
-  const right = Buffer.from(b);
-  if (left.length !== right.length) return false;
-  return crypto.timingSafeEqual(left, right);
-}
-
-function eventTypeMatches(allowedEventTypes: string[], eventType: string): boolean {
-  if (allowedEventTypes.length === 0) return true;
-  return allowedEventTypes.some((pattern) => {
-    if (pattern === '*') return true;
-    if (pattern.endsWith('*')) {
-      return eventType.startsWith(pattern.slice(0, -1));
-    }
-    return pattern === eventType;
-  });
-}
-
-function normalizeRunStatus(value: unknown): RunStatus | undefined {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (
-    normalized === 'queued'
-    || normalized === 'running'
-    || normalized === 'succeeded'
-    || normalized === 'failed'
-    || normalized === 'cancelled'
-  ) {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizeDispatchMode(value: unknown): 'direct' | 'self-assembly' | undefined {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (normalized === 'direct' || normalized === 'self-assembly') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizeSource(value: unknown): CursorBridgeEventSource | undefined {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (normalized === 'webhook' || normalized === 'cli-dispatch') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizePositiveInt(value: unknown): number | undefined {
-  const parsed = normalizeNumber(value);
-  if (typeof parsed !== 'number' || parsed <= 0) return undefined;
-  return Math.trunc(parsed);
-}
-
-function normalizeNonNegativeInt(value: unknown): number | undefined {
-  const parsed = normalizeNumber(value);
-  if (typeof parsed !== 'number' || parsed < 0) return undefined;
-  return Math.trunc(parsed);
-}
-
-function clampPositiveInt(value: number | undefined, fallback: number): number {
-  const normalized = typeof value === 'number' && Number.isFinite(value)
-    ? Math.max(0, Math.trunc(value))
-    : fallback;
-  return normalized;
-}
-
-function normalizeOptionalBoolean(value: unknown): boolean | undefined {
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true' || normalized === '1' || normalized === 'yes') return true;
-    if (normalized === 'false' || normalized === '0' || normalized === 'no') return false;
-  }
-  return undefined;
-}
-
-function normalizeNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function asBoolean(value: unknown, fallback: boolean): boolean {
-  const parsed = normalizeOptionalBoolean(value);
-  if (typeof parsed === 'boolean') return parsed;
-  return fallback;
-}
-
-function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value.map((item) => String(item ?? ''));
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asRecord(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  return value as Record<string, unknown>;
-}
diff --git a/packages/kernel/src/diagnostics.test.ts b/packages/kernel/src/diagnostics.test.ts
deleted file mode 100644
index 92e1f8b..0000000
--- a/packages/kernel/src/diagnostics.test.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import YAML from 'yaml';
-import * as dispatch from './dispatch.js';
-import * as ledger from './ledger.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import * as workspace from './workspace.js';
-import { diagnoseVaultHealth } from './diagnostics/doctor.js';
-import { computeVaultStats } from './diagnostics/stats.js';
-import { visualizeVaultGraph } from './diagnostics/viz.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-diagnostics-'));
-  workspace.initWorkspace(workspacePath, {
-    createReadme: false,
-  });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('diagnostics tooling', () => {
-  it('doctor detects issues and auto-fixes orphan links + stale claims/runs', () => {
-    const alpha = thread.createThread(workspacePath, 'Alpha Node', 'alpha goal', 'agent-a');
-    const beta = thread.createThread(workspacePath, 'Beta Node', 'beta goal', 'agent-a');
-    store.update(
-      workspacePath,
-      alpha.path,
-      {},
-      `## Links\n\n- [[${beta.path}]]\n- [[threads/non-existent.md]]\n`,
-      'agent-a',
-    );
-    thread.claim(workspacePath, beta.path, 'agent-b');
-
-    const run = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'stale run candidate',
-    });
-    dispatch.markRun(workspacePath, run.id, 'agent-runner', 'running');
-
-    const oldIso = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
-    ageClaimEntry(workspacePath, beta.path, oldIso);
-    ageRunEntry(workspacePath, run.id, oldIso);
-
-    store.create(workspacePath, 'decision', {
-      title: 'Alpha Node',
-      date: new Date().toISOString(),
-    }, '', 'agent-a');
-
-    fs.writeFileSync(
-      path.join(workspacePath, 'threads', 'missing-required.md'),
-      '---\ntitle: Missing Goal\nstatus: open\ncreated: 2026-01-01T00:00:00.000Z\nupdated: 2026-01-01T00:00:00.000Z\n---\n\nmissing required goal\n',
-      'utf-8',
-    );
-
-    injectBrokenManifestReference(workspacePath);
-
-    const before = diagnoseVaultHealth(workspacePath, {
-      staleAfterMs: 60 * 60 * 1000,
-    });
-    expect(issueCount(before, 'orphan-wiki-link')).toBeGreaterThan(0);
-    expect(issueCount(before, 'stale-claim')).toBeGreaterThan(0);
-    expect(issueCount(before, 'stale-run')).toBeGreaterThan(0);
-    expect(issueCount(before, 'missing-required-field')).toBeGreaterThan(0);
-    expect(issueCount(before, 'broken-primitive-registry-reference')).toBeGreaterThan(0);
-    expect(issueCount(before, 'duplicate-slug')).toBeGreaterThan(0);
-
-    const after = diagnoseVaultHealth(workspacePath, {
-      fix: true,
-      actor: 'doctor-bot',
-      staleAfterMs: 60 * 60 * 1000,
-    });
-    expect(after.fixes.orphanLinksRemoved).toBeGreaterThan(0);
-    expect(after.fixes.staleClaimsReleased).toBeGreaterThan(0);
-    expect(after.fixes.staleRunsCancelled).toBeGreaterThan(0);
-    expect(after.checks.orphanWikiLinks).toBe(0);
-    expect(after.checks.staleClaims).toBe(0);
-    expect(after.checks.staleRuns).toBe(0);
-
-    const alphaRaw = fs.readFileSync(path.join(workspacePath, alpha.path), 'utf-8');
-    expect(alphaRaw).not.toContain('[[threads/non-existent.md]]');
-    expect(alphaRaw).toContain(`[[${beta.path}]]`);
-    expect(ledger.currentOwner(workspacePath, beta.path)).toBeNull();
-    expect(dispatch.status(workspacePath, run.id).status).toBe('cancelled');
-  });
-
-  it('stats reports deterministic primitive, link, and velocity metrics', () => {
-    const baseline = computeVaultStats(workspacePath);
-    const baselineThreadCount = baseline.primitives.byType.thread ?? 0;
-    const baselineDecisionCount = baseline.primitives.byType.decision ?? 0;
-    const baselineLinkTotal = baseline.links.total;
-    const baselineOrphanCount = baseline.links.orphanCount;
-
-    const alpha = thread.createThread(workspacePath, 'Alpha Thread', 'goal alpha', 'agent-a');
-    const beta = thread.createThread(workspacePath, 'Beta Thread', 'goal beta', 'agent-a');
-    thread.claim(workspacePath, alpha.path, 'agent-a');
-    thread.done(workspacePath, alpha.path, 'agent-a', 'done https://github.com/versatly/workgraph/pull/24');
-    store.update(
-      workspacePath,
-      beta.path,
-      {},
-      `## Links\n\n- [[${alpha.path}]]\n- [[threads/missing-link.md]]\n`,
-      'agent-a',
-    );
-    store.create(workspacePath, 'decision', {
-      title: 'Design Choice',
-      date: new Date().toISOString(),
-    }, '', 'agent-a');
-
-    const stats = computeVaultStats(workspacePath);
-    expect(stats.primitives.total).toBe(baseline.primitives.total + 3);
-    expect(stats.primitives.byType.thread).toBe(baselineThreadCount + 2);
-    expect(stats.primitives.byType.decision).toBe(baselineDecisionCount + 1);
-    expect(stats.links.total).toBe(baselineLinkTotal + 1);
-    expect(stats.links.orphanCount).toBe(baselineOrphanCount + 1);
-    expect(stats.links.mostConnectedNodes.length).toBeGreaterThan(0);
-    expect(stats.frontmatter.averageCompleteness).toBeCloseTo(1, 5);
-    expect(stats.ledger.totalEvents).toBeGreaterThan(0);
-    const bucketTotal = stats.ledger.eventRatePerDay.byDay.reduce((sum, item) => sum + item.count, 0);
-    expect(bucketTotal).toBe(stats.ledger.totalEvents);
-    expect(stats.threads.completedCount).toBe(1);
-    expect(stats.threads.averageOpenToDoneHours).toBeGreaterThanOrEqual(0);
-  });
-
-  it('viz renders box-drawing graph output with focus mode', () => {
-    const root = thread.createThread(workspacePath, 'Root Node', 'root goal', 'agent-a');
-    const leaf = thread.createThread(workspacePath, 'Leaf Node', 'leaf goal', 'agent-a');
-    store.update(
-      workspacePath,
-      root.path,
-      {},
-      `See [[${leaf.path}]]`,
-      'agent-a',
-    );
-
-    const viz = visualizeVaultGraph(workspacePath, {
-      focus: root.path,
-      depth: 2,
-      color: false,
-    });
-    expect(viz.rendered).toContain(root.path);
-    expect(viz.rendered).toContain(leaf.path);
-    expect(viz.rendered).toContain('[thread]');
-    expect(viz.rendered.includes('├') || viz.rendered.includes('└')).toBe(true);
-    expect(viz.rendered).toContain('─▶');
-  });
-});
-
-function issueCount(report: ReturnType<typeof diagnoseVaultHealth>, code: string): number {
-  return report.issues.filter((issue) => issue.code === code).length;
-}
-
-function ageClaimEntry(workspacePath: string, targetPath: string, oldIso: string): void {
-  const ledgerPath = path.join(workspacePath, '.workgraph', 'ledger.jsonl');
-  const entries = ledger.readAll(workspacePath);
-  const claimIndex = entries.findIndex((entry) => entry.op === 'claim' && entry.target === targetPath);
-  if (claimIndex === -1) throw new Error(`Claim entry not found for ${targetPath}`);
-  entries[claimIndex].ts = oldIso;
-  fs.writeFileSync(ledgerPath, entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n', 'utf-8');
-}
-
-function ageRunEntry(workspacePath: string, runId: string, oldIso: string): void {
-  const runsPath = path.join(workspacePath, '.workgraph', 'dispatch-runs.json');
-  const parsed = JSON.parse(fs.readFileSync(runsPath, 'utf-8')) as {
-    runs?: Array<{ id: string; updatedAt: string }>;
-  };
-  const run = parsed.runs?.find((entry) => entry.id === runId);
-  if (!run) throw new Error(`Run not found: ${runId}`);
-  run.updatedAt = oldIso;
-  fs.writeFileSync(runsPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
-}
-
-function injectBrokenManifestReference(workspacePath: string): void {
-  const manifestPath = path.join(workspacePath, '.workgraph', 'primitive-registry.yaml');
-  const manifest = YAML.parse(fs.readFileSync(manifestPath, 'utf-8')) as {
-    primitives: Array<Record<string, unknown>>;
-  };
-  manifest.primitives.push({
-    name: 'ghost',
-    directory: 'ghosts',
-    canonical: false,
-    builtIn: false,
-    fields: [],
-  });
-  fs.writeFileSync(manifestPath, YAML.stringify(manifest), 'utf-8');
-}
diff --git a/packages/kernel/src/diagnostics/changelog.ts b/packages/kernel/src/diagnostics/changelog.ts
deleted file mode 100644
index da5ebfe..0000000
--- a/packages/kernel/src/diagnostics/changelog.ts
+++ /dev/null
@@ -1,171 +0,0 @@
-import * as ledger from '../ledger.js';
-import type { LedgerEntry } from '../types.js';
-import { inferPrimitiveTypeFromPath, parseDateToTimestamp } from './format.js';
-
-export interface ChangelogOptions {
-  since: string;
-  until?: string;
-}
-
-export interface ChangelogItem {
-  ts: string;
-  actor: string;
-  op: string;
-  target: string;
-  summary?: string;
-}
-
-export interface ChangelogTypeGroup {
-  primitiveType: string;
-  items: ChangelogItem[];
-}
-
-export interface ChangelogDayGroup {
-  day: string;
-  created: ChangelogTypeGroup[];
-  updated: ChangelogTypeGroup[];
-  completed: ChangelogTypeGroup[];
-}
-
-export interface ChangelogReport {
-  generatedAt: string;
-  workspacePath: string;
-  since: string;
-  until?: string;
-  totalEvents: number;
-  days: ChangelogDayGroup[];
-}
-
-type ChangelogAction = 'created' | 'updated' | 'completed';
-
-export function generateLedgerChangelog(workspacePath: string, options: ChangelogOptions): ChangelogReport {
-  const sinceTs = parseDateToTimestamp(options.since, '--since');
-  const untilTs = options.until ? parseDateToTimestamp(options.until, '--until') : null;
-  const allEntries = ledger.readAll(workspacePath);
-
-  const grouped = new Map<string, Record<ChangelogAction, Map<string, ChangelogItem[]>>>();
-  let matchedEventCount = 0;
-  for (const entry of allEntries) {
-    const eventTs = Date.parse(entry.ts);
-    if (!Number.isFinite(eventTs)) continue;
-    if (eventTs < sinceTs) continue;
-    if (untilTs !== null && eventTs > untilTs) continue;
-
-    const action = categorizeEntry(entry);
-    if (!action) continue;
-    matchedEventCount += 1;
-
-    const day = entry.ts.slice(0, 10);
-    const primitiveType = entry.type ?? inferPrimitiveTypeFromPath(entry.target) ?? 'unknown';
-    const dayGroup = grouped.get(day) ?? {
-      created: new Map<string, ChangelogItem[]>(),
-      updated: new Map<string, ChangelogItem[]>(),
-      completed: new Map<string, ChangelogItem[]>(),
-    };
-    const byType = dayGroup[action];
-    const items = byType.get(primitiveType) ?? [];
-    items.push({
-      ts: entry.ts,
-      actor: entry.actor,
-      op: entry.op,
-      target: entry.target,
-      summary: buildEntrySummary(entry),
-    });
-    byType.set(primitiveType, items);
-    grouped.set(day, dayGroup);
-  }
-
-  const days = [...grouped.entries()]
-    .sort((a, b) => b[0].localeCompare(a[0]))
-    .map(([day, dayGroup]) => ({
-      day,
-      created: normalizeTypeGroups(dayGroup.created),
-      updated: normalizeTypeGroups(dayGroup.updated),
-      completed: normalizeTypeGroups(dayGroup.completed),
-    }));
-
-  return {
-    generatedAt: new Date().toISOString(),
-    workspacePath,
-    since: options.since,
-    ...(options.until ? { until: options.until } : {}),
-    totalEvents: matchedEventCount,
-    days,
-  };
-}
-
-export function renderChangelogText(report: ChangelogReport): string[] {
-  if (report.days.length === 0) {
-    return [`No changelog activity found since ${report.since}.`];
-  }
-
-  const lines: string[] = [];
-  lines.push(`Changelog since ${report.since}${report.until ? ` until ${report.until}` : ''}`);
-  lines.push('');
-
-  for (const day of report.days) {
-    lines.push(`${day.day}`);
-    lines.push(...renderActionGroup('Created', day.created));
-    lines.push(...renderActionGroup('Updated', day.updated));
-    lines.push(...renderActionGroup('Completed', day.completed));
-    lines.push('');
-  }
-  return lines;
-}
-
-function renderActionGroup(title: string, groups: ChangelogTypeGroup[]): string[] {
-  if (groups.length === 0) {
-    return [`  ${title}: none`];
-  }
-  const lines: string[] = [`  ${title}:`];
-  for (const group of groups) {
-    lines.push(`    - ${group.primitiveType}:`);
-    for (const item of group.items) {
-      const time = item.ts.slice(11, 19);
-      const summarySuffix = item.summary ? ` — ${item.summary}` : '';
-      lines.push(`      - [${time}] ${item.target} (${item.actor})${summarySuffix}`);
-    }
-  }
-  return lines;
-}
-
-function normalizeTypeGroups(byType: Map<string, ChangelogItem[]>): ChangelogTypeGroup[] {
-  return [...byType.entries()]
-    .sort((a, b) => a[0].localeCompare(b[0]))
-    .map(([primitiveType, items]) => ({
-      primitiveType,
-      items: items.slice().sort((a, b) => a.ts.localeCompare(b.ts) || a.target.localeCompare(b.target)),
-    }));
-}
-
-function categorizeEntry(entry: LedgerEntry): ChangelogAction | null {
-  if (entry.op === 'create') return 'created';
-  if (entry.op === 'done') return 'completed';
-  if (entry.op === 'update') {
-    const toStatus = String(entry.data?.to_status ?? '');
-    if (isCompletedStatus(toStatus)) return 'completed';
-    return 'updated';
-  }
-  return null;
-}
-
-function isCompletedStatus(status: string): boolean {
-  const normalized = status.toLowerCase();
-  return normalized === 'done' || normalized === 'succeeded' || normalized === 'completed' || normalized === 'closed';
-}
-
-function buildEntrySummary(entry: LedgerEntry): string | undefined {
-  if (entry.op === 'create') {
-    return entry.data?.title ? `title: ${String(entry.data.title)}` : undefined;
-  }
-  if (entry.op === 'update') {
-    const changed = Array.isArray(entry.data?.changed) ? entry.data?.changed.map((value) => String(value)) : [];
-    if (changed.length > 0) return `changed: ${changed.join(', ')}`;
-    if (entry.data?.to_status) return `status: ${String(entry.data?.to_status)}`;
-    return undefined;
-  }
-  if (entry.op === 'done' && entry.data?.output) {
-    return `output: ${String(entry.data.output)}`;
-  }
-  return undefined;
-}
diff --git a/packages/kernel/src/diagnostics/doctor.ts b/packages/kernel/src/diagnostics/doctor.ts
deleted file mode 100644
index f4b829c..0000000
--- a/packages/kernel/src/diagnostics/doctor.ts
+++ /dev/null
@@ -1,581 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import YAML from 'yaml';
-import * as dispatch from '../dispatch.js';
-import * as graph from '../graph.js';
-import * as ledger from '../ledger.js';
-import * as store from '../store.js';
-import * as thread from '../thread.js';
-import { formatDurationHours } from './format.js';
-import { buildPrimitiveWikiGraph, loadPrimitiveInventory, type MissingWikiLink, type PrimitiveInventory } from './primitives.js';
-
-export type DoctorSeverity = 'warning' | 'error';
-
-export interface DoctorIssue {
-  code: string;
-  severity: DoctorSeverity;
-  message: string;
-  path?: string;
-  details?: Record<string, unknown>;
-}
-
-export interface DoctorChecks {
-  orphanWikiLinks: number;
-  staleClaims: number;
-  staleRuns: number;
-  missingRequiredFields: number;
-  brokenPrimitiveRegistryReferences: number;
-  emptyPrimitiveDirectories: number;
-  duplicateSlugs: number;
-}
-
-export interface DoctorFixSummary {
-  enabled: boolean;
-  orphanLinksRemoved: number;
-  staleClaimsReleased: number;
-  staleRunsCancelled: number;
-  filesUpdated: string[];
-  errors: string[];
-}
-
-export interface DoctorReport {
-  generatedAt: string;
-  workspacePath: string;
-  ok: boolean;
-  summary: {
-    errors: number;
-    warnings: number;
-  };
-  checks: DoctorChecks;
-  issues: DoctorIssue[];
-  fixes: DoctorFixSummary;
-}
-
-export interface DoctorOptions {
-  fix?: boolean;
-  actor?: string;
-  staleAfterMs?: number;
-}
-
-interface StaleClaim {
-  target: string;
-  owner: string;
-  claimedAt: string;
-  ageMs: number;
-}
-
-interface StaleRun {
-  id: string;
-  actor: string;
-  updatedAt: string;
-  ageMs: number;
-}
-
-interface DoctorFindings {
-  issues: DoctorIssue[];
-  checks: DoctorChecks;
-  orphanLinks: MissingWikiLink[];
-  staleClaims: StaleClaim[];
-  staleRuns: StaleRun[];
-}
-
-interface DispatchRunSnapshot {
-  id: string;
-  actor: string;
-  status: string;
-  updatedAt: string;
-}
-
-const DEFAULT_STALE_AFTER_MS = 60 * 60 * 1000;
-const DOCTOR_ACTOR = 'workgraph-doctor';
-
-export function diagnoseVaultHealth(workspacePath: string, options: DoctorOptions = {}): DoctorReport {
-  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
-  const fixEnabled = options.fix === true;
-  const fixActor = options.actor ?? DOCTOR_ACTOR;
-  const fixSummary: DoctorFixSummary = {
-    enabled: fixEnabled,
-    orphanLinksRemoved: 0,
-    staleClaimsReleased: 0,
-    staleRunsCancelled: 0,
-    filesUpdated: [],
-    errors: [],
-  };
-
-  let findings = collectDoctorFindings(workspacePath, staleAfterMs);
-  if (fixEnabled) {
-    const orphanFix = removeOrphanLinks(workspacePath, findings.orphanLinks);
-    fixSummary.orphanLinksRemoved = orphanFix.removedLinks;
-    fixSummary.filesUpdated.push(...orphanFix.filesUpdated);
-    fixSummary.errors.push(...orphanFix.errors);
-
-    const staleClaimFix = releaseStaleClaims(workspacePath, findings.staleClaims);
-    fixSummary.staleClaimsReleased = staleClaimFix.released;
-    fixSummary.errors.push(...staleClaimFix.errors);
-
-    const staleRunFix = cancelStaleRuns(workspacePath, findings.staleRuns, fixActor);
-    fixSummary.staleRunsCancelled = staleRunFix.cancelled;
-    fixSummary.errors.push(...staleRunFix.errors);
-
-    if (fixSummary.orphanLinksRemoved > 0) {
-      graph.refreshWikiLinkGraphIndex(workspacePath);
-    }
-    findings = collectDoctorFindings(workspacePath, staleAfterMs);
-  }
-
-  const warnings = findings.issues.filter((issue) => issue.severity === 'warning').length;
-  const errors = findings.issues.filter((issue) => issue.severity === 'error').length;
-  return {
-    generatedAt: new Date().toISOString(),
-    workspacePath,
-    ok: errors === 0,
-    summary: { errors, warnings },
-    checks: findings.checks,
-    issues: findings.issues,
-    fixes: {
-      ...fixSummary,
-      filesUpdated: fixSummary.filesUpdated.slice().sort((a, b) => a.localeCompare(b)),
-    },
-  };
-}
-
-function collectDoctorFindings(workspacePath: string, staleAfterMs: number): DoctorFindings {
-  const issues: DoctorIssue[] = [];
-  const now = Date.now();
-  let inventory: PrimitiveInventory | null = null;
-
-  try {
-    inventory = loadPrimitiveInventory(workspacePath);
-  } catch (error) {
-    issues.push({
-      code: 'primitive-inventory-load-failed',
-      severity: 'error',
-      message: `Failed to load primitive inventory: ${errorMessage(error)}`,
-    });
-  }
-
-  const primitiveGraph = inventory
-    ? buildPrimitiveWikiGraph(workspacePath, inventory)
-    : {
-        missingLinks: [] as MissingWikiLink[],
-      };
-
-  for (const orphan of primitiveGraph.missingLinks) {
-    issues.push({
-      code: 'orphan-wiki-link',
-      severity: 'warning',
-      message: `Orphan wiki-link in ${orphan.from}: ${orphan.token} -> ${orphan.normalizedTarget}`,
-      path: orphan.from,
-      details: {
-        token: orphan.token,
-        target: orphan.normalizedTarget,
-      },
-    });
-  }
-
-  if (inventory) {
-    for (const primitive of inventory.primitives) {
-      for (const requiredField of primitive.requiredFields) {
-        if (isMissingRequiredValue(primitive.fields[requiredField])) {
-          issues.push({
-            code: 'missing-required-field',
-            severity: 'error',
-            message: `Missing required frontmatter field "${requiredField}" on ${primitive.path}`,
-            path: primitive.path,
-            details: {
-              field: requiredField,
-              type: primitive.type,
-            },
-          });
-        }
-      }
-    }
-
-    for (const [slug, pathsForSlug] of inventory.slugToPaths.entries()) {
-      if (pathsForSlug.length <= 1) continue;
-      issues.push({
-        code: 'duplicate-slug',
-        severity: 'error',
-        message: `Duplicate slug "${slug}" is used by: ${pathsForSlug.join(', ')}`,
-        details: { slug, paths: pathsForSlug },
-      });
-    }
-  }
-
-  const staleClaims = collectStaleClaims(workspacePath, staleAfterMs, now);
-  for (const staleClaim of staleClaims) {
-    issues.push({
-      code: 'stale-claim',
-      severity: 'warning',
-      message: `Stale claim on ${staleClaim.target} by ${staleClaim.owner} (${formatDurationHours(staleClaim.ageMs / 3600000)} old)`,
-      path: staleClaim.target,
-      details: {
-        owner: staleClaim.owner,
-        claimedAt: staleClaim.claimedAt,
-      },
-    });
-  }
-
-  const staleRuns = collectStaleRuns(workspacePath, staleAfterMs, now);
-  for (const staleRun of staleRuns) {
-    issues.push({
-      code: 'stale-run',
-      severity: 'warning',
-      message: `Run ${staleRun.id} is stuck in running for ${formatDurationHours(staleRun.ageMs / 3600000)}`,
-      details: {
-        runId: staleRun.id,
-        actor: staleRun.actor,
-        updatedAt: staleRun.updatedAt,
-      },
-    });
-  }
-
-  const registryIssues = collectPrimitiveRegistryReferenceIssues(workspacePath, inventory);
-  issues.push(...registryIssues);
-
-  if (inventory) {
-    const emptyDirectoryIssues = collectEmptyPrimitiveDirectoryIssues(workspacePath, inventory);
-    issues.push(...emptyDirectoryIssues);
-  }
-
-  const checks: DoctorChecks = {
-    orphanWikiLinks: countIssues(issues, 'orphan-wiki-link'),
-    staleClaims: countIssues(issues, 'stale-claim'),
-    staleRuns: countIssues(issues, 'stale-run'),
-    missingRequiredFields: countIssues(issues, 'missing-required-field'),
-    brokenPrimitiveRegistryReferences: countIssues(issues, 'broken-primitive-registry-reference'),
-    emptyPrimitiveDirectories: countIssues(issues, 'empty-primitive-directory'),
-    duplicateSlugs: countIssues(issues, 'duplicate-slug'),
-  };
-
-  return {
-    issues: issues.sort((a, b) => severityRank(a.severity) - severityRank(b.severity) || a.code.localeCompare(b.code)),
-    checks,
-    orphanLinks: primitiveGraph.missingLinks,
-    staleClaims,
-    staleRuns,
-  };
-}
-
-function collectStaleClaims(workspacePath: string, staleAfterMs: number, now: number): StaleClaim[] {
-  const staleClaims: StaleClaim[] = [];
-  const claims = ledger.allClaims(workspacePath);
-  for (const [target, owner] of claims.entries()) {
-    const history = ledger.historyOf(workspacePath, target);
-    const lastClaim = history.slice().reverse().find((entry) => entry.op === 'claim');
-    if (!lastClaim) continue;
-    const claimTs = Date.parse(lastClaim.ts);
-    if (!Number.isFinite(claimTs)) continue;
-    const ageMs = now - claimTs;
-    if (ageMs <= staleAfterMs) continue;
-    staleClaims.push({
-      target,
-      owner,
-      claimedAt: lastClaim.ts,
-      ageMs,
-    });
-  }
-  return staleClaims.sort((a, b) => b.ageMs - a.ageMs || a.target.localeCompare(b.target));
-}
-
-function collectStaleRuns(workspacePath: string, staleAfterMs: number, now: number): StaleRun[] {
-  const runs = readDispatchRunsSnapshot(workspacePath)
-    .filter((run) => run.status === 'running');
-  const staleRuns: StaleRun[] = [];
-  for (const run of runs) {
-    const updatedTs = Date.parse(run.updatedAt);
-    if (!Number.isFinite(updatedTs)) continue;
-    const ageMs = now - updatedTs;
-    if (ageMs <= staleAfterMs) continue;
-    staleRuns.push({
-      id: run.id,
-      actor: run.actor,
-      updatedAt: run.updatedAt,
-      ageMs,
-    });
-  }
-  return staleRuns.sort((a, b) => b.ageMs - a.ageMs || a.id.localeCompare(b.id));
-}
-
-function collectPrimitiveRegistryReferenceIssues(workspacePath: string, inventory: PrimitiveInventory | null): DoctorIssue[] {
-  const issues: DoctorIssue[] = [];
-  const manifestPath = path.join(workspacePath, '.workgraph', 'primitive-registry.yaml');
-  if (!fs.existsSync(manifestPath)) {
-    issues.push({
-      code: 'broken-primitive-registry-reference',
-      severity: 'error',
-      message: 'Missing .workgraph/primitive-registry.yaml',
-      path: '.workgraph/primitive-registry.yaml',
-    });
-    return issues;
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = YAML.parse(fs.readFileSync(manifestPath, 'utf-8'));
-  } catch (error) {
-    issues.push({
-      code: 'broken-primitive-registry-reference',
-      severity: 'error',
-      message: `Unable to parse primitive-registry.yaml: ${errorMessage(error)}`,
-      path: '.workgraph/primitive-registry.yaml',
-    });
-    return issues;
-  }
-
-  const primitives = (parsed as { primitives?: Array<Record<string, unknown>> })?.primitives;
-  if (!Array.isArray(primitives)) {
-    issues.push({
-      code: 'broken-primitive-registry-reference',
-      severity: 'error',
-      message: 'primitive-registry.yaml is missing a "primitives" array.',
-      path: '.workgraph/primitive-registry.yaml',
-    });
-    return issues;
-  }
-
-  const seenNames = new Map<string, number>();
-  for (const primitiveEntry of primitives) {
-    const name = String(primitiveEntry.name ?? '').trim();
-    const directory = String(primitiveEntry.directory ?? '').trim();
-    if (!name || !directory) {
-      issues.push({
-        code: 'broken-primitive-registry-reference',
-        severity: 'error',
-        message: 'primitive-registry.yaml contains an entry with missing name or directory.',
-        path: '.workgraph/primitive-registry.yaml',
-      });
-      continue;
-    }
-
-    seenNames.set(name, (seenNames.get(name) ?? 0) + 1);
-    const registryType = inventory?.typeDefs.get(name);
-    if (!registryType) {
-      issues.push({
-        code: 'broken-primitive-registry-reference',
-        severity: 'error',
-        message: `primitive-registry.yaml references unknown primitive "${name}".`,
-        path: '.workgraph/primitive-registry.yaml',
-      });
-      continue;
-    }
-    if (registryType.directory !== directory) {
-      issues.push({
-        code: 'broken-primitive-registry-reference',
-        severity: 'error',
-        message: `primitive-registry.yaml directory mismatch for "${name}": expected "${registryType.directory}", got "${directory}".`,
-        path: '.workgraph/primitive-registry.yaml',
-      });
-    }
-    if (!fs.existsSync(path.join(workspacePath, directory))) {
-      issues.push({
-        code: 'broken-primitive-registry-reference',
-        severity: 'error',
-        message: `primitive-registry.yaml references missing directory "${directory}/".`,
-        path: '.workgraph/primitive-registry.yaml',
-      });
-    }
-  }
-
-  for (const [name, count] of seenNames.entries()) {
-    if (count <= 1) continue;
-    issues.push({
-      code: 'broken-primitive-registry-reference',
-      severity: 'error',
-      message: `primitive-registry.yaml has duplicate entries for primitive "${name}".`,
-      path: '.workgraph/primitive-registry.yaml',
-    });
-  }
-
-  if (inventory) {
-    const manifestNames = new Set(primitives.map((entry) => String(entry.name ?? '').trim()).filter(Boolean));
-    for (const typeName of inventory.typeDefs.keys()) {
-      if (manifestNames.has(typeName)) continue;
-      issues.push({
-        code: 'broken-primitive-registry-reference',
-        severity: 'warning',
-        message: `Registry type "${typeName}" is missing from primitive-registry.yaml.`,
-        path: '.workgraph/primitive-registry.yaml',
-      });
-    }
-  }
-
-  return issues;
-}
-
-function collectEmptyPrimitiveDirectoryIssues(workspacePath: string, inventory: PrimitiveInventory): DoctorIssue[] {
-  const issues: DoctorIssue[] = [];
-  for (const typeDef of inventory.typeDefs.values()) {
-    const directoryPath = path.join(workspacePath, typeDef.directory);
-    if (!fs.existsSync(directoryPath)) continue;
-    const markdownCount = listMarkdownFilesRecursive(directoryPath).length;
-    if (markdownCount > 0) continue;
-    issues.push({
-      code: 'empty-primitive-directory',
-      severity: 'warning',
-      message: `Primitive directory "${typeDef.directory}/" is empty.`,
-      path: `${typeDef.directory}/`,
-      details: {
-        type: typeDef.name,
-      },
-    });
-  }
-  return issues;
-}
-
-function removeOrphanLinks(
-  workspacePath: string,
-  orphanLinks: MissingWikiLink[],
-): { removedLinks: number; filesUpdated: string[]; errors: string[] } {
-  const errors: string[] = [];
-  const filesUpdated: string[] = [];
-  if (orphanLinks.length === 0) {
-    return { removedLinks: 0, filesUpdated, errors };
-  }
-
-  const tokensBySource = new Map<string, Set<string>>();
-  for (const orphan of orphanLinks) {
-    const tokenSet = tokensBySource.get(orphan.from) ?? new Set<string>();
-    tokenSet.add(orphan.token);
-    tokensBySource.set(orphan.from, tokenSet);
-  }
-
-  let removedLinks = 0;
-  for (const [sourcePath, tokenSet] of tokensBySource.entries()) {
-    const absPath = path.join(workspacePath, sourcePath);
-    if (!fs.existsSync(absPath)) continue;
-    try {
-      const raw = fs.readFileSync(absPath, 'utf-8');
-      let fileRemoved = 0;
-      const updated = raw.replace(/\[\[([^[\]]+)\]\]/g, (token) => {
-        if (!tokenSet.has(token)) return token;
-        fileRemoved += 1;
-        return '';
-      });
-      if (fileRemoved === 0) continue;
-      fs.writeFileSync(absPath, updated, 'utf-8');
-      removedLinks += fileRemoved;
-      filesUpdated.push(sourcePath);
-    } catch (error) {
-      errors.push(`Failed to remove orphan links from ${sourcePath}: ${errorMessage(error)}`);
-    }
-  }
-
-  return {
-    removedLinks,
-    filesUpdated: filesUpdated.sort((a, b) => a.localeCompare(b)),
-    errors,
-  };
-}
-
-function releaseStaleClaims(
-  workspacePath: string,
-  staleClaims: StaleClaim[],
-): { released: number; errors: string[] } {
-  const errors: string[] = [];
-  let released = 0;
-  for (const staleClaim of staleClaims) {
-    try {
-      thread.release(
-        workspacePath,
-        staleClaim.target,
-        staleClaim.owner,
-        'Auto-release stale claim by workgraph doctor',
-      );
-      released += 1;
-    } catch (error) {
-      const fallbackActor = staleClaim.owner || DOCTOR_ACTOR;
-      try {
-        ledger.append(workspacePath, fallbackActor, 'release', staleClaim.target, 'thread', {
-          reason: 'Auto-release stale claim by workgraph doctor',
-        });
-        const existing = store.read(workspacePath, staleClaim.target);
-        if (existing) {
-          store.update(
-            workspacePath,
-            staleClaim.target,
-            { status: 'open', owner: null },
-            undefined,
-            fallbackActor,
-          );
-        }
-        released += 1;
-      } catch (fallbackError) {
-        errors.push(
-          `Failed to release stale claim ${staleClaim.target}: ${errorMessage(error)} / fallback: ${errorMessage(fallbackError)}`,
-        );
-      }
-    }
-  }
-  return { released, errors };
-}
-
-function cancelStaleRuns(
-  workspacePath: string,
-  staleRuns: StaleRun[],
-  actor: string,
-): { cancelled: number; errors: string[] } {
-  const errors: string[] = [];
-  let cancelled = 0;
-  for (const staleRun of staleRuns) {
-    try {
-      dispatch.stop(workspacePath, staleRun.id, actor);
-      cancelled += 1;
-    } catch (error) {
-      errors.push(`Failed to cancel stale run ${staleRun.id}: ${errorMessage(error)}`);
-    }
-  }
-  return { cancelled, errors };
-}
-
-function readDispatchRunsSnapshot(workspacePath: string): DispatchRunSnapshot[] {
-  const runsPath = path.join(workspacePath, '.workgraph', 'dispatch-runs.json');
-  if (!fs.existsSync(runsPath)) return [];
-  try {
-    const parsed = JSON.parse(fs.readFileSync(runsPath, 'utf-8')) as { runs?: DispatchRunSnapshot[] };
-    return Array.isArray(parsed.runs)
-      ? parsed.runs
-      : [];
-  } catch {
-    return [];
-  }
-}
-
-function listMarkdownFilesRecursive(rootDirectory: string): string[] {
-  const files: string[] = [];
-  const stack = [rootDirectory];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    const entries = fs.readdirSync(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const absPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(absPath);
-        continue;
-      }
-      if (entry.isFile() && entry.name.endsWith('.md')) {
-        files.push(absPath);
-      }
-    }
-  }
-  return files;
-}
-
-function isMissingRequiredValue(value: unknown): boolean {
-  if (value === undefined || value === null) return true;
-  if (typeof value === 'string') return value.trim().length === 0;
-  return false;
-}
-
-function countIssues(issues: DoctorIssue[], code: string): number {
-  return issues.filter((issue) => issue.code === code).length;
-}
-
-function severityRank(severity: DoctorSeverity): number {
-  return severity === 'error' ? 0 : 1;
-}
-
-function errorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  return String(error);
-}
diff --git a/packages/kernel/src/diagnostics/format.ts b/packages/kernel/src/diagnostics/format.ts
deleted file mode 100644
index 999de48..0000000
--- a/packages/kernel/src/diagnostics/format.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-const ANSI = {
-  reset: '\u001B[0m',
-  dim: '\u001B[2m',
-  red: '\u001B[31m',
-  green: '\u001B[32m',
-  yellow: '\u001B[33m',
-  blue: '\u001B[34m',
-  magenta: '\u001B[35m',
-  cyan: '\u001B[36m',
-  gray: '\u001B[90m',
-} as const;
-
-export type AnsiColor = keyof typeof ANSI;
-
-export function supportsColor(enabledByOption: boolean): boolean {
-  if (!enabledByOption) return false;
-  if (process.env.NO_COLOR) return false;
-  return process.stdout.isTTY === true;
-}
-
-export function colorize(text: string, color: AnsiColor, enabled: boolean): string {
-  if (!enabled) return text;
-  if (!ANSI[color]) return text;
-  return `${ANSI[color]}${text}${ANSI.reset}`;
-}
-
-export function dim(text: string, enabled: boolean): string {
-  return colorize(text, 'dim', enabled);
-}
-
-export function parseDateToTimestamp(value: string, optionName: string): number {
-  const parsed = Date.parse(value);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Invalid ${optionName} value "${value}". Expected an ISO-8601 date/time.`);
-  }
-  return parsed;
-}
-
-export function parsePositiveInt(rawValue: string | undefined, fallback: number, optionName: string): number {
-  if (rawValue === undefined) return fallback;
-  const parsed = Number.parseInt(String(rawValue), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`Invalid ${optionName} value "${rawValue}". Expected a positive integer.`);
-  }
-  return parsed;
-}
-
-export function formatDurationHours(hours: number): string {
-  if (!Number.isFinite(hours) || hours < 0) return '0h';
-  if (hours < 1) {
-    const minutes = Math.round(hours * 60);
-    return `${minutes}m`;
-  }
-  if (hours < 24) {
-    return `${hours.toFixed(2)}h`;
-  }
-  return `${(hours / 24).toFixed(2)}d`;
-}
-
-export function inferPrimitiveTypeFromPath(targetPath: string): string | null {
-  const normalized = String(targetPath).replace(/\\/g, '/');
-  const segment = normalized.split('/')[0]?.trim();
-  if (!segment) return null;
-  if (!normalized.endsWith('.md')) return null;
-  const singular = segment.endsWith('s') ? segment.slice(0, -1) : segment;
-  return singular || null;
-}
diff --git a/packages/kernel/src/diagnostics/index.ts b/packages/kernel/src/diagnostics/index.ts
deleted file mode 100644
index 62aa91d..0000000
--- a/packages/kernel/src/diagnostics/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export * from './doctor.js';
-export * from './replay.js';
-export * from './viz.js';
-export * from './stats.js';
-export * from './changelog.js';
-export * from './render.js';
diff --git a/packages/kernel/src/diagnostics/primitives.ts b/packages/kernel/src/diagnostics/primitives.ts
deleted file mode 100644
index a466b29..0000000
--- a/packages/kernel/src/diagnostics/primitives.ts
+++ /dev/null
@@ -1,269 +0,0 @@
-import path from 'node:path';
-import * as query from '../query.js';
-import { loadRegistry } from '../registry.js';
-import type { PrimitiveInstance, PrimitiveTypeDefinition, Registry } from '../types.js';
-
-export interface PrimitiveNode extends PrimitiveInstance {
-  slug: string;
-  requiredFields: string[];
-  frontmatterCompleteness: number;
-}
-
-export interface PrimitiveInventory {
-  registry: Registry;
-  primitives: PrimitiveNode[];
-  byPath: Map<string, PrimitiveNode>;
-  byType: Map<string, PrimitiveNode[]>;
-  slugToPaths: Map<string, string[]>;
-  typeByDirectory: Map<string, string>;
-  typeDefs: Map<string, PrimitiveTypeDefinition>;
-}
-
-export interface WikiLinkMatch {
-  token: string;
-  rawTarget: string;
-}
-
-export interface PrimitiveEdge {
-  from: string;
-  to: string;
-}
-
-export interface MissingWikiLink {
-  from: string;
-  token: string;
-  rawTarget: string;
-  normalizedTarget: string;
-}
-
-export interface AmbiguousWikiLink {
-  from: string;
-  token: string;
-  rawTarget: string;
-  normalizedTarget: string;
-  candidates: string[];
-}
-
-export interface PrimitiveWikiGraph {
-  generatedAt: string;
-  nodes: string[];
-  edges: PrimitiveEdge[];
-  outgoing: Record<string, string[]>;
-  incoming: Record<string, string[]>;
-  hubs: Array<{ path: string; degree: number }>;
-  orphanNodes: string[];
-  missingLinks: MissingWikiLink[];
-  ambiguousLinks: AmbiguousWikiLink[];
-}
-
-type PrimitiveTargetResolution =
-  | { status: 'external'; normalizedTarget: string }
-  | { status: 'resolved'; normalizedTarget: string; path: string }
-  | { status: 'ambiguous'; normalizedTarget: string; candidates: string[] }
-  | { status: 'missing'; normalizedTarget: string }
-  | { status: 'non-primitive'; normalizedTarget: string };
-
-export function loadPrimitiveInventory(workspacePath: string): PrimitiveInventory {
-  const registry = loadRegistry(workspacePath);
-  const allPrimitives = query.queryPrimitives(workspacePath);
-  const byPath = new Map<string, PrimitiveNode>();
-  const byType = new Map<string, PrimitiveNode[]>();
-  const slugToPaths = new Map<string, string[]>();
-  const typeByDirectory = new Map<string, string>();
-  const typeDefs = new Map<string, PrimitiveTypeDefinition>();
-
-  for (const typeDef of Object.values(registry.types)) {
-    typeByDirectory.set(typeDef.directory, typeDef.name);
-    typeDefs.set(typeDef.name, typeDef);
-  }
-
-  const primitives: PrimitiveNode[] = allPrimitives.map((instance) => {
-    const typeDef = typeDefs.get(instance.type);
-    const requiredFields = Object.entries(typeDef?.fields ?? {})
-      .filter(([, fieldDef]) => fieldDef.required === true)
-      .map(([fieldName]) => fieldName);
-    const presentCount = requiredFields.filter((fieldName) => hasRequiredValue(instance.fields[fieldName])).length;
-    const frontmatterCompleteness = requiredFields.length === 0 ? 1 : presentCount / requiredFields.length;
-    const slug = path.basename(instance.path, '.md');
-    return {
-      ...instance,
-      slug,
-      requiredFields,
-      frontmatterCompleteness,
-    };
-  });
-
-  for (const primitive of primitives) {
-    byPath.set(primitive.path, primitive);
-    const existingByType = byType.get(primitive.type) ?? [];
-    existingByType.push(primitive);
-    byType.set(primitive.type, existingByType);
-
-    const existingBySlug = slugToPaths.get(primitive.slug) ?? [];
-    existingBySlug.push(primitive.path);
-    slugToPaths.set(primitive.slug, existingBySlug);
-  }
-
-  for (const list of byType.values()) {
-    list.sort((a, b) => a.path.localeCompare(b.path));
-  }
-  for (const [slug, pathsForSlug] of slugToPaths.entries()) {
-    slugToPaths.set(slug, pathsForSlug.slice().sort((a, b) => a.localeCompare(b)));
-  }
-
-  return {
-    registry,
-    primitives: primitives.slice().sort((a, b) => a.path.localeCompare(b.path)),
-    byPath,
-    byType,
-    slugToPaths,
-    typeByDirectory,
-    typeDefs,
-  };
-}
-
-export function buildPrimitiveWikiGraph(workspacePath: string, inventoryInput?: PrimitiveInventory): PrimitiveWikiGraph {
-  const inventory = inventoryInput ?? loadPrimitiveInventory(workspacePath);
-  const edgeSet = new Set<string>();
-  const outgoing = new Map<string, Set<string>>();
-  const incoming = new Map<string, Set<string>>();
-  const missingLinks: MissingWikiLink[] = [];
-  const ambiguousLinks: AmbiguousWikiLink[] = [];
-
-  for (const primitive of inventory.primitives) {
-    if (!outgoing.has(primitive.path)) outgoing.set(primitive.path, new Set<string>());
-    if (!incoming.has(primitive.path)) incoming.set(primitive.path, new Set<string>());
-
-    for (const link of extractWikiLinks(primitive.body)) {
-      const resolved = resolvePrimitiveWikiTarget(link.rawTarget, inventory);
-      if (resolved.status === 'resolved') {
-        const key = `${primitive.path}=>${resolved.path}`;
-        if (edgeSet.has(key)) continue;
-        edgeSet.add(key);
-        outgoing.get(primitive.path)!.add(resolved.path);
-        if (!incoming.has(resolved.path)) incoming.set(resolved.path, new Set<string>());
-        incoming.get(resolved.path)!.add(primitive.path);
-      } else if (resolved.status === 'missing') {
-        missingLinks.push({
-          from: primitive.path,
-          token: link.token,
-          rawTarget: link.rawTarget,
-          normalizedTarget: resolved.normalizedTarget,
-        });
-      } else if (resolved.status === 'ambiguous') {
-        ambiguousLinks.push({
-          from: primitive.path,
-          token: link.token,
-          rawTarget: link.rawTarget,
-          normalizedTarget: resolved.normalizedTarget,
-          candidates: resolved.candidates,
-        });
-      }
-    }
-  }
-
-  const edges = [...edgeSet]
-    .map((key) => {
-      const [from, to] = key.split('=>');
-      return { from, to };
-    })
-    .sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
-
-  const outgoingRecord = mapToSortedRecord(outgoing);
-  const incomingRecord = mapToSortedRecord(incoming);
-
-  const hubs = inventory.primitives
-    .map((primitive) => ({
-      path: primitive.path,
-      degree: (outgoingRecord[primitive.path]?.length ?? 0) + (incomingRecord[primitive.path]?.length ?? 0),
-    }))
-    .filter((entry) => entry.degree > 0)
-    .sort((a, b) => b.degree - a.degree || a.path.localeCompare(b.path));
-
-  const orphanNodes = inventory.primitives
-    .map((primitive) => primitive.path)
-    .filter((nodePath) => (outgoingRecord[nodePath]?.length ?? 0) === 0 && (incomingRecord[nodePath]?.length ?? 0) === 0)
-    .sort((a, b) => a.localeCompare(b));
-
-  return {
-    generatedAt: new Date().toISOString(),
-    nodes: inventory.primitives.map((primitive) => primitive.path),
-    edges,
-    outgoing: outgoingRecord,
-    incoming: incomingRecord,
-    hubs,
-    orphanNodes,
-    missingLinks: missingLinks.slice().sort((a, b) => a.from.localeCompare(b.from) || a.token.localeCompare(b.token)),
-    ambiguousLinks: ambiguousLinks
-      .slice()
-      .sort((a, b) => a.from.localeCompare(b.from) || a.token.localeCompare(b.token)),
-  };
-}
-
-export function extractWikiLinks(markdown: string): WikiLinkMatch[] {
-  const matches = markdown.matchAll(/\[\[([^[\]]+)\]\]/g);
-  const links: WikiLinkMatch[] = [];
-  for (const match of matches) {
-    const token = match[0];
-    const rawTarget = match[1]?.trim();
-    if (!token || !rawTarget) continue;
-    links.push({ token, rawTarget });
-  }
-  return links;
-}
-
-function resolvePrimitiveWikiTarget(rawTarget: string, inventory: PrimitiveInventory): PrimitiveTargetResolution {
-  const primary = rawTarget.split('|')[0]?.split('#')[0]?.trim() ?? '';
-  if (!primary) {
-    return { status: 'non-primitive', normalizedTarget: '' };
-  }
-  if (/^https?:\/\//i.test(primary)) {
-    return { status: 'external', normalizedTarget: primary };
-  }
-
-  const normalized = normalizeWikiTarget(primary);
-  if (normalized.includes('/')) {
-    if (inventory.byPath.has(normalized)) {
-      return { status: 'resolved', normalizedTarget: normalized, path: normalized };
-    }
-    const directory = normalized.split('/')[0];
-    if (inventory.typeByDirectory.has(directory)) {
-      return { status: 'missing', normalizedTarget: normalized };
-    }
-    return { status: 'non-primitive', normalizedTarget: normalized };
-  }
-
-  const slug = normalized.replace(/\.md$/i, '');
-  const candidates = inventory.slugToPaths.get(slug) ?? [];
-  if (candidates.length === 1) {
-    return { status: 'resolved', normalizedTarget: normalized, path: candidates[0] };
-  }
-  if (candidates.length > 1) {
-    return { status: 'ambiguous', normalizedTarget: normalized, candidates };
-  }
-  return { status: 'missing', normalizedTarget: normalized };
-}
-
-function normalizeWikiTarget(value: string): string {
-  const normalized = value
-    .replace(/\\/g, '/')
-    .replace(/^\.\//, '')
-    .trim();
-  if (!normalized) return normalized;
-  return normalized.endsWith('.md') ? normalized : `${normalized}.md`;
-}
-
-function hasRequiredValue(value: unknown): boolean {
-  if (value === undefined || value === null) return false;
-  if (typeof value === 'string') return value.trim().length > 0;
-  return true;
-}
-
-function mapToSortedRecord(source: Map<string, Set<string>>): Record<string, string[]> {
-  const output: Record<string, string[]> = {};
-  const sortedKeys = [...source.keys()].sort((a, b) => a.localeCompare(b));
-  for (const key of sortedKeys) {
-    output[key] = [...(source.get(key) ?? new Set<string>())].sort((a, b) => a.localeCompare(b));
-  }
-  return output;
-}
diff --git a/packages/kernel/src/diagnostics/render.ts b/packages/kernel/src/diagnostics/render.ts
deleted file mode 100644
index b822709..0000000
--- a/packages/kernel/src/diagnostics/render.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { formatDurationHours } from './format.js';
-import type { DoctorReport } from './doctor.js';
-import type { VaultStats } from './stats.js';
-
-export function renderDoctorReport(report: DoctorReport): string[] {
-  const lines: string[] = [];
-  lines.push(`Vault health: ${report.ok ? 'OK' : 'NOT OK'}`);
-  lines.push(`Errors: ${report.summary.errors}  Warnings: ${report.summary.warnings}`);
-  lines.push(
-    `Checks: orphan_links=${report.checks.orphanWikiLinks} stale_claims=${report.checks.staleClaims} stale_runs=${report.checks.staleRuns} missing_required=${report.checks.missingRequiredFields} broken_registry_refs=${report.checks.brokenPrimitiveRegistryReferences} empty_dirs=${report.checks.emptyPrimitiveDirectories} duplicate_slugs=${report.checks.duplicateSlugs}`,
-  );
-
-  if (report.fixes.enabled) {
-    lines.push(
-      `Auto-fix: removed_orphan_links=${report.fixes.orphanLinksRemoved} released_stale_claims=${report.fixes.staleClaimsReleased} cancelled_stale_runs=${report.fixes.staleRunsCancelled}`,
-    );
-    if (report.fixes.filesUpdated.length > 0) {
-      lines.push(`Updated files: ${report.fixes.filesUpdated.join(', ')}`);
-    }
-    if (report.fixes.errors.length > 0) {
-      lines.push(`Fix errors: ${report.fixes.errors.length}`);
-      for (const error of report.fixes.errors) {
-        lines.push(`  - ${error}`);
-      }
-    }
-  }
-
-  if (report.issues.length === 0) {
-    lines.push('No issues detected.');
-    return lines;
-  }
-
-  lines.push('Issues:');
-  for (const issue of report.issues) {
-    const pathSuffix = issue.path ? ` (${issue.path})` : '';
-    lines.push(`- [${issue.severity.toUpperCase()}] ${issue.code}${pathSuffix}: ${issue.message}`);
-  }
-  return lines;
-}
-
-export function renderStatsReport(stats: VaultStats): string[] {
-  const lines: string[] = [];
-  lines.push(`Primitives: total=${stats.primitives.total}`);
-  lines.push(
-    `By type: ${Object.entries(stats.primitives.byType).map(([type, count]) => `${type}=${count}`).join(', ') || 'none'}`,
-  );
-  lines.push(
-    `Links: total=${stats.links.total} density=${stats.links.wikiLinkDensity.toFixed(2)} orphan_links=${stats.links.orphanCount} orphan_nodes=${stats.links.orphanNodeCount}`,
-  );
-  lines.push(
-    `Top hubs: ${stats.links.mostConnectedNodes.slice(0, 5).map((hub) => `${hub.path}(${hub.degree})`).join(', ') || 'none'}`,
-  );
-  lines.push(
-    `Frontmatter completeness: avg=${(stats.frontmatter.averageCompleteness * 100).toFixed(1)}%`,
-  );
-  lines.push(
-    `Ledger event rate/day: avg=${stats.ledger.eventRatePerDay.average.toFixed(2)} over ${stats.ledger.eventRatePerDay.byDay.length} day(s)`,
-  );
-  lines.push(
-    `Thread velocity: completed=${stats.threads.completedCount} avg_open_to_done=${formatDurationHours(stats.threads.averageOpenToDoneHours)}`,
-  );
-  return lines;
-}
diff --git a/packages/kernel/src/diagnostics/replay.ts b/packages/kernel/src/diagnostics/replay.ts
deleted file mode 100644
index 8c4c974..0000000
--- a/packages/kernel/src/diagnostics/replay.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-import * as ledger from '../ledger.js';
-import type { LedgerEntry } from '../types.js';
-import { colorize, dim, parseDateToTimestamp, supportsColor } from './format.js';
-
-export type ReplayEventTypeFilter = 'create' | 'update' | 'transition';
-
-export interface ReplayOptions {
-  type?: ReplayEventTypeFilter;
-  actor?: string;
-  primitive?: string;
-  since?: string;
-  until?: string;
-  color?: boolean;
-}
-
-export interface ReplayUpdateDiff {
-  changedFields: string[];
-  statusTransition?: {
-    from: string | null;
-    to: string | null;
-  };
-}
-
-export interface ReplayEvent {
-  ts: string;
-  actor: string;
-  op: string;
-  target: string;
-  primitiveType?: string;
-  category: ReplayEventTypeFilter;
-  diff?: ReplayUpdateDiff;
-}
-
-export interface ReplayReport {
-  generatedAt: string;
-  workspacePath: string;
-  filters: {
-    type?: ReplayEventTypeFilter;
-    actor?: string;
-    primitive?: string;
-    since?: string;
-    until?: string;
-  };
-  totalEvents: number;
-  events: ReplayEvent[];
-}
-
-export function replayLedger(workspacePath: string, options: ReplayOptions = {}): ReplayReport {
-  const sinceTs = options.since ? parseDateToTimestamp(options.since, '--since') : null;
-  const untilTs = options.until ? parseDateToTimestamp(options.until, '--until') : null;
-  if (options.type && !isReplayTypeFilter(options.type)) {
-    throw new Error(`Invalid --type "${options.type}". Expected create|update|transition.`);
-  }
-
-  const allEntries = ledger.readAll(workspacePath);
-  const ordered = allEntries
-    .map((entry, index) => ({ entry, index }))
-    .sort((a, b) => {
-      const aTs = Date.parse(a.entry.ts);
-      const bTs = Date.parse(b.entry.ts);
-      const safeA = Number.isFinite(aTs) ? aTs : Number.MAX_SAFE_INTEGER;
-      const safeB = Number.isFinite(bTs) ? bTs : Number.MAX_SAFE_INTEGER;
-      return safeA - safeB || a.index - b.index;
-    })
-    .map((item) => item.entry);
-
-  const events = ordered
-    .filter((entry) => matchesReplayFilters(entry, options, sinceTs, untilTs))
-    .map((entry) => mapReplayEvent(entry));
-
-  return {
-    generatedAt: new Date().toISOString(),
-    workspacePath,
-    filters: {
-      ...(options.type ? { type: options.type } : {}),
-      ...(options.actor ? { actor: options.actor } : {}),
-      ...(options.primitive ? { primitive: options.primitive } : {}),
-      ...(options.since ? { since: options.since } : {}),
-      ...(options.until ? { until: options.until } : {}),
-    },
-    totalEvents: allEntries.length,
-    events,
-  };
-}
-
-export function renderReplayText(report: ReplayReport, options: { color?: boolean } = {}): string[] {
-  if (report.events.length === 0) {
-    return ['No ledger events matched the provided filters.'];
-  }
-
-  const colorEnabled = supportsColor(options.color !== false);
-  const lines: string[] = [];
-  for (const event of report.events) {
-    const categoryColor = event.category === 'create'
-      ? 'green'
-      : event.category === 'update'
-        ? 'yellow'
-        : 'cyan';
-    const categoryTag = colorize(event.category.toUpperCase().padEnd(10, ' '), categoryColor, colorEnabled);
-    const ts = dim(event.ts, colorEnabled);
-    lines.push(`${ts} ${categoryTag} ${event.op.padEnd(8, ' ')} ${event.actor} -> ${event.target}`);
-    if (event.diff) {
-      if (event.diff.changedFields.length > 0) {
-        lines.push(`  ${dim('Δ changed', colorEnabled)}: ${event.diff.changedFields.join(', ')}`);
-      }
-      if (event.diff.statusTransition) {
-        lines.push(
-          `  ${dim('Δ status', colorEnabled)}: ${String(event.diff.statusTransition.from)} -> ${String(event.diff.statusTransition.to)}`,
-        );
-      }
-    }
-  }
-  return lines;
-}
-
-function mapReplayEvent(entry: LedgerEntry): ReplayEvent {
-  const category = categoryForOp(entry.op);
-  const diff = entry.op === 'update' ? summarizeUpdateDiff(entry) : undefined;
-  return {
-    ts: entry.ts,
-    actor: entry.actor,
-    op: entry.op,
-    target: entry.target,
-    primitiveType: entry.type,
-    category,
-    ...(diff ? { diff } : {}),
-  };
-}
-
-function summarizeUpdateDiff(entry: LedgerEntry): ReplayUpdateDiff | undefined {
-  const changed = Array.isArray(entry.data?.changed)
-    ? entry.data?.changed.map((field) => String(field))
-    : [];
-  const fromStatus = toNullableString(entry.data?.from_status);
-  const toStatus = toNullableString(entry.data?.to_status);
-  if (changed.length === 0 && fromStatus === undefined && toStatus === undefined) {
-    return undefined;
-  }
-  return {
-    changedFields: changed,
-    ...(fromStatus !== undefined || toStatus !== undefined
-      ? {
-          statusTransition: {
-            from: fromStatus ?? null,
-            to: toStatus ?? null,
-          },
-        }
-      : {}),
-  };
-}
-
-function matchesReplayFilters(
-  entry: LedgerEntry,
-  options: ReplayOptions,
-  sinceTs: number | null,
-  untilTs: number | null,
-): boolean {
-  if (options.type && categoryForOp(entry.op) !== options.type) return false;
-  if (options.actor && entry.actor !== options.actor) return false;
-  if (options.primitive) {
-    const primitiveFilter = options.primitive.toLowerCase();
-    const target = entry.target.toLowerCase();
-    const type = String(entry.type ?? '').toLowerCase();
-    if (!target.includes(primitiveFilter) && type !== primitiveFilter) return false;
-  }
-  if (sinceTs !== null || untilTs !== null) {
-    const eventTs = Date.parse(entry.ts);
-    if (!Number.isFinite(eventTs)) return false;
-    if (sinceTs !== null && eventTs < sinceTs) return false;
-    if (untilTs !== null && eventTs > untilTs) return false;
-  }
-  return true;
-}
-
-function categoryForOp(op: string): ReplayEventTypeFilter {
-  if (op === 'create') return 'create';
-  if (op === 'update') return 'update';
-  return 'transition';
-}
-
-function isReplayTypeFilter(value: string): value is ReplayEventTypeFilter {
-  return value === 'create' || value === 'update' || value === 'transition';
-}
-
-function toNullableString(value: unknown): string | null | undefined {
-  if (value === undefined) return undefined;
-  if (value === null) return null;
-  return String(value);
-}
diff --git a/packages/kernel/src/diagnostics/stats.ts b/packages/kernel/src/diagnostics/stats.ts
deleted file mode 100644
index 69d3807..0000000
--- a/packages/kernel/src/diagnostics/stats.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-import * as ledger from '../ledger.js';
-import { buildPrimitiveWikiGraph, loadPrimitiveInventory, type PrimitiveNode } from './primitives.js';
-
-export interface VaultStats {
-  generatedAt: string;
-  workspacePath: string;
-  primitives: {
-    total: number;
-    byType: Record<string, number>;
-  };
-  links: {
-    total: number;
-    wikiLinkDensity: number;
-    graphDensityRatio: number;
-    orphanCount: number;
-    orphanNodeCount: number;
-    mostConnectedNodes: Array<{ path: string; degree: number }>;
-  };
-  frontmatter: {
-    averageCompleteness: number;
-    byType: Record<string, number>;
-  };
-  ledger: {
-    totalEvents: number;
-    eventRatePerDay: {
-      average: number;
-      byDay: Array<{ day: string; count: number }>;
-    };
-  };
-  threads: {
-    completedCount: number;
-    averageOpenToDoneHours: number;
-  };
-}
-
-export function computeVaultStats(workspacePath: string): VaultStats {
-  const inventory = loadPrimitiveInventory(workspacePath);
-  const primitiveGraph = buildPrimitiveWikiGraph(workspacePath, inventory);
-  const byType = buildPrimitiveCountByType(inventory.primitives);
-  const frontmatter = computeFrontmatterStats(inventory.primitives);
-  const allEntries = ledger.readAll(workspacePath);
-  const eventRate = computeEventRatePerDay(allEntries);
-  const threadVelocity = computeThreadVelocity(workspacePath, inventory.byType.get('thread') ?? []);
-  const nodeCount = primitiveGraph.nodes.length;
-  const edgeCount = primitiveGraph.edges.length;
-  const possibleDirectedEdges = nodeCount > 1 ? nodeCount * (nodeCount - 1) : 0;
-
-  return {
-    generatedAt: new Date().toISOString(),
-    workspacePath,
-    primitives: {
-      total: inventory.primitives.length,
-      byType,
-    },
-    links: {
-      total: edgeCount,
-      wikiLinkDensity: nodeCount > 0 ? edgeCount / nodeCount : 0,
-      graphDensityRatio: possibleDirectedEdges > 0 ? edgeCount / possibleDirectedEdges : 0,
-      orphanCount: primitiveGraph.missingLinks.length,
-      orphanNodeCount: primitiveGraph.orphanNodes.length,
-      mostConnectedNodes: primitiveGraph.hubs.slice(0, 10),
-    },
-    frontmatter,
-    ledger: {
-      totalEvents: allEntries.length,
-      eventRatePerDay: eventRate,
-    },
-    threads: threadVelocity,
-  };
-}
-
-function buildPrimitiveCountByType(primitives: PrimitiveNode[]): Record<string, number> {
-  const byType = primitives.reduce<Record<string, number>>((acc, primitive) => {
-    acc[primitive.type] = (acc[primitive.type] ?? 0) + 1;
-    return acc;
-  }, {});
-  return Object.keys(byType)
-    .sort((a, b) => a.localeCompare(b))
-    .reduce<Record<string, number>>((acc, typeName) => {
-      acc[typeName] = byType[typeName];
-      return acc;
-    }, {});
-}
-
-function computeFrontmatterStats(primitives: PrimitiveNode[]): VaultStats['frontmatter'] {
-  if (primitives.length === 0) {
-    return {
-      averageCompleteness: 1,
-      byType: {},
-    };
-  }
-
-  const totalsByType = new Map<string, { sum: number; count: number }>();
-  let sum = 0;
-  for (const primitive of primitives) {
-    sum += primitive.frontmatterCompleteness;
-    const current = totalsByType.get(primitive.type) ?? { sum: 0, count: 0 };
-    current.sum += primitive.frontmatterCompleteness;
-    current.count += 1;
-    totalsByType.set(primitive.type, current);
-  }
-
-  const byType = [...totalsByType.entries()]
-    .sort((a, b) => a[0].localeCompare(b[0]))
-    .reduce<Record<string, number>>((acc, [typeName, stats]) => {
-      acc[typeName] = stats.count > 0 ? stats.sum / stats.count : 1;
-      return acc;
-    }, {});
-
-  return {
-    averageCompleteness: sum / primitives.length,
-    byType,
-  };
-}
-
-function computeEventRatePerDay(entries: ReturnType<typeof ledger.readAll>): VaultStats['ledger']['eventRatePerDay'] {
-  if (entries.length === 0) {
-    return {
-      average: 0,
-      byDay: [],
-    };
-  }
-  const byDay = new Map<string, number>();
-  for (const entry of entries) {
-    const day = entry.ts.slice(0, 10);
-    if (!day) continue;
-    byDay.set(day, (byDay.get(day) ?? 0) + 1);
-  }
-  const dayCounts = [...byDay.entries()]
-    .sort((a, b) => a[0].localeCompare(b[0]))
-    .map(([day, count]) => ({ day, count }));
-  const totalCount = dayCounts.reduce((acc, item) => acc + item.count, 0);
-  return {
-    average: dayCounts.length > 0 ? totalCount / dayCounts.length : 0,
-    byDay: dayCounts,
-  };
-}
-
-function computeThreadVelocity(
-  workspacePath: string,
-  threads: PrimitiveNode[],
-): VaultStats['threads'] {
-  const durationsHours: number[] = [];
-  for (const thread of threads) {
-    const history = ledger.historyOf(workspacePath, thread.path);
-    const createEntry = history.find((entry) => entry.op === 'create');
-    const completionEntry = history.find((entry) =>
-      entry.op === 'done' ||
-      (entry.op === 'update' && String(entry.data?.to_status ?? '') === 'done')
-    );
-    if (!createEntry || !completionEntry) continue;
-    const start = Date.parse(createEntry.ts);
-    const end = Date.parse(completionEntry.ts);
-    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) continue;
-    durationsHours.push((end - start) / (1000 * 60 * 60));
-  }
-
-  const sum = durationsHours.reduce((acc, value) => acc + value, 0);
-  return {
-    completedCount: durationsHours.length,
-    averageOpenToDoneHours: durationsHours.length > 0 ? sum / durationsHours.length : 0,
-  };
-}
diff --git a/packages/kernel/src/diagnostics/viz.ts b/packages/kernel/src/diagnostics/viz.ts
deleted file mode 100644
index 0d42609..0000000
--- a/packages/kernel/src/diagnostics/viz.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-import path from 'node:path';
-import { colorize, dim, parsePositiveInt, supportsColor } from './format.js';
-import { buildPrimitiveWikiGraph, loadPrimitiveInventory, type PrimitiveInventory } from './primitives.js';
-
-export interface VizOptions {
-  focus?: string;
-  depth?: number;
-  top?: number;
-  color?: boolean;
-}
-
-export interface VizReport {
-  generatedAt: string;
-  workspacePath: string;
-  nodeCount: number;
-  edgeCount: number;
-  hubs: Array<{ path: string; degree: number }>;
-  focus?: string;
-  rendered: string;
-}
-
-const TYPE_COLORS = ['cyan', 'magenta', 'yellow', 'green', 'blue', 'red'] as const;
-
-export function visualizeVaultGraph(workspacePath: string, options: VizOptions = {}): VizReport {
-  const inventory = loadPrimitiveInventory(workspacePath);
-  const primitiveGraph = buildPrimitiveWikiGraph(workspacePath, inventory);
-  const depth = normalizeDepth(options.depth);
-  const top = normalizeTop(options.top);
-  const colorEnabled = supportsColor(options.color !== false);
-  const typeColorMap = buildTypeColorMap(inventory);
-  const labelForNode = (nodePath: string): string => {
-    const primitive = inventory.byPath.get(nodePath);
-    const typeName = primitive?.type ?? 'unknown';
-    const base = `${nodePath} [${typeName}]`;
-    const typeColor = typeColorMap.get(typeName) ?? 'gray';
-    return colorize(base, typeColor, colorEnabled);
-  };
-
-  let rendered = '';
-  let focusPath: string | undefined;
-  if (options.focus) {
-    focusPath = resolveFocusPath(options.focus, inventory);
-    rendered = renderFocusedGraph(focusPath, primitiveGraph, depth, labelForNode, colorEnabled);
-  } else {
-    rendered = renderTopHubGraph(primitiveGraph, depth, top, labelForNode, colorEnabled);
-  }
-
-  return {
-    generatedAt: new Date().toISOString(),
-    workspacePath,
-    nodeCount: primitiveGraph.nodes.length,
-    edgeCount: primitiveGraph.edges.length,
-    hubs: primitiveGraph.hubs,
-    ...(focusPath ? { focus: focusPath } : {}),
-    rendered,
-  };
-}
-
-function renderFocusedGraph(
-  focusPath: string,
-  graph: ReturnType<typeof buildPrimitiveWikiGraph>,
-  depth: number,
-  labelForNode: (nodePath: string) => string,
-  colorEnabled: boolean,
-): string {
-  const outgoing = graph.outgoing[focusPath] ?? [];
-  const incoming = graph.incoming[focusPath] ?? [];
-  const lines: string[] = [];
-  lines.push(labelForNode(focusPath));
-
-  const hasOutgoing = outgoing.length > 0;
-  const hasIncoming = incoming.length > 0;
-  if (!hasOutgoing && !hasIncoming) {
-    lines.push(`└─ ${dim('(no links)', colorEnabled)}`);
-    return lines.join('\n');
-  }
-
-  const sections: Array<{ title: string; neighbors: string[]; map: Record<string, string[]>; arrow: '▶' | '◀' }> = [];
-  if (outgoing.length > 0) {
-    sections.push({ title: 'Outgoing', neighbors: outgoing, map: graph.outgoing, arrow: '▶' });
-  }
-  if (incoming.length > 0) {
-    sections.push({ title: 'Incoming', neighbors: incoming, map: graph.incoming, arrow: '◀' });
-  }
-
-  sections.forEach((section, index) => {
-    const isLastSection = index === sections.length - 1;
-    lines.push(`${isLastSection ? '└' : '├'}─ ${section.title}`);
-    renderNeighbors({
-      lines,
-      map: section.map,
-      neighbors: section.neighbors,
-      depthRemaining: depth,
-      prefix: isLastSection ? '   ' : '│  ',
-      arrow: section.arrow,
-      labelForNode,
-      colorEnabled,
-      ancestors: new Set([focusPath]),
-    });
-  });
-
-  return lines.join('\n');
-}
-
-function renderTopHubGraph(
-  graph: ReturnType<typeof buildPrimitiveWikiGraph>,
-  depth: number,
-  top: number,
-  labelForNode: (nodePath: string) => string,
-  colorEnabled: boolean,
-): string {
-  const lines: string[] = [];
-  const hubs = graph.hubs.slice(0, top);
-  const roots = graph.nodes.length > top
-    ? hubs.map((hub) => hub.path)
-    : graph.nodes.slice().sort((a, b) => a.localeCompare(b));
-  const isTruncated = graph.nodes.length > top;
-
-  roots.forEach((root, rootIndex) => {
-    lines.push(labelForNode(root));
-    const neighbors = graph.outgoing[root] ?? [];
-    if (neighbors.length === 0) {
-      lines.push(`└─ ${dim('(no outgoing links)', colorEnabled)}`);
-    } else {
-      renderNeighbors({
-        lines,
-        map: graph.outgoing,
-        neighbors,
-        depthRemaining: depth,
-        prefix: '',
-        arrow: '▶',
-        labelForNode,
-        colorEnabled,
-        ancestors: new Set([root]),
-      });
-    }
-    if (rootIndex !== roots.length - 1) {
-      lines.push('');
-    }
-  });
-
-  if (isTruncated) {
-    lines.push('');
-    lines.push(dim(`Showing top ${roots.length} most-connected nodes of ${graph.nodes.length}.`, colorEnabled));
-  }
-
-  return lines.join('\n');
-}
-
-function renderNeighbors(params: {
-  lines: string[];
-  map: Record<string, string[]>;
-  neighbors: string[];
-  depthRemaining: number;
-  prefix: string;
-  arrow: '▶' | '◀';
-  labelForNode: (nodePath: string) => string;
-  colorEnabled: boolean;
-  ancestors: Set<string>;
-}): void {
-  if (params.depthRemaining <= 0) return;
-  const sortedNeighbors = params.neighbors.slice().sort((a, b) => a.localeCompare(b));
-  sortedNeighbors.forEach((neighbor, index) => {
-    const isLast = index === sortedNeighbors.length - 1;
-    const branch = isLast ? '└' : '├';
-    const cycle = params.ancestors.has(neighbor);
-    const cycleTag = cycle ? ` ${dim('(cycle)', params.colorEnabled)}` : '';
-    params.lines.push(`${params.prefix}${branch}─${params.arrow} ${params.labelForNode(neighbor)}${cycleTag}`);
-    if (cycle || params.depthRemaining <= 1) return;
-    const nextPrefix = `${params.prefix}${isLast ? '   ' : '│  '}`;
-    const nextAncestors = new Set(params.ancestors);
-    nextAncestors.add(neighbor);
-    renderNeighbors({
-      ...params,
-      neighbors: params.map[neighbor] ?? [],
-      depthRemaining: params.depthRemaining - 1,
-      prefix: nextPrefix,
-      ancestors: nextAncestors,
-    });
-  });
-}
-
-function normalizeDepth(depth: number | undefined): number {
-  if (depth === undefined) return 2;
-  return parsePositiveInt(String(depth), 2, '--depth');
-}
-
-function normalizeTop(top: number | undefined): number {
-  if (top === undefined) return 10;
-  return parsePositiveInt(String(top), 10, '--top');
-}
-
-function resolveFocusPath(focusInput: string, inventory: PrimitiveInventory): string {
-  const normalized = focusInput.replace(/\\/g, '/').trim();
-  if (!normalized) {
-    throw new Error('--focus value cannot be empty.');
-  }
-  const directCandidate = normalized.endsWith('.md') ? normalized : `${normalized}.md`;
-  if (inventory.byPath.has(normalized)) return normalized;
-  if (inventory.byPath.has(directCandidate)) return directCandidate;
-
-  const slug = path.basename(normalized, '.md');
-  const candidates = inventory.slugToPaths.get(slug) ?? [];
-  if (candidates.length === 1) return candidates[0];
-  if (candidates.length > 1) {
-    throw new Error(`Focus slug "${focusInput}" is ambiguous: ${candidates.join(', ')}`);
-  }
-  throw new Error(`Focus node "${focusInput}" was not found.`);
-}
-
-function buildTypeColorMap(inventory: PrimitiveInventory): Map<string, 'gray' | typeof TYPE_COLORS[number]> {
-  const map = new Map<string, 'gray' | typeof TYPE_COLORS[number]>();
-  const typeNames = [...inventory.typeDefs.keys()].sort((a, b) => a.localeCompare(b));
-  typeNames.forEach((typeName, index) => {
-    map.set(typeName, TYPE_COLORS[index % TYPE_COLORS.length]);
-  });
-  return map;
-}
diff --git a/packages/kernel/src/dispatch-evidence-loop.test.ts b/packages/kernel/src/dispatch-evidence-loop.test.ts
deleted file mode 100644
index 8551d60..0000000
--- a/packages/kernel/src/dispatch-evidence-loop.test.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import { loadRegistry, saveRegistry } from './registry.js';
-import {
-  auditTrail,
-  createRun,
-  executeRun,
-  listRunEvidence,
-  retryRun,
-} from './dispatch.js';
-import { registerDispatchAdapter } from './runtime-adapter-registry.js';
-import type { DispatchAdapter, DispatchAdapterExecutionInput, DispatchAdapterExecutionResult } from './runtime-adapter-contracts.js';
-
-let workspacePath: string;
-let gitAvailable = false;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-dispatch-evidence-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-  const gitInit = spawnSync('git', ['init'], {
-    cwd: workspacePath,
-    stdio: 'ignore',
-  });
-  gitAvailable = (gitInit.status ?? 1) === 0;
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('dispatch run evidence loop', () => {
-  it('captures immutable audit trail and execution evidence', async () => {
-    const command = `"${process.execPath}" -e "const fs=require('fs'); fs.mkdirSync('artifacts',{recursive:true}); fs.writeFileSync('artifacts/evidence.txt','ok'); console.log('tests: 3 passed, 0 failed'); console.log('proof artifacts/evidence.txt'); console.log('https://github.com/versatly/workgraph/pull/4242');"`;
-    const run = createRun(workspacePath, {
-      actor: 'agent-evidence',
-      adapter: 'shell-worker',
-      objective: 'Collect execution evidence',
-      context: {
-        shell_command: command,
-      },
-    });
-
-    const executed = await executeRun(workspacePath, run.id, {
-      actor: 'agent-evidence',
-      timeoutMs: 10_000,
-    });
-
-    expect(executed.status).toBe('succeeded');
-    expect((executed.evidenceChain?.count ?? 0) > 0).toBe(true);
-    expect((executed.audit?.eventCount ?? 0) > 0).toBe(true);
-
-    const evidence = listRunEvidence(workspacePath, run.id);
-    const evidenceTypes = new Set(evidence.map((entry) => entry.type));
-    expect(evidenceTypes.has('stdout')).toBe(true);
-    expect(evidenceTypes.has('test-result')).toBe(true);
-    expect(evidenceTypes.has('pr-url')).toBe(true);
-    expect(evidenceTypes.has('attachment')).toBe(true);
-    if (gitAvailable) {
-      expect(evidenceTypes.has('file-change')).toBe(true);
-    }
-
-    const trail = auditTrail(workspacePath, run.id);
-    expect(trail.some((entry) => entry.kind === 'run-created')).toBe(true);
-    expect(trail.some((entry) => entry.kind === 'run-execution-started')).toBe(true);
-    expect(trail.some((entry) => entry.kind === 'run-evidence-collected')).toBe(true);
-    expect(trail.some((entry) => entry.kind === 'run-execution-finished')).toBe(true);
-  });
-
-  it('fails gracefully on execution timeout and records timeout audit event', async () => {
-    registerDispatchAdapter('test-timeout-adapter', () =>
-      makeAdapter(async () =>
-        new Promise<DispatchAdapterExecutionResult>(() => {
-          // Intentional never-resolving execution promise to trigger dispatcher timeout.
-        })),
-    );
-
-    const run = createRun(workspacePath, {
-      actor: 'agent-timeout',
-      adapter: 'test-timeout-adapter',
-      objective: 'Trigger timeout path',
-    });
-
-    const finished = await executeRun(workspacePath, run.id, {
-      actor: 'agent-timeout',
-      timeoutMs: 25,
-    });
-
-    expect(finished.status).toBe('failed');
-    expect(finished.error).toContain('timed out');
-    const trail = auditTrail(workspacePath, run.id);
-    expect(trail.some((entry) => entry.kind === 'run-execution-timeout')).toBe(true);
-  });
-
-  it('retries failed runs into a new attempt', async () => {
-    registerDispatchAdapter('test-retry-adapter', () =>
-      makeAdapter(async (input) => {
-        if (input.context?.retry_attempt) {
-          return {
-            status: 'succeeded',
-            output: 'retry succeeded',
-            logs: [],
-          };
-        }
-        return {
-          status: 'failed',
-          error: 'first attempt failed',
-          logs: [],
-        };
-      }),
-    );
-
-    const source = createRun(workspacePath, {
-      actor: 'agent-retry',
-      adapter: 'test-retry-adapter',
-      objective: 'Retry target',
-    });
-    const failed = await executeRun(workspacePath, source.id, { actor: 'agent-retry' });
-    expect(failed.status).toBe('failed');
-
-    const retried = await retryRun(workspacePath, source.id, {
-      actor: 'agent-retry',
-    });
-    expect(retried.id).not.toBe(source.id);
-    expect(retried.status).toBe('succeeded');
-    expect(retried.context?.retry_of_run_id).toBe(source.id);
-    expect(retried.context?.retry_attempt).toBe(1);
-
-    const sourceTrail = auditTrail(workspacePath, source.id);
-    expect(sourceTrail.some((entry) => entry.kind === 'run-retried')).toBe(true);
-  });
-});
-
-function makeAdapter(
-  executeImpl: (input: DispatchAdapterExecutionInput) => Promise<DispatchAdapterExecutionResult>,
-): DispatchAdapter {
-  return {
-    name: 'test-adapter',
-    async create() {
-      return { runId: 'external-run', status: 'queued' };
-    },
-    async status(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async followup(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async stop(runId: string) {
-      return { runId, status: 'cancelled' };
-    },
-    async logs() {
-      return [];
-    },
-    execute: executeImpl,
-  };
-}
diff --git a/packages/kernel/src/dispatch-run-audit.ts b/packages/kernel/src/dispatch-run-audit.ts
deleted file mode 100644
index d70c646..0000000
--- a/packages/kernel/src/dispatch-run-audit.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import type { DispatchRunAuditEvent, DispatchRunAuditEventKind } from './types.js';
-
-const RUN_AUDIT_FILE = '.workgraph/dispatch-run-audit.jsonl';
-
-export interface AppendDispatchRunAuditEventInput {
-  runId: string;
-  actor: string;
-  kind: DispatchRunAuditEventKind;
-  data?: Record<string, unknown>;
-  ts?: string;
-}
-
-export function appendDispatchRunAuditEvent(
-  workspacePath: string,
-  input: AppendDispatchRunAuditEventInput,
-): DispatchRunAuditEvent {
-  const now = input.ts ?? new Date().toISOString();
-  const existing = listDispatchRunAuditEvents(workspacePath, input.runId);
-  const last = existing[existing.length - 1];
-  const event: Omit<DispatchRunAuditEvent, 'hash'> = {
-    id: `runevt_${randomUUID()}`,
-    runId: input.runId,
-    seq: (last?.seq ?? 0) + 1,
-    ts: now,
-    actor: input.actor,
-    kind: input.kind,
-    data: input.data ?? {},
-    prevHash: last?.hash,
-  };
-  const hash = hashAuditEvent(event);
-  const fullEvent: DispatchRunAuditEvent = {
-    ...event,
-    hash,
-  };
-  appendAuditLine(workspacePath, fullEvent);
-  return fullEvent;
-}
-
-export function listDispatchRunAuditEvents(
-  workspacePath: string,
-  runId?: string,
-): DispatchRunAuditEvent[] {
-  const filePath = runAuditPath(workspacePath);
-  if (!fs.existsSync(filePath)) return [];
-  let lines: string[] = [];
-  try {
-    lines = fs.readFileSync(filePath, 'utf-8')
-      .split('\n')
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-  const parsed: DispatchRunAuditEvent[] = [];
-  for (const line of lines) {
-    try {
-      const event = JSON.parse(line) as DispatchRunAuditEvent;
-      if (runId && event.runId !== runId) continue;
-      parsed.push(event);
-    } catch {
-      continue;
-    }
-  }
-  return parsed;
-}
-
-export function runAuditPath(workspacePath: string): string {
-  return path.join(workspacePath, RUN_AUDIT_FILE);
-}
-
-function appendAuditLine(workspacePath: string, event: DispatchRunAuditEvent): void {
-  const filePath = runAuditPath(workspacePath);
-  const directory = path.dirname(filePath);
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  fs.appendFileSync(filePath, `${JSON.stringify(event)}\n`, 'utf-8');
-}
-
-function hashAuditEvent(event: Omit<DispatchRunAuditEvent, 'hash'>): string {
-  return createHash('sha256')
-    .update(JSON.stringify(event))
-    .digest('hex');
-}
diff --git a/packages/kernel/src/dispatch-run-evidence.ts b/packages/kernel/src/dispatch-run-evidence.ts
deleted file mode 100644
index d7faba3..0000000
--- a/packages/kernel/src/dispatch-run-evidence.ts
+++ /dev/null
@@ -1,269 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { collectThreadEvidence } from './evidence.js';
-import type { DispatchAdapterExecutionResult } from './runtime-adapter-contracts.js';
-import type {
-  DispatchRunDispatchTracking,
-  DispatchRunEvidenceItem,
-  DispatchRunExternalIdentity,
-} from './types.js';
-
-const PR_URL_PATTERN = /\bhttps?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+\b/gi;
-const MAX_EVIDENCE_TEXT_CHARS = 3_000;
-const MAX_TEST_SIGNALS = 20;
-
-export interface DispatchExecutionEvidenceInput {
-  runId: string;
-  execution: DispatchAdapterExecutionResult;
-  beforeGitState: Set<string> | null;
-  afterGitState: Set<string> | null;
-}
-
-export interface DispatchExecutionEvidenceResult {
-  items: DispatchRunEvidenceItem[];
-  summary: {
-    count: number;
-    byType: Record<string, number>;
-    lastCollectedAt: string;
-  };
-}
-
-export interface DispatchExternalCorrelationEvidenceInput {
-  runId: string;
-  external?: DispatchRunExternalIdentity;
-  tracking?: DispatchRunDispatchTracking;
-  metadata?: Record<string, unknown>;
-}
-
-export function captureWorkspaceGitState(workspacePath: string): Set<string> | null {
-  const result = spawnSync('git', ['status', '--porcelain', '--untracked-files=all'], {
-    cwd: workspacePath,
-    encoding: 'utf-8',
-  });
-  if ((result.status ?? 1) !== 0) return null;
-  const files = new Set<string>();
-  for (const rawLine of result.stdout.split('\n')) {
-    const line = rawLine.trimEnd();
-    if (!line) continue;
-    const payload = line.slice(3).trim();
-    if (!payload) continue;
-    if (payload.includes(' -> ')) {
-      const [, target] = payload.split(' -> ');
-      if (target) files.add(target.trim());
-      continue;
-    }
-    files.add(payload);
-  }
-  return files;
-}
-
-export function collectDispatchExternalCorrelationEvidence(
-  input: DispatchExternalCorrelationEvidenceInput,
-): DispatchExecutionEvidenceResult {
-  const now = new Date().toISOString();
-  const evidence: DispatchRunEvidenceItem[] = [];
-  if (input.external?.provider && input.external.externalRunId) {
-    evidence.push(createEvidence(
-      input.runId,
-      now,
-      'external-correlation',
-      'adapter-external',
-      `${input.external.provider}:${input.external.externalRunId}`,
-      {
-        provider: input.external.provider,
-        external_run_id: input.external.externalRunId,
-        external_agent_id: input.external.externalAgentId,
-        external_thread_id: input.external.externalThreadId,
-        correlation_keys: input.external.correlationKeys ?? [],
-        last_known_status: input.external.lastKnownStatus,
-        last_known_at: input.external.lastKnownAt,
-        metadata: input.external.metadata ?? {},
-      },
-    ));
-  }
-  if (input.tracking?.outboundPayloadDigest) {
-    evidence.push(createEvidence(
-      input.runId,
-      now,
-      'metric',
-      'adapter-external',
-      input.tracking.outboundPayloadDigest,
-      {
-        kind: 'outbound_payload_digest',
-        dispatched_at: input.tracking.dispatchedAt,
-        last_sent_at: input.tracking.lastSentAt,
-        acknowledged: input.tracking.acknowledged === true,
-        acknowledged_at: input.tracking.acknowledgedAt,
-        retry_count: input.tracking.retryCount,
-      },
-    ));
-  }
-  if (input.metadata && Object.keys(input.metadata).length > 0) {
-    evidence.push(createEvidence(
-      input.runId,
-      now,
-      'metric',
-      'adapter-external',
-      clampText(JSON.stringify(input.metadata)),
-      {
-        kind: 'external_metadata',
-      },
-    ));
-  }
-  const deduped = dedupeEvidence(evidence);
-  return {
-    items: deduped,
-    summary: {
-      count: deduped.length,
-      byType: buildTypeCounts(deduped),
-      lastCollectedAt: now,
-    },
-  };
-}
-
-export function collectDispatchExecutionEvidence(
-  input: DispatchExecutionEvidenceInput,
-): DispatchExecutionEvidenceResult {
-  const now = new Date().toISOString();
-  const evidence: DispatchRunEvidenceItem[] = [];
-  const output = readOptionalText(input.execution.output);
-  const error = readOptionalText(input.execution.error);
-  const logLines = (input.execution.logs ?? []).map((entry) => `[${entry.level}] ${entry.message}`).join('\n');
-  const corpus = [output, error, logLines].filter(Boolean).join('\n');
-
-  if (output) {
-    evidence.push(createEvidence(input.runId, now, 'stdout', 'adapter-output', clampText(extractStdout(output))));
-  }
-  if (error) {
-    evidence.push(createEvidence(input.runId, now, 'stderr', 'adapter-error', clampText(error)));
-  }
-
-  const prUrls = dedupeStrings(corpus.match(PR_URL_PATTERN) ?? []);
-  for (const url of prUrls) {
-    evidence.push(createEvidence(input.runId, now, 'pr-url', 'derived', url));
-  }
-
-  const testSignals = extractTestSignals(corpus);
-  for (const signal of testSignals) {
-    evidence.push(createEvidence(input.runId, now, 'test-result', 'derived', signal));
-  }
-
-  const inferred = collectThreadEvidence(corpus);
-  for (const item of inferred) {
-    if (item.type === 'url') {
-      evidence.push(createEvidence(input.runId, now, 'url', 'derived', item.value));
-    } else if (item.type === 'attachment') {
-      evidence.push(createEvidence(input.runId, now, 'attachment', 'derived', item.value));
-    } else if (item.type === 'thread-ref') {
-      evidence.push(createEvidence(input.runId, now, 'thread-ref', 'derived', item.value));
-    } else {
-      evidence.push(createEvidence(input.runId, now, 'reply-ref', 'derived', item.value));
-    }
-  }
-
-  const changedFiles = diffGitStates(input.beforeGitState, input.afterGitState);
-  for (const file of changedFiles) {
-    evidence.push(createEvidence(input.runId, now, 'file-change', 'git', file));
-  }
-
-  if (input.execution.metrics && Object.keys(input.execution.metrics).length > 0) {
-    evidence.push(createEvidence(
-      input.runId,
-      now,
-      'metric',
-      'adapter-metric',
-      clampText(JSON.stringify(input.execution.metrics)),
-    ));
-  }
-
-  const deduped = dedupeEvidence(evidence);
-  return {
-    items: deduped,
-    summary: {
-      count: deduped.length,
-      byType: buildTypeCounts(deduped),
-      lastCollectedAt: now,
-    },
-  };
-}
-
-function createEvidence(
-  runId: string,
-  ts: string,
-  type: DispatchRunEvidenceItem['type'],
-  source: DispatchRunEvidenceItem['source'],
-  value: string,
-  metadata?: Record<string, unknown>,
-): DispatchRunEvidenceItem {
-  return {
-    id: `runev_${randomUUID()}`,
-    runId,
-    ts,
-    type,
-    source,
-    value,
-    ...(metadata ? { metadata } : {}),
-  };
-}
-
-function readOptionalText(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function extractStdout(output: string): string {
-  const match = output.match(/STDOUT:\n([\s\S]*?)\n\nSTDERR:/);
-  if (!match?.[1]) return output;
-  return match[1].trim();
-}
-
-function clampText(value: string): string {
-  if (value.length <= MAX_EVIDENCE_TEXT_CHARS) return value;
-  return `${value.slice(0, MAX_EVIDENCE_TEXT_CHARS)}\n...[truncated]`;
-}
-
-function extractTestSignals(text: string): string[] {
-  if (!text) return [];
-  const signals = text
-    .split('\n')
-    .map((line) => line.trim())
-    .filter((line) =>
-      line.length > 0
-      && /test|spec|vitest|jest|pass|fail|coverage/i.test(line)
-      && /(pass|fail|skip|todo|coverage)/i.test(line),
-    );
-  return dedupeStrings(signals).slice(0, MAX_TEST_SIGNALS);
-}
-
-function diffGitStates(before: Set<string> | null, after: Set<string> | null): string[] {
-  if (!before || !after) return [];
-  const diff: string[] = [];
-  for (const entry of after) {
-    if (!before.has(entry)) diff.push(entry);
-  }
-  return diff.sort((a, b) => a.localeCompare(b));
-}
-
-function dedupeEvidence(items: DispatchRunEvidenceItem[]): DispatchRunEvidenceItem[] {
-  const deduped = new Map<string, DispatchRunEvidenceItem>();
-  for (const item of items) {
-    const key = `${item.type}:${item.source}:${item.value}`;
-    if (!deduped.has(key)) {
-      deduped.set(key, item);
-    }
-  }
-  return [...deduped.values()];
-}
-
-function dedupeStrings(items: string[]): string[] {
-  return [...new Set(items.map((entry) => entry.trim()).filter(Boolean))];
-}
-
-function buildTypeCounts(items: DispatchRunEvidenceItem[]): Record<string, number> {
-  const counts: Record<string, number> = {};
-  for (const item of items) {
-    counts[item.type] = (counts[item.type] ?? 0) + 1;
-  }
-  return counts;
-}
diff --git a/packages/kernel/src/dispatch.test.ts b/packages/kernel/src/dispatch.test.ts
deleted file mode 100644
index 7013f61..0000000
--- a/packages/kernel/src/dispatch.test.ts
+++ /dev/null
@@ -1,407 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { loadRegistry, saveRegistry } from './registry.js';
-import {
-  claimThread,
-  createAndExecuteRun,
-  createRun,
-  executeRun,
-  followup,
-  heartbeat,
-  listRuns,
-  markRun,
-  recoverDispatchState,
-  reconcileExpiredLeases,
-  status,
-  stop,
-} from './dispatch.js';
-import { registerDispatchAdapter } from './runtime-adapter-registry.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import type {
-  DispatchAdapter,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-} from './runtime-adapter-contracts.js';
-import { InputValidationError } from './errors.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-dispatch-core-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('dispatch core module', () => {
-  it('creates idempotent runs and persists a run primitive', () => {
-    const first = createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Process backlog',
-      idempotencyKey: 'same-key',
-    });
-    const second = createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Process backlog duplicate',
-      idempotencyKey: 'same-key',
-    });
-
-    expect(second.id).toBe(first.id);
-
-    const runPrimitives = store.list(workspacePath, 'run')
-      .filter((instance) => String(instance.fields.run_id) === first.id);
-    expect(runPrimitives).toHaveLength(1);
-
-    const queuedRuns = listRuns(workspacePath, { status: 'queued' });
-    expect(queuedRuns.some((entry) => entry.id === first.id)).toBe(true);
-  });
-
-  it('records followup without implicitly starting queued runs and blocks followup after stop', () => {
-    const created = createRun(workspacePath, {
-      actor: 'agent-op',
-      objective: 'Prepare deployment',
-    });
-
-    const followed = followup(workspacePath, created.id, 'agent-op', 'Start execution');
-    expect(followed.status).toBe('queued');
-    expect(followed.followups).toHaveLength(1);
-    expect(followed.leaseExpires).toBeUndefined();
-
-    const stopped = stop(workspacePath, created.id, 'agent-op');
-    expect(stopped.status).toBe('cancelled');
-
-    expect(() => followup(workspacePath, created.id, 'agent-op', 'Retry')).toThrow(
-      `Cannot send follow-up to run ${created.id} in terminal status "cancelled".`,
-    );
-  });
-
-  it('enforces heartbeat state and extends lease for running runs', () => {
-    const created = createRun(workspacePath, {
-      actor: 'agent-lease',
-      objective: 'Long-running check',
-    });
-
-    expect(() =>
-      heartbeat(workspacePath, created.id, { actor: 'agent-lease', leaseMinutes: 5 }),
-    ).toThrow('Only running runs may heartbeat.');
-
-    markRun(workspacePath, created.id, 'agent-lease', 'running');
-    const touched = heartbeat(workspacePath, created.id, {
-      actor: 'agent-lease',
-      leaseMinutes: 5,
-    });
-    expect(touched.heartbeats).toHaveLength(1);
-    expect(touched.leaseDurationMinutes).toBe(5);
-    expect(Date.parse(String(touched.leaseExpires))).toBeGreaterThan(Date.now());
-  });
-
-  it('requeues expired running leases during reconcile', () => {
-    const run = createRun(workspacePath, {
-      actor: 'agent-ops',
-      objective: 'Lease reconcile target',
-    });
-    markRun(workspacePath, run.id, 'agent-ops', 'running');
-
-    const dispatchStatePath = path.join(workspacePath, '.workgraph', 'dispatch-runs.json');
-    const state = JSON.parse(fs.readFileSync(dispatchStatePath, 'utf-8')) as {
-      version: number;
-      runs: Array<Record<string, unknown>>;
-    };
-    const target = state.runs.find((entry) => entry.id === run.id);
-    expect(target).toBeDefined();
-    target!.status = 'running';
-    target!.leaseExpires = '2001-01-01T00:00:00.000Z';
-    fs.writeFileSync(dispatchStatePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
-
-    const reconciled = reconcileExpiredLeases(workspacePath, 'agent-ops');
-    expect(reconciled.requeuedRuns.map((entry) => entry.id)).toContain(run.id);
-
-    const after = status(workspacePath, run.id);
-    expect(after.status).toBe('queued');
-    expect(after.leaseExpires).toBeUndefined();
-  });
-
-  it('claims thread refs and rejects gate-blocked claims', () => {
-    thread.createThread(workspacePath, 'Claimable', 'Ready for claim', 'agent-seed');
-    const claimed = claimThread(workspacePath, 'claimable', 'agent-claim');
-    expect(claimed.thread.path).toBe('threads/claimable.md');
-    expect(claimed.gateCheck.allowed).toBe(true);
-
-    store.create(
-      workspacePath,
-      'policy-gate',
-      {
-        title: 'Need readiness fact',
-        status: 'active',
-        required_facts: ['facts/readiness.md'],
-        required_approvals: [],
-        min_age_seconds: 0,
-      },
-      'Gate requiring readiness fact.',
-      'agent-policy',
-    );
-    store.create(
-      workspacePath,
-      'thread',
-      {
-        title: 'Guarded task',
-        goal: 'Blocked by gate',
-        status: 'open',
-        priority: 'medium',
-        deps: [],
-        context_refs: [],
-        tags: [],
-        gates: ['policy-gates/need-readiness-fact.md'],
-        approvals: [],
-      },
-      'Cannot be claimed until gate passes.',
-      'agent-policy',
-    );
-
-    expect(() => claimThread(workspacePath, 'guarded-task', 'agent-claim')).toThrow(
-      'Quality gates blocked claim',
-    );
-  });
-
-  it('executes runs through registered adapter and stores output/metrics', async () => {
-    registerDispatchAdapter('test-exec-success', () =>
-      makeAdapter(async (input) => ({
-        status: 'succeeded',
-        output: `done:${input.objective}`,
-        logs: [{
-          ts: new Date().toISOString(),
-          level: 'info',
-          message: 'adapter execution complete',
-        }],
-        metrics: { steps: 3 },
-      })),
-    );
-
-    const run = createRun(workspacePath, {
-      actor: 'agent-exec',
-      adapter: 'test-exec-success',
-      objective: 'Adapter execution objective',
-    });
-    const finished = await executeRun(workspacePath, run.id, { actor: 'agent-exec' });
-
-    expect(finished.status).toBe('succeeded');
-    expect(finished.output).toBe('done:Adapter execution objective');
-    expect(finished.context?.adapter_metrics).toEqual({ steps: 3 });
-    expect(finished.logs.some((entry) => entry.message.includes('adapter execution complete'))).toBe(true);
-  });
-
-  it('keeps the lease alive while a long adapter execution is in flight', async () => {
-    registerDispatchAdapter('test-long-exec', () =>
-      makeAdapter(async () => {
-        await sleep(30);
-        return {
-          status: 'succeeded',
-          output: 'finished slowly',
-          logs: [],
-        };
-      }),
-    );
-
-    const run = createRun(workspacePath, {
-      actor: 'agent-keepalive',
-      adapter: 'test-long-exec',
-      objective: 'Lease keepalive objective',
-      context: {
-        run_lease_heartbeat_ms: 5,
-      },
-    });
-    const finished = await executeRun(workspacePath, run.id, {
-      actor: 'agent-keepalive',
-      timeoutMs: 500,
-    });
-
-    expect(finished.status).toBe('succeeded');
-    expect((finished.heartbeats ?? []).length).toBeGreaterThan(0);
-    expect(finished.context?.lease_heartbeat_ms).toBe(100);
-  });
-
-  it('aborts adapter execution when dispatch timeout fires', async () => {
-    let aborted = false;
-    registerDispatchAdapter('test-timeout-abort', () =>
-      makeAdapter(async (input) => new Promise<DispatchAdapterExecutionResult>((_resolve) => {
-        input.abortSignal?.addEventListener('abort', () => {
-          aborted = true;
-        }, { once: true });
-      })),
-    );
-
-    const run = createRun(workspacePath, {
-      actor: 'agent-timeout',
-      adapter: 'test-timeout-abort',
-      objective: 'Timeout objective',
-      context: {
-        run_lease_heartbeat_ms: 5,
-      },
-    });
-    const finished = await executeRun(workspacePath, run.id, {
-      actor: 'agent-timeout',
-      timeoutMs: 25,
-    });
-
-    expect(finished.status).toBe('failed');
-    expect(finished.error).toContain('timed out');
-    expect(aborted).toBe(true);
-  });
-
-  it('supports createAndExecuteRun convenience helper', async () => {
-    registerDispatchAdapter('test-create-and-exec', () =>
-      makeAdapter(async () => ({
-        status: 'failed',
-        error: 'synthetic failure',
-        logs: [{
-          ts: new Date().toISOString(),
-          level: 'error',
-          message: 'run failed from adapter',
-        }],
-      })),
-    );
-
-    const finished = await createAndExecuteRun(workspacePath, {
-      actor: 'agent-helper',
-      adapter: 'test-create-and-exec',
-      objective: 'Combined create+execute',
-    });
-
-    expect(finished.status).toBe('failed');
-    expect(finished.error).toBe('synthetic failure');
-  });
-
-  it('rejects adapters without execute or with non-terminal execute result', async () => {
-    registerDispatchAdapter('test-no-exec', () =>
-      makeAdapter(undefined),
-    );
-    const noExec = createRun(workspacePath, {
-      actor: 'agent-adapter',
-      adapter: 'test-no-exec',
-      objective: 'No execute adapter',
-    });
-    await expect(
-      executeRun(workspacePath, noExec.id, { actor: 'agent-adapter' }),
-    ).rejects.toThrow('does not implement execute()');
-
-    registerDispatchAdapter('test-invalid-terminal', () =>
-      makeAdapter(async () => ({
-        status: 'running',
-        logs: [{
-          ts: new Date().toISOString(),
-          level: 'warn',
-          message: 'still running',
-        }],
-      })),
-    );
-    const invalid = createRun(workspacePath, {
-      actor: 'agent-adapter',
-      adapter: 'test-invalid-terminal',
-      objective: 'Bad terminal status',
-    });
-    const invalidResult = await executeRun(workspacePath, invalid.id, { actor: 'agent-adapter' });
-    expect(invalidResult.status).toBe('failed');
-    expect(invalidResult.error).toContain('invalid terminal status "running"');
-  });
-
-  it('validates public inputs with typed errors', () => {
-    expect(() => createRun(workspacePath, {
-      actor: '??',
-      objective: 'Invalid actor',
-    })).toThrow(InputValidationError);
-    expect(() => status(workspacePath, 'bad-run-id')).toThrow(InputValidationError);
-  });
-
-  it('continues createRun when audit append fails', () => {
-    const auditPath = path.join(workspacePath, '.workgraph', 'dispatch-run-audit.jsonl');
-    fs.mkdirSync(auditPath, { recursive: true });
-    const run = createRun(workspacePath, {
-      actor: 'agent-audit',
-      objective: 'Audit failure should degrade gracefully',
-    });
-    expect(run.id.startsWith('run_')).toBe(true);
-    expect(status(workspacePath, run.id).id).toBe(run.id);
-  });
-
-  it('recovers orphaned running runs and removes corrupt run entries', () => {
-    const run = createRun(workspacePath, {
-      actor: 'agent-recover',
-      objective: 'Recover me',
-    });
-    markRun(workspacePath, run.id, 'agent-recover', 'running');
-
-    const dispatchStatePath = path.join(workspacePath, '.workgraph', 'dispatch-runs.json');
-    const state = JSON.parse(fs.readFileSync(dispatchStatePath, 'utf-8')) as {
-      version: number;
-      runs: Array<Record<string, unknown>>;
-    };
-    const target = state.runs.find((entry) => entry.id === run.id);
-    expect(target).toBeDefined();
-    target!.leaseExpires = undefined;
-    state.runs.push({
-      id: 'broken',
-      status: 'running',
-      objective: 'bad record',
-    });
-    fs.writeFileSync(dispatchStatePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
-
-    const recovery = recoverDispatchState(workspacePath, 'agent-repair');
-    expect(recovery.repairedRuns.map((entry) => entry.id)).toContain(run.id);
-    expect(recovery.removedCorruptRuns).toBe(1);
-    expect(status(workspacePath, run.id).status).toBe('queued');
-  });
-
-  it('cleans stale dispatch lock files before mutation', () => {
-    const lockName = `${crypto.createHash('sha1').update('dispatch-runs-state').digest('hex')}.lock`;
-    const lockPath = path.join(workspacePath, '.workgraph', 'locks', lockName);
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    fs.writeFileSync(lockPath, JSON.stringify({
-      pid: 999_999,
-      key: 'dispatch-runs-state',
-      createdAt: '2000-01-01T00:00:00.000Z',
-    }) + '\n', 'utf-8');
-
-    const run = createRun(workspacePath, {
-      actor: 'agent-lock',
-      objective: 'Stale lock recovery',
-    });
-    expect(run.id.startsWith('run_')).toBe(true);
-  });
-});
-
-function makeAdapter(
-  executeImpl?: (input: DispatchAdapterExecutionInput) => Promise<DispatchAdapterExecutionResult>,
-): DispatchAdapter {
-  return {
-    name: 'test-adapter',
-    async create() {
-      return { runId: 'external-run', status: 'queued' };
-    },
-    async status(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async followup(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async stop(runId: string) {
-      return { runId, status: 'cancelled' };
-    },
-    async logs() {
-      return [];
-    },
-    ...(executeImpl ? { execute: executeImpl } : {}),
-  };
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
diff --git a/packages/kernel/src/dispatch.ts b/packages/kernel/src/dispatch.ts
deleted file mode 100644
index 1d4ba8d..0000000
--- a/packages/kernel/src/dispatch.ts
+++ /dev/null
@@ -1,2855 +0,0 @@
-/**
- * Runtime dispatch contract with adapter-backed execution.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import * as auth from './auth.js';
-import * as ledger from './ledger.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import * as gate from './gate.js';
-import {
-  appendDispatchRunAuditEvent,
-  listDispatchRunAuditEvents,
-} from './dispatch-run-audit.js';
-import {
-  captureWorkspaceGitState,
-  collectDispatchExternalCorrelationEvidence,
-  collectDispatchExecutionEvidence,
-} from './dispatch-run-evidence.js';
-import {
-  findDispatchBrokerState,
-  hydrateRunWithDispatchBrokerState,
-  isBrokeredRun,
-  listDispatchBrokerStates,
-  mergeDispatchTracking,
-  mergeExternalIdentity,
-  normalizeDispatchTracking,
-  normalizeExternalIdentity,
-  readDispatchBrokerState,
-  updateDispatchBrokerState,
-} from './dispatch/external-run-state.js';
-import { resolveDispatchAdapter } from './runtime-adapter-registry.js';
-import {
-  ConflictError,
-  InputValidationError,
-  ResourceNotFoundError,
-  asWorkgraphError,
-} from './errors.js';
-import { atomicWriteFile, withFileLock } from './fs-reliability.js';
-import {
-  validateActorName,
-  validateIdempotencyKey,
-  validateObjective,
-  validateRunId,
-  validateWorkspacePath,
-} from './validation.js';
-import type {
-  DispatchAdapterCancelInput,
-  DispatchAdapterDispatchInput,
-  DispatchAdapterExternalIdentity,
-  DispatchAdapterExternalUpdate,
-  DispatchAdapterLogEntry,
-} from './runtime-adapter-contracts.js';
-import type {
-  DispatchRun,
-  DispatchRunAuditEvent,
-  DispatchRunDispatchTracking,
-  DispatchRunEvidenceItem,
-  DispatchRunExternalIdentity,
-  PrimitiveInstance,
-  RunStatus,
-} from './types.js';
-
-const RUNS_FILE = '.workgraph/dispatch-runs.json';
-const DEFAULT_LEASE_MINUTES = 30;
-const DEFAULT_EXECUTE_TIMEOUT_MS = 10 * 60_000;
-const DEFAULT_LEASE_HEARTBEAT_INTERVAL_MS = 60_000;
-const RUNS_LOCK_SCOPE = 'dispatch-runs-state';
-
-export interface DispatchCreateInput {
-  actor: string;
-  adapter?: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  idempotencyKey?: string;
-}
-
-export interface DispatchExecuteInput {
-  actor: string;
-  agents?: string[];
-  maxSteps?: number;
-  stepDelayMs?: number;
-  space?: string;
-  createCheckpoint?: boolean;
-  timeoutMs?: number;
-  dispatchMode?: 'direct' | 'self-assembly';
-  selfAssemblyAgent?: string;
-  selfAssemblyOptions?: Record<string, unknown>;
-}
-
-export interface DispatchHeartbeatInput {
-  actor: string;
-  leaseMinutes?: number;
-}
-
-export interface DispatchReconcileResult {
-  reconciledAt: string;
-  inspectedRuns: number;
-  requeuedRuns: DispatchRun[];
-}
-
-export interface DispatchHandoffInput {
-  actor: string;
-  to: string;
-  reason: string;
-  adapter?: string;
-}
-
-export interface DispatchHandoffResult {
-  sourceRun: DispatchRun;
-  handoffRun: DispatchRun;
-}
-
-export interface DispatchClaimResult {
-  thread: PrimitiveInstance;
-  gateCheck: gate.ThreadGateCheckResult;
-}
-
-export interface DispatchRetryInput {
-  actor: string;
-  adapter?: string;
-  objective?: string;
-  contextPatch?: Record<string, unknown>;
-  execute?: boolean;
-  agents?: string[];
-  maxSteps?: number;
-  stepDelayMs?: number;
-  space?: string;
-  createCheckpoint?: boolean;
-  timeoutMs?: number;
-  dispatchMode?: 'direct' | 'self-assembly';
-  selfAssemblyAgent?: string;
-  selfAssemblyOptions?: Record<string, unknown>;
-}
-
-export interface DispatchStateRecoveryResult {
-  repairedAt: string;
-  scannedRuns: number;
-  repairedRuns: DispatchRun[];
-  removedCorruptRuns: number;
-  warnings: string[];
-}
-
-export interface DispatchExternalReconcileInput {
-  actor: string;
-  runId?: string;
-  provider?: string;
-  externalRunId?: string;
-  correlationKeys?: string[];
-  status?: RunStatus;
-  output?: string;
-  error?: string;
-  acknowledged?: boolean;
-  acknowledgedAt?: string;
-  external?: DispatchRunExternalIdentity;
-  metadata?: Record<string, unknown>;
-  logs?: DispatchAdapterLogEntry[];
-  source?: 'dispatch' | 'poll' | 'event' | 'cancel';
-  ts?: string;
-}
-
-export interface DispatchExternalReconcileResult {
-  reconciledAt: string;
-  matchedRunId?: string;
-  statusChanged: boolean;
-  previousStatus?: RunStatus;
-  currentStatus?: RunStatus;
-  run?: DispatchRun;
-}
-
-export interface DispatchPollExternalRunsResult {
-  reconciledAt: string;
-  inspectedRuns: number;
-  reconciledRuns: DispatchRun[];
-  failures: Array<{
-    runId: string;
-    error: string;
-  }>;
-}
-
-function withDispatchOperation<T>(
-  operation: string,
-  context: {
-    workspacePath?: string;
-    runId?: string;
-    actor?: string;
-    threadPath?: string;
-  },
-  fn: () => T,
-): T {
-  try {
-    return fn();
-  } catch (error) {
-    throw asWorkgraphError(error, `Dispatch operation failed: ${operation}`, {
-      operation,
-      workspacePath: context.workspacePath,
-      runId: context.runId,
-      actor: context.actor,
-      threadPath: context.threadPath,
-    });
-  }
-}
-
-async function withDispatchOperationAsync<T>(
-  operation: string,
-  context: {
-    workspacePath?: string;
-    runId?: string;
-    actor?: string;
-    threadPath?: string;
-  },
-  fn: () => Promise<T>,
-): Promise<T> {
-  try {
-    return await fn();
-  } catch (error) {
-    throw asWorkgraphError(error, `Dispatch operation failed: ${operation}`, {
-      operation,
-      workspacePath: context.workspacePath,
-      runId: context.runId,
-      actor: context.actor,
-      threadPath: context.threadPath,
-    });
-  }
-}
-
-function withRunsMutation<T>(workspacePath: string, fn: (state: { version: number; runs: DispatchRun[] }) => T): T {
-  return withFileLock(workspacePath, RUNS_LOCK_SCOPE, () => {
-    const state = loadRuns(workspacePath);
-    const result = fn(state);
-    saveRuns(workspacePath, state);
-    return result;
-  });
-}
-
-function appendDispatchRunAuditEventSafe(
-  workspacePath: string,
-  payload: Parameters<typeof appendDispatchRunAuditEvent>[1],
-  options: {
-    runId?: string;
-    actor?: string;
-    operation?: string;
-  } = {},
-): void {
-  try {
-    appendDispatchRunAuditEvent(workspacePath, payload);
-  } catch (error) {
-    logDispatchWarning(
-      `Audit event append failed${options.operation ? ` during ${options.operation}` : ''}.`,
-      error,
-      {
-        runId: options.runId ?? payload.runId,
-        actor: options.actor ?? payload.actor,
-      },
-    );
-  }
-}
-
-function appendLedgerEventSafe(
-  workspacePath: string,
-  actor: string,
-  op: 'create' | 'update' | 'handoff',
-  target: string,
-  type: string,
-  data?: Record<string, unknown>,
-): void {
-  try {
-    ledger.append(workspacePath, actor, op, target, type, data);
-  } catch (error) {
-    logDispatchWarning('Ledger append failed for non-critical dispatch telemetry.', error, {
-      actor,
-      runId: target.replace('.workgraph/runs/', ''),
-    });
-  }
-}
-
-function ensureRunPrimitiveSafe(workspacePath: string, run: DispatchRun, actor: string): void {
-  try {
-    ensureRunPrimitive(workspacePath, run, actor);
-  } catch (error) {
-    logDispatchWarning('Run primitive creation failed; continuing dispatch operation.', error, {
-      runId: run.id,
-      actor,
-    });
-  }
-}
-
-function syncRunPrimitiveSafe(workspacePath: string, run: DispatchRun, actor: string): void {
-  try {
-    syncRunPrimitive(workspacePath, run, actor);
-  } catch (error) {
-    logDispatchWarning('Run primitive sync failed; continuing dispatch operation.', error, {
-      runId: run.id,
-      actor,
-    });
-  }
-}
-
-function validatedWorkspacePath(workspacePath: string, operation: string): string {
-  return validateWorkspacePath(workspacePath, { workspacePath, operation });
-}
-
-export function createRun(workspacePath: string, input: DispatchCreateInput): DispatchRun {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.create');
-  const safeActor = validateActorName(input.actor, {
-    workspacePath: safeWorkspacePath,
-    actor: input.actor,
-    operation: 'dispatch.run.create',
-  });
-  const safeObjective = validateObjective(input.objective, {
-    workspacePath: safeWorkspacePath,
-    actor: safeActor,
-    operation: 'dispatch.run.create',
-  });
-  const safeIdempotencyKey = validateIdempotencyKey(input.idempotencyKey, {
-    workspacePath: safeWorkspacePath,
-    actor: safeActor,
-    operation: 'dispatch.run.create',
-  });
-  return withDispatchOperation('dispatch.run.create', {
-    workspacePath: safeWorkspacePath,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.create', '.workgraph/dispatch-runs', [
-      'dispatch:run',
-    ]);
-    const result = withRunsMutation(safeWorkspacePath, (state) => {
-      if (safeIdempotencyKey) {
-        const existing = state.runs.find((run) => run.idempotencyKey === safeIdempotencyKey);
-        if (existing) {
-          return {
-            run: existing,
-            idempotencyHit: true,
-          };
-        }
-      }
-      const now = new Date().toISOString();
-      const run: DispatchRun = {
-        id: `run_${randomUUID()}`,
-        createdAt: now,
-        updatedAt: now,
-        actor: safeActor,
-        adapter: input.adapter ?? 'cursor-cloud',
-        objective: safeObjective,
-        status: 'queued',
-        leaseDurationMinutes: DEFAULT_LEASE_MINUTES,
-        heartbeats: [],
-        idempotencyKey: safeIdempotencyKey,
-        context: input.context,
-        followups: [],
-        logs: [
-          { ts: now, level: 'info', message: `Run created for objective: ${safeObjective}` },
-        ],
-      };
-      state.runs.push(run);
-      return {
-        run,
-        idempotencyHit: false,
-      };
-    });
-
-    if (result.idempotencyHit) {
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: result.run.id,
-        actor: safeActor,
-        kind: 'run-idempotency-hit',
-        data: {
-          idempotency_key: safeIdempotencyKey,
-        },
-      }, {
-        runId: result.run.id,
-        actor: safeActor,
-        operation: 'dispatch.run.create.idempotency',
-      });
-      return hydrateRunWithRuntimeMetadata(safeWorkspacePath, result.run);
-    }
-
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: result.run.id,
-      actor: safeActor,
-      kind: 'run-created',
-      data: {
-        adapter: result.run.adapter,
-        objective: result.run.objective,
-        status: result.run.status,
-        idempotency_key: result.run.idempotencyKey,
-      },
-    }, {
-      runId: result.run.id,
-      actor: safeActor,
-      operation: 'dispatch.run.create',
-    });
-    appendLedgerEventSafe(safeWorkspacePath, safeActor, 'create', `.workgraph/runs/${result.run.id}`, 'run', {
-      adapter: result.run.adapter,
-      objective: result.run.objective,
-      status: result.run.status,
-    });
-    ensureRunPrimitiveSafe(safeWorkspacePath, result.run, safeActor);
-    return hydrateRunWithRuntimeMetadata(safeWorkspacePath, result.run);
-  });
-}
-
-export function claimThread(workspacePath: string, threadRef: string, actor: string): DispatchClaimResult {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.thread.claim');
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    actor,
-    operation: 'dispatch.thread.claim',
-  });
-  return withDispatchOperation('dispatch.thread.claim', {
-    workspacePath: safeWorkspacePath,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.thread.claim', threadRef, [
-      'thread:claim',
-      'thread:manage',
-    ]);
-    const threadPath = resolveThreadRef(threadRef);
-    const gateCheck = gate.checkThreadGates(safeWorkspacePath, threadPath);
-    if (!gateCheck.allowed) {
-      throw new ConflictError(gate.summarizeGateFailures(gateCheck), {
-        workspacePath: safeWorkspacePath,
-        threadPath,
-        actor: safeActor,
-        operation: 'dispatch.thread.claim',
-      });
-    }
-    const claimedThread = thread.claim(safeWorkspacePath, threadPath, safeActor);
-    return {
-      thread: claimedThread,
-      gateCheck,
-    };
-  });
-}
-
-export function status(workspacePath: string, runId: string): DispatchRun {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.status');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.status',
-  });
-  return withDispatchOperation('dispatch.run.status', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-  }, () => {
-    const run = getRun(safeWorkspacePath, safeRunId);
-    if (!run) {
-      throw new ResourceNotFoundError(`Run not found: ${safeRunId}`, {
-        workspacePath: safeWorkspacePath,
-        runId: safeRunId,
-        operation: 'dispatch.run.status',
-      });
-    }
-    return hydrateRunWithRuntimeMetadata(safeWorkspacePath, run);
-  });
-}
-
-export function followup(workspacePath: string, runId: string, actor: string, input: string): DispatchRun {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.followup');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.followup',
-  });
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor,
-    operation: 'dispatch.run.followup',
-  });
-  const safeInput = String(input ?? '').trim();
-  if (!safeInput) {
-    throw new InputValidationError('Follow-up input must be a non-empty string.', {
-      workspacePath: safeWorkspacePath,
-      runId: safeRunId,
-      actor: safeActor,
-      operation: 'dispatch.run.followup',
-    });
-  }
-  return withDispatchOperation('dispatch.run.followup', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.followup', safeRunId, [
-      'dispatch:run',
-    ]);
-    const run = withRunsMutation(safeWorkspacePath, (state) => {
-      const target = state.runs.find((entry) => entry.id === safeRunId);
-      if (!target) {
-        throw new ResourceNotFoundError(`Run not found: ${safeRunId}`, {
-          workspacePath: safeWorkspacePath,
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.followup',
-        });
-      }
-      if (!['queued', 'running'].includes(target.status)) {
-        throw new ConflictError(
-          `Cannot send follow-up to run ${safeRunId} in terminal status "${target.status}".`,
-          {
-            workspacePath: safeWorkspacePath,
-            runId: safeRunId,
-            actor: safeActor,
-            operation: 'dispatch.run.followup',
-          },
-        );
-      }
-      const now = new Date().toISOString();
-      target.followups.push({ ts: now, actor: safeActor, input: safeInput });
-      target.updatedAt = now;
-      target.logs.push({
-        ts: now,
-        level: 'info',
-        message: `Follow-up from ${safeActor}: ${safeInput}`,
-      });
-      return target;
-    });
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: run.id,
-      actor: safeActor,
-      kind: 'run-followup',
-      data: {
-        input: safeInput,
-        status: run.status,
-      },
-    }, {
-      runId: run.id,
-      actor: safeActor,
-      operation: 'dispatch.run.followup',
-    });
-    appendLedgerEventSafe(safeWorkspacePath, safeActor, 'update', `.workgraph/runs/${run.id}`, 'run', {
-      followup: true,
-      status: run.status,
-    });
-    syncRunPrimitiveSafe(safeWorkspacePath, run, safeActor);
-    return hydrateRunWithRuntimeMetadata(safeWorkspacePath, run);
-  });
-}
-
-export function stop(workspacePath: string, runId: string, actor: string): DispatchRun {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.stop');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.stop',
-  });
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor,
-    operation: 'dispatch.run.stop',
-  });
-  return withDispatchOperation('dispatch.run.stop', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, () => {
-    const run = status(safeWorkspacePath, safeRunId);
-    if (wantsExternalBroker(run)) {
-      return requestBrokeredRunCancellation(safeWorkspacePath, run, safeActor);
-    }
-    return setStatus(safeWorkspacePath, safeRunId, safeActor, 'cancelled', 'Run cancelled by operator.');
-  });
-}
-
-export function markRun(
-  workspacePath: string,
-  runId: string,
-  actor: string,
-  nextStatus: Exclude<RunStatus, 'queued'>,
-  options: { output?: string; error?: string; contextPatch?: Record<string, unknown> } = {},
-): DispatchRun {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.mark');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.mark',
-  });
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor,
-    operation: 'dispatch.run.mark',
-  });
-  return withDispatchOperation('dispatch.run.mark', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.mark', safeRunId, [
-      'dispatch:run',
-    ]);
-    const run = setStatus(safeWorkspacePath, safeRunId, safeActor, nextStatus, `Run moved to ${nextStatus}.`);
-    if (options.output) run.output = options.output;
-    if (options.error) run.error = options.error;
-    if (options.contextPatch && Object.keys(options.contextPatch).length > 0) {
-      run.context = {
-        ...(run.context ?? {}),
-        ...options.contextPatch,
-      };
-    }
-    const target = withRunsMutation(safeWorkspacePath, (state) => {
-      const entry = state.runs.find((candidate) => candidate.id === safeRunId);
-      if (!entry) return null;
-      entry.output = run.output;
-      entry.error = run.error;
-      entry.context = run.context;
-      entry.updatedAt = new Date().toISOString();
-      return entry;
-    });
-    if (target) {
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: target.id,
-        actor: safeActor,
-        kind: 'run-marked',
-        data: {
-          status: target.status,
-          has_output: Boolean(target.output),
-          has_error: Boolean(target.error),
-          context_keys: Object.keys(target.context ?? {}),
-        },
-      }, {
-        runId: target.id,
-        actor: safeActor,
-        operation: 'dispatch.run.mark',
-      });
-      syncRunPrimitiveSafe(safeWorkspacePath, target, safeActor);
-    }
-    return hydrateRunWithRuntimeMetadata(safeWorkspacePath, target ?? run);
-  });
-}
-
-export function heartbeat(
-  workspacePath: string,
-  runId: string,
-  input: DispatchHeartbeatInput,
-): DispatchRun {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.heartbeat');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.heartbeat',
-  });
-  const safeActor = validateActorName(input.actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: input.actor,
-    operation: 'dispatch.run.heartbeat',
-  });
-  return withDispatchOperation('dispatch.run.heartbeat', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.heartbeat', safeRunId, [
-      'dispatch:run',
-    ]);
-    const run = withRunsMutation(safeWorkspacePath, (state) => {
-      const target = state.runs.find((entry) => entry.id === safeRunId);
-      if (!target) {
-        throw new ResourceNotFoundError(`Run not found: ${safeRunId}`, {
-          workspacePath: safeWorkspacePath,
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.heartbeat',
-        });
-      }
-      if (target.status !== 'running') {
-        throw new ConflictError(
-          `Cannot heartbeat run ${safeRunId} in "${target.status}" state. Only running runs may heartbeat.`,
-          {
-            workspacePath: safeWorkspacePath,
-            runId: safeRunId,
-            actor: safeActor,
-            operation: 'dispatch.run.heartbeat',
-          },
-        );
-      }
-
-      const now = new Date().toISOString();
-      target.heartbeats = [...(target.heartbeats ?? []), now];
-      applyLease(target, now, input.leaseMinutes);
-      target.updatedAt = now;
-      target.logs.push({
-        ts: now,
-        level: 'info',
-        message: `Lease heartbeat from ${safeActor}. Extended until ${target.leaseExpires}.`,
-      });
-      return target;
-    });
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: run.id,
-      actor: safeActor,
-      kind: 'run-heartbeat',
-      data: {
-        lease_expires: run.leaseExpires,
-        lease_duration_minutes: run.leaseDurationMinutes,
-        heartbeat_count: run.heartbeats?.length ?? 0,
-      },
-    }, {
-      runId: run.id,
-      actor: safeActor,
-      operation: 'dispatch.run.heartbeat',
-    });
-    appendLedgerEventSafe(safeWorkspacePath, safeActor, 'update', `.workgraph/runs/${run.id}`, 'run', {
-      heartbeat: true,
-      lease_expires: run.leaseExpires,
-    });
-    syncRunPrimitiveSafe(safeWorkspacePath, run, safeActor);
-    return hydrateRunWithRuntimeMetadata(safeWorkspacePath, run);
-  });
-}
-
-export function reconcileExpiredLeases(
-  workspacePath: string,
-  actor: string,
-): DispatchReconcileResult {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.reconcile');
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    actor,
-    operation: 'dispatch.run.reconcile',
-  });
-  return withDispatchOperation('dispatch.run.reconcile', {
-    workspacePath: safeWorkspacePath,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.reconcile', '.workgraph/dispatch-runs', [
-      'dispatch:run',
-      'policy:manage',
-    ]);
-    const nowMs = Date.now();
-    const nowIso = new Date(nowMs).toISOString();
-    const requeuedRuns = withRunsMutation(safeWorkspacePath, (state) => {
-      const requeued: DispatchRun[] = [];
-      for (const run of state.runs) {
-        if (run.status !== 'running') continue;
-        if (!run.leaseExpires) continue;
-        const leaseExpiresMs = Date.parse(run.leaseExpires);
-        if (!Number.isFinite(leaseExpiresMs) || leaseExpiresMs > nowMs) continue;
-        run.status = 'queued';
-        run.updatedAt = nowIso;
-        run.logs.push({
-          ts: nowIso,
-          level: 'warn',
-          message: `Lease expired at ${run.leaseExpires}. Run returned to queued.`,
-        });
-        clearLease(run);
-        requeued.push(run);
-      }
-      return requeued;
-    });
-    for (const run of requeuedRuns) {
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: run.id,
-        actor: safeActor,
-        kind: 'run-status-changed',
-        data: {
-          from_status: 'running',
-          to_status: 'queued',
-          reason: 'lease-expired',
-        },
-      }, {
-        runId: run.id,
-        actor: safeActor,
-        operation: 'dispatch.run.reconcile',
-      });
-      appendLedgerEventSafe(safeWorkspacePath, safeActor, 'update', `.workgraph/runs/${run.id}`, 'run', {
-        status: run.status,
-        reconciled_expired_lease: true,
-      });
-      syncRunPrimitiveSafe(safeWorkspacePath, run, safeActor);
-    }
-
-    return {
-      reconciledAt: nowIso,
-      inspectedRuns: loadRuns(safeWorkspacePath).runs.length,
-      requeuedRuns,
-    };
-  });
-}
-
-export function handoffRun(
-  workspacePath: string,
-  runId: string,
-  input: DispatchHandoffInput,
-): DispatchHandoffResult {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.handoff');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.handoff',
-  });
-  const safeActor = validateActorName(input.actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: input.actor,
-    operation: 'dispatch.run.handoff',
-  });
-  const safeToActor = validateActorName(input.to, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: input.to,
-    operation: 'dispatch.run.handoff',
-  });
-  const safeReason = String(input.reason ?? '').trim();
-  if (!safeReason) {
-    throw new InputValidationError('Handoff reason is required.', {
-      workspacePath: safeWorkspacePath,
-      runId: safeRunId,
-      actor: safeActor,
-      operation: 'dispatch.run.handoff',
-    });
-  }
-  return withDispatchOperation('dispatch.run.handoff', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.handoff', safeRunId, [
-      'dispatch:run',
-    ]);
-    const sourceRun = status(safeWorkspacePath, safeRunId);
-    const now = new Date().toISOString();
-    const handoffContext: Record<string, unknown> = {
-      ...(sourceRun.context ?? {}),
-      handoff_from_run_id: sourceRun.id,
-      handoff_from_actor: sourceRun.actor,
-      handoff_initiated_by: safeActor,
-      handoff_reason: safeReason,
-      handoff_at: now,
-    };
-    const created = createRun(safeWorkspacePath, {
-      actor: safeToActor,
-      adapter: input.adapter ?? sourceRun.adapter,
-      objective: sourceRun.objective,
-      context: handoffContext,
-    });
-
-    appendRunLogs(safeWorkspacePath, sourceRun.id, safeActor, [{
-      ts: now,
-      level: 'info',
-      message: `Run handed off to ${safeToActor} as ${created.id}. Reason: ${safeReason}`,
-    }]);
-    appendRunLogs(safeWorkspacePath, created.id, safeActor, [{
-      ts: now,
-      level: 'info',
-      message: `Handoff received from ${sourceRun.id} by ${safeActor}. Reason: ${safeReason}`,
-    }]);
-    appendLedgerEventSafe(safeWorkspacePath, safeActor, 'handoff', `.workgraph/runs/${sourceRun.id}`, 'run', {
-      from_run_id: sourceRun.id,
-      to_run_id: created.id,
-      to_actor: safeToActor,
-      reason: safeReason,
-    });
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: sourceRun.id,
-      actor: safeActor,
-      kind: 'run-handoff',
-      data: {
-        to_run_id: created.id,
-        to_actor: safeToActor,
-        reason: safeReason,
-      },
-    }, {
-      runId: sourceRun.id,
-      actor: safeActor,
-      operation: 'dispatch.run.handoff',
-    });
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: created.id,
-      actor: safeActor,
-      kind: 'run-handoff',
-      data: {
-        from_run_id: sourceRun.id,
-        from_actor: sourceRun.actor,
-        reason: safeReason,
-      },
-    }, {
-      runId: created.id,
-      actor: safeActor,
-      operation: 'dispatch.run.handoff',
-    });
-
-    return {
-      sourceRun: status(safeWorkspacePath, sourceRun.id),
-      handoffRun: status(safeWorkspacePath, created.id),
-    };
-  });
-}
-
-export function logs(workspacePath: string, runId: string): DispatchRun['logs'] {
-  return status(workspacePath, runId).logs;
-}
-
-export function auditTrail(workspacePath: string, runId: string): DispatchRunAuditEvent[] {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.audit');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.audit',
-  });
-  return withDispatchOperation('dispatch.run.audit', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-  }, () => {
-    const run = status(safeWorkspacePath, safeRunId);
-    try {
-      return listDispatchRunAuditEvents(safeWorkspacePath, run.id);
-    } catch (error) {
-      logDispatchWarning('Audit trail listing failed; returning an empty trail.', error, { runId: run.id });
-      return [];
-    }
-  });
-}
-
-export function listRunEvidence(workspacePath: string, runId: string): DispatchRunEvidenceItem[] {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.evidence');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.evidence',
-  });
-  return withDispatchOperation('dispatch.run.evidence', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-  }, () => {
-    const trail = auditTrail(safeWorkspacePath, safeRunId);
-    const evidence: DispatchRunEvidenceItem[] = [];
-    for (const entry of trail) {
-      if (entry.kind !== 'run-evidence-collected') continue;
-      const items = Array.isArray(entry.data.items) ? entry.data.items : [];
-      for (const item of items) {
-        if (!item || typeof item !== 'object') continue;
-        evidence.push(item as DispatchRunEvidenceItem);
-      }
-    }
-    return evidence;
-  });
-}
-
-export function listRuns(workspacePath: string, options: { status?: RunStatus; limit?: number } = {}): DispatchRun[] {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.list');
-  return withDispatchOperation('dispatch.run.list', { workspacePath: safeWorkspacePath }, () => {
-    const runs = loadRuns(safeWorkspacePath).runs
-      .filter((run) => (options.status ? run.status === options.status : true))
-      .map((run) => hydrateRunWithRuntimeMetadata(safeWorkspacePath, run))
-      .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    if (options.limit && options.limit > 0) {
-      return runs.slice(0, options.limit);
-    }
-    return runs;
-  });
-}
-
-export async function executeRun(
-  workspacePath: string,
-  runId: string,
-  input: DispatchExecuteInput,
-): Promise<DispatchRun> {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.execute');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.execute',
-  });
-  const safeActor = validateActorName(input.actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: input.actor,
-    operation: 'dispatch.run.execute',
-  });
-  return withDispatchOperationAsync('dispatch.run.execute', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, async () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.execute', safeRunId, [
-      'dispatch:run',
-    ]);
-    const existing = status(safeWorkspacePath, safeRunId);
-    if (!['queued', 'running'].includes(existing.status)) {
-      throw new ConflictError(
-        `Run ${safeRunId} is in terminal status "${existing.status}" and cannot be executed.`,
-        {
-          workspacePath: safeWorkspacePath,
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.execute',
-        },
-      );
-    }
-
-    const adapter = resolveDispatchAdapter(existing.adapter);
-    const resolvedDispatchMode = input.dispatchMode
-      ?? normalizeDispatchMode(existing.context?.dispatch_mode)
-      ?? 'direct';
-    const resolvedTimeoutMs = normalizeExecutionTimeoutMs(
-      input.timeoutMs ?? readOptionalNumber(existing.context?.run_timeout_ms),
-    );
-    const resolvedHeartbeatIntervalMs = normalizeLeaseHeartbeatIntervalMs(
-      readOptionalNumber(existing.context?.run_lease_heartbeat_ms),
-      existing.leaseDurationMinutes,
-    );
-    const abortController = new AbortController();
-    let beforeGitState: ReturnType<typeof captureWorkspaceGitState> = null;
-    try {
-      beforeGitState = captureWorkspaceGitState(safeWorkspacePath);
-    } catch (error) {
-      logDispatchWarning('Unable to capture pre-run git state; continuing without git evidence.', error, {
-        runId: safeRunId,
-        actor: safeActor,
-      });
-    }
-
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: safeRunId,
-      actor: safeActor,
-      kind: 'run-execution-started',
-      data: {
-        adapter: existing.adapter,
-        dispatch_mode: resolvedDispatchMode,
-        timeout_ms: resolvedTimeoutMs,
-      },
-    }, {
-      runId: safeRunId,
-      actor: safeActor,
-      operation: 'dispatch.run.execute',
-    });
-
-    if (resolvedDispatchMode === 'self-assembly') {
-      const selfAssembly = await attemptSelfAssembly(safeWorkspacePath, existing, {
-        ...input,
-        actor: safeActor,
-      });
-      appendRunLogs(safeWorkspacePath, safeRunId, safeActor, selfAssembly.logs);
-      if (!selfAssembly.ok) {
-        appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-          runId: safeRunId,
-          actor: safeActor,
-          kind: 'run-execution-error',
-          data: {
-            dispatch_mode: resolvedDispatchMode,
-            error: selfAssembly.error,
-            stage: 'self-assembly',
-          },
-        }, {
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.execute.self-assembly',
-        });
-        return markRun(safeWorkspacePath, safeRunId, safeActor, 'failed', {
-          error: selfAssembly.error,
-          contextPatch: {
-            dispatch_mode: resolvedDispatchMode,
-            self_assembly_failed: true,
-          },
-        });
-      }
-    }
-
-    if (wantsExternalBroker(existing)) {
-      try {
-        if (existing.external?.externalRunId) {
-          if (adapter.poll) {
-            await pollExternalRuns(safeWorkspacePath, safeActor, { runId: safeRunId });
-          }
-          return status(safeWorkspacePath, safeRunId);
-        }
-        return await attemptExternalBrokerDispatch(safeWorkspacePath, existing, safeActor, adapter);
-      } catch (error) {
-        return failBrokeredRun(safeWorkspacePath, safeRunId, safeActor, errorMessage(error));
-      }
-    }
-
-    if (!adapter.execute) {
-      throw new ConflictError(`Dispatch adapter "${existing.adapter}" does not implement execute().`, {
-        workspacePath: safeWorkspacePath,
-        runId: safeRunId,
-        actor: safeActor,
-        operation: 'dispatch.run.execute',
-      });
-    }
-
-    if (existing.status === 'queued') {
-      setStatus(safeWorkspacePath, safeRunId, safeActor, 'running', `Run started on adapter "${existing.adapter}".`);
-    }
-
-    const stopLeaseHeartbeat = startRunLeaseHeartbeat(
-      safeWorkspacePath,
-      safeRunId,
-      safeActor,
-      resolvedHeartbeatIntervalMs,
-    );
-    try {
-      const execution = await withExecutionTimeout(
-        adapter.execute({
-          workspacePath: safeWorkspacePath,
-          runId: safeRunId,
-          actor: safeActor,
-          objective: existing.objective,
-          context: existing.context,
-          agents: input.agents,
-          maxSteps: input.maxSteps,
-          stepDelayMs: input.stepDelayMs,
-          space: input.space,
-          createCheckpoint: input.createCheckpoint,
-          isCancelled: () => abortController.signal.aborted || getRun(safeWorkspacePath, safeRunId)?.status === 'cancelled',
-          onHeartbeat: () => {
-            heartbeat(safeWorkspacePath, safeRunId, { actor: safeActor });
-          },
-          abortSignal: abortController.signal,
-          heartbeatIntervalMs: resolvedHeartbeatIntervalMs,
-        }),
-        resolvedTimeoutMs,
-        safeRunId,
-        async () => {
-          abortController.abort();
-          await safeStopAdapterExecution(adapter, safeRunId, safeActor);
-        },
-      );
-
-      appendRunLogs(safeWorkspacePath, safeRunId, safeActor, execution.logs);
-      const currentRun = status(safeWorkspacePath, safeRunId);
-      if (currentRun.status === 'cancelled') {
-        appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-          runId: safeRunId,
-          actor: safeActor,
-          kind: 'run-execution-finished',
-          data: {
-            status: 'cancelled',
-            reason: 'execution result ignored after cancellation',
-          },
-        }, {
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.execute',
-        });
-        return currentRun;
-      }
-      const finalStatus = execution.status;
-      if (finalStatus === 'queued' || finalStatus === 'running') {
-        throw new ConflictError(`Adapter returned invalid terminal status "${finalStatus}" for execute().`, {
-          workspacePath: safeWorkspacePath,
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.execute',
-        });
-      }
-      let evidenceSummary: DispatchRun['evidenceChain'] | undefined;
-      try {
-        const afterGitState = captureWorkspaceGitState(safeWorkspacePath);
-        const evidence = collectDispatchExecutionEvidence({
-          runId: safeRunId,
-          execution,
-          beforeGitState,
-          afterGitState,
-        });
-        evidenceSummary = evidence.summary;
-        appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-          runId: safeRunId,
-          actor: safeActor,
-          kind: 'run-evidence-collected',
-          data: {
-            items: evidence.items,
-            summary: evidence.summary,
-          },
-        }, {
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.execute.evidence',
-        });
-      } catch (error) {
-        logDispatchWarning('Evidence collection failed; completing run without evidence chain.', error, {
-          runId: safeRunId,
-          actor: safeActor,
-        });
-        appendRunLogs(safeWorkspacePath, safeRunId, safeActor, [{
-          ts: new Date().toISOString(),
-          level: 'warn',
-          message: `Evidence collection failed: ${errorMessage(error)}`,
-        }]);
-      }
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: safeRunId,
-        actor: safeActor,
-        kind: 'run-execution-finished',
-        data: {
-          status: finalStatus,
-          evidence_count: evidenceSummary?.count ?? 0,
-        },
-      }, {
-        runId: safeRunId,
-        actor: safeActor,
-        operation: 'dispatch.run.execute',
-      });
-
-      return markRun(safeWorkspacePath, safeRunId, safeActor, finalStatus, {
-        output: execution.output,
-        error: execution.error,
-        contextPatch: {
-          ...(execution.metrics ? { adapter_metrics: execution.metrics } : {}),
-          dispatch_mode: resolvedDispatchMode,
-          lease_heartbeat_ms: resolvedHeartbeatIntervalMs,
-          ...(evidenceSummary ? { evidence_chain: evidenceSummary } : {}),
-        },
-      });
-    } catch (error) {
-      const message = errorMessage(error);
-      const statusValue = status(safeWorkspacePath, safeRunId);
-      if (statusValue.status === 'cancelled') {
-        appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-          runId: safeRunId,
-          actor: safeActor,
-          kind: 'run-execution-finished',
-          data: {
-            status: 'cancelled',
-            reason: 'execution cancelled',
-          },
-        }, {
-          runId: safeRunId,
-          actor: safeActor,
-          operation: 'dispatch.run.execute',
-        });
-        return statusValue;
-      }
-      const kind = message.includes('timed out')
-        ? 'run-execution-timeout'
-        : 'run-execution-error';
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: safeRunId,
-        actor: safeActor,
-        kind,
-        data: {
-          error: message,
-        },
-      }, {
-        runId: safeRunId,
-        actor: safeActor,
-        operation: 'dispatch.run.execute',
-      });
-      return markRun(safeWorkspacePath, safeRunId, safeActor, 'failed', {
-        error: message,
-        contextPatch: {
-          dispatch_mode: resolvedDispatchMode,
-          lease_heartbeat_ms: resolvedHeartbeatIntervalMs,
-        },
-      });
-    } finally {
-      stopLeaseHeartbeat();
-      abortController.abort();
-    }
-  });
-}
-
-export async function createAndExecuteRun(
-  workspacePath: string,
-  createInput: DispatchCreateInput,
-  executeInput: Omit<DispatchExecuteInput, 'actor'> = {},
-): Promise<DispatchRun> {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.create-execute');
-  return withDispatchOperationAsync('dispatch.run.create-execute', {
-    workspacePath: safeWorkspacePath,
-    actor: createInput.actor,
-  }, async () => {
-    const run = createRun(safeWorkspacePath, createInput);
-    return executeRun(safeWorkspacePath, run.id, {
-      actor: createInput.actor,
-      ...executeInput,
-    });
-  });
-}
-
-export async function retryRun(
-  workspacePath: string,
-  runId: string,
-  input: DispatchRetryInput,
-): Promise<DispatchRun> {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.retry');
-  const safeRunId = validateRunId(runId, {
-    workspacePath: safeWorkspacePath,
-    runId,
-    operation: 'dispatch.run.retry',
-  });
-  const safeActor = validateActorName(input.actor, {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: input.actor,
-    operation: 'dispatch.run.retry',
-  });
-  return withDispatchOperationAsync('dispatch.run.retry', {
-    workspacePath: safeWorkspacePath,
-    runId: safeRunId,
-    actor: safeActor,
-  }, async () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.retry', safeRunId, [
-      'dispatch:run',
-    ]);
-    const source = status(safeWorkspacePath, safeRunId);
-    if (source.status !== 'failed') {
-      throw new ConflictError(`Run ${safeRunId} is in status "${source.status}". Only failed runs can be retried.`, {
-        workspacePath: safeWorkspacePath,
-        runId: safeRunId,
-        actor: safeActor,
-        operation: 'dispatch.run.retry',
-      });
-    }
-    const priorAttempt = readOptionalNumber(source.context?.retry_attempt) ?? 0;
-    const retryAttempt = Math.trunc(priorAttempt) + 1;
-    const retried = createRun(safeWorkspacePath, {
-      actor: safeActor,
-      adapter: input.adapter ?? source.adapter,
-      objective: input.objective ?? source.objective,
-      context: {
-        ...(source.context ?? {}),
-        ...(input.contextPatch ?? {}),
-        retry_of_run_id: source.id,
-        retry_attempt: retryAttempt,
-        retry_requested_by: safeActor,
-        retry_requested_at: new Date().toISOString(),
-      },
-    });
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: source.id,
-      actor: safeActor,
-      kind: 'run-retried',
-      data: {
-        retried_run_id: retried.id,
-        retry_attempt: retryAttempt,
-      },
-    }, {
-      runId: source.id,
-      actor: safeActor,
-      operation: 'dispatch.run.retry',
-    });
-    if (input.execute === false) {
-      return retried;
-    }
-    return executeRun(safeWorkspacePath, retried.id, {
-      actor: safeActor,
-      agents: input.agents,
-      maxSteps: input.maxSteps,
-      stepDelayMs: input.stepDelayMs,
-      space: input.space,
-      createCheckpoint: input.createCheckpoint,
-      timeoutMs: input.timeoutMs,
-      dispatchMode: input.dispatchMode,
-      selfAssemblyAgent: input.selfAssemblyAgent,
-      selfAssemblyOptions: input.selfAssemblyOptions,
-    });
-  });
-}
-
-export function recoverDispatchState(workspacePath: string, actor: string): DispatchStateRecoveryResult {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.state.recover');
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    actor,
-    operation: 'dispatch.state.recover',
-  });
-  return withDispatchOperation('dispatch.state.recover', {
-    workspacePath: safeWorkspacePath,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.state.recover', '.workgraph/dispatch-runs', [
-      'dispatch:run',
-      'policy:manage',
-    ]);
-    const nowIso = new Date().toISOString();
-    const warnings: string[] = [];
-    let removedCorruptRuns = 0;
-    const repairedRuns = withRunsMutation(safeWorkspacePath, (state) => {
-      const repaired: DispatchRun[] = [];
-      const healthyRuns: DispatchRun[] = [];
-      for (const rawRun of state.runs) {
-        try {
-          const run = hydrateRun(rawRun);
-          const brokerState = readDispatchBrokerState(safeWorkspacePath, run.id);
-          const brokered = hydrateRunWithDispatchBrokerState(run, brokerState);
-          if (!run.id || !run.id.startsWith('run_')) {
-            removedCorruptRuns += 1;
-            warnings.push('Dropped corrupt run entry with missing/invalid run ID.');
-            continue;
-          }
-          let changed = false;
-          if (run.status === 'running' && !run.leaseExpires && !isBrokeredRun(brokered)) {
-            run.status = 'queued';
-            run.updatedAt = nowIso;
-            run.logs.push({
-              ts: nowIso,
-              level: 'warn',
-              message: 'Recovered run with missing lease by re-queueing it.',
-            });
-            changed = true;
-          }
-          if (run.status === 'running' && run.leaseExpires && !isBrokeredRun(brokered)) {
-            const leaseMs = Date.parse(run.leaseExpires);
-            if (!Number.isFinite(leaseMs) || leaseMs <= Date.now()) {
-              run.status = 'queued';
-              run.updatedAt = nowIso;
-              clearLease(run);
-              run.logs.push({
-                ts: nowIso,
-                level: 'warn',
-                message: 'Recovered run with expired/invalid lease by re-queueing it.',
-              });
-              changed = true;
-            }
-          }
-          if (changed) repaired.push(run);
-          healthyRuns.push(run);
-        } catch {
-          removedCorruptRuns += 1;
-          warnings.push('Dropped an unreadable dispatch run record while repairing state.');
-        }
-      }
-      state.runs = healthyRuns;
-      return repaired;
-    });
-    for (const run of repairedRuns) {
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: run.id,
-        actor: safeActor,
-        kind: 'run-status-changed',
-        data: {
-          to_status: run.status,
-          reason: 'state-recovery',
-        },
-      }, {
-        runId: run.id,
-        actor: safeActor,
-        operation: 'dispatch.state.recover',
-      });
-      appendLedgerEventSafe(safeWorkspacePath, safeActor, 'update', `.workgraph/runs/${run.id}`, 'run', {
-        status: run.status,
-        recovered: true,
-      });
-      ensureRunPrimitiveSafe(safeWorkspacePath, run, safeActor);
-      syncRunPrimitiveSafe(safeWorkspacePath, run, safeActor);
-    }
-    return {
-      repairedAt: nowIso,
-      scannedRuns: loadRuns(safeWorkspacePath).runs.length,
-      repairedRuns,
-      removedCorruptRuns,
-      warnings,
-    };
-  });
-}
-
-function appendRunLogs(
-  workspacePath: string,
-  runId: string,
-  actor: string,
-  logEntries: DispatchAdapterLogEntry[],
-): void {
-  assertDispatchMutationAuthorized(workspacePath, actor, 'dispatch.run.logs', runId, [
-    'dispatch:run',
-  ]);
-  if (logEntries.length === 0) return;
-  const run = withRunsMutation(workspacePath, (state) => {
-    const target = state.runs.find((entry) => entry.id === runId);
-    if (!target) {
-      throw new ResourceNotFoundError(`Run not found: ${runId}`, {
-        workspacePath,
-        runId,
-        actor,
-        operation: 'dispatch.run.logs',
-      });
-    }
-    target.logs.push(...logEntries);
-    target.updatedAt = new Date().toISOString();
-    return target;
-  });
-  appendDispatchRunAuditEventSafe(workspacePath, {
-    runId: run.id,
-    actor,
-    kind: 'run-logs-appended',
-    data: {
-      count: logEntries.length,
-      levels: [...new Set(logEntries.map((entry) => entry.level))],
-    },
-  }, {
-    runId: run.id,
-    actor,
-    operation: 'dispatch.run.logs',
-  });
-  appendLedgerEventSafe(workspacePath, actor, 'update', `.workgraph/runs/${run.id}`, 'run', {
-    log_append_count: logEntries.length,
-  });
-  syncRunPrimitiveSafe(workspacePath, run, actor);
-}
-
-function setStatus(
-  workspacePath: string,
-  runId: string,
-  actor: string,
-  statusValue: RunStatus,
-  logMessage: string,
-): DispatchRun {
-  assertDispatchMutationAuthorized(workspacePath, actor, 'dispatch.run.status', runId, [
-    'dispatch:run',
-  ]);
-  const run = withRunsMutation(workspacePath, (state) => {
-    const target = state.runs.find((entry) => entry.id === runId);
-    if (!target) {
-      throw new ResourceNotFoundError(`Run not found: ${runId}`, {
-        workspacePath,
-        runId,
-        actor,
-        operation: 'dispatch.run.status',
-      });
-    }
-    const previousStatus = target.status;
-    assertRunStatusTransition(target.status, statusValue, runId);
-    const now = new Date().toISOString();
-    target.status = statusValue;
-    if (statusValue === 'running') {
-      applyLease(target, now);
-    } else {
-      clearLease(target);
-    }
-    target.updatedAt = now;
-    target.logs.push({ ts: now, level: 'info', message: logMessage });
-    appendDispatchRunAuditEventSafe(workspacePath, {
-      runId: target.id,
-      actor,
-      kind: 'run-status-changed',
-      data: {
-        from_status: previousStatus,
-        to_status: statusValue,
-        lease_expires: target.leaseExpires,
-      },
-    }, {
-      runId: target.id,
-      actor,
-      operation: 'dispatch.run.status',
-    });
-    appendLedgerEventSafe(workspacePath, actor, 'update', `.workgraph/runs/${target.id}`, 'run', {
-      status: target.status,
-    });
-    return target;
-  });
-  syncRunPrimitiveSafe(workspacePath, run, actor);
-  return hydrateRunWithRuntimeMetadata(workspacePath, run);
-}
-
-function runsPath(workspacePath: string): string {
-  return path.join(workspacePath, RUNS_FILE);
-}
-
-function loadRuns(workspacePath: string): { version: number; runs: DispatchRun[] } {
-  const rPath = runsPath(workspacePath);
-  if (!fs.existsSync(rPath)) {
-    const seeded = { version: 1, runs: [] as DispatchRun[] };
-    saveRuns(workspacePath, seeded);
-    return seeded;
-  }
-  try {
-    const raw = fs.readFileSync(rPath, 'utf-8');
-    const parsed = JSON.parse(raw) as { version?: number; runs?: DispatchRun[] };
-    return {
-      version: parsed.version ?? 1,
-      runs: Array.isArray(parsed.runs) ? parsed.runs.map(hydrateRun) : [],
-    };
-  } catch (error) {
-    logDispatchWarning('Dispatch runs state is unreadable; seeding an empty run state.', error, {
-      target: rPath,
-    });
-    const seeded = { version: 1, runs: [] as DispatchRun[] };
-    saveRuns(workspacePath, seeded);
-    return seeded;
-  }
-}
-
-function saveRuns(workspacePath: string, value: { version: number; runs: DispatchRun[] }): void {
-  const rPath = runsPath(workspacePath);
-  const dir = path.dirname(rPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  atomicWriteFile(rPath, JSON.stringify(value, null, 2) + '\n');
-}
-
-function getRun(workspacePath: string, runId: string): DispatchRun | null {
-  const state = loadRuns(workspacePath);
-  return state.runs.find((run) => run.id === runId) ?? null;
-}
-
-function ensureRunPrimitive(workspacePath: string, run: DispatchRun, actor: string): void {
-  const hydrated = hydrateRunWithRuntimeMetadata(workspacePath, run);
-  const safeTitle = `${hydrated.objective} (${hydrated.id.slice(0, 8)})`;
-  const runPrimitivePath = `runs/${run.id}.md`;
-  const existing = store.read(workspacePath, runPrimitivePath);
-  if (existing) return;
-  store.create(
-    workspacePath,
-    'run',
-    {
-      title: safeTitle,
-      objective: hydrated.objective,
-      runtime: hydrated.adapter,
-      status: hydrated.status,
-      run_id: hydrated.id,
-      owner: hydrated.actor,
-      lease_expires: hydrated.leaseExpires,
-      lease_duration_minutes: hydrated.leaseDurationMinutes,
-      last_heartbeat: latestHeartbeat(hydrated),
-      heartbeat_timestamps: hydrated.heartbeats ?? [],
-      ...(hydrated.external ? { external: sanitizeFrontmatterValue(hydrated.external) } : {}),
-      ...(hydrated.dispatchTracking ? { dispatch_tracking: sanitizeFrontmatterValue(hydrated.dispatchTracking) } : {}),
-      tags: ['dispatch'],
-    },
-    renderRunBody(hydrated),
-    actor,
-    { pathOverride: runPrimitivePath },
-  );
-}
-
-function syncRunPrimitive(workspacePath: string, run: DispatchRun, actor: string): void {
-  const runs = store.list(workspacePath, 'run');
-  const existing = runs.find((entry) => String(entry.fields.run_id) === run.id);
-  if (!existing) return;
-  const hydrated = hydrateRunWithRuntimeMetadata(workspacePath, run);
-  store.update(
-    workspacePath,
-    existing.path,
-    {
-      status: hydrated.status,
-      runtime: hydrated.adapter,
-      objective: hydrated.objective,
-      owner: hydrated.actor,
-      lease_expires: hydrated.leaseExpires,
-      lease_duration_minutes: hydrated.leaseDurationMinutes,
-      last_heartbeat: latestHeartbeat(hydrated),
-      heartbeat_timestamps: hydrated.heartbeats ?? [],
-      ...(hydrated.external ? { external: sanitizeFrontmatterValue(hydrated.external) } : {}),
-      ...(hydrated.dispatchTracking ? { dispatch_tracking: sanitizeFrontmatterValue(hydrated.dispatchTracking) } : {}),
-    },
-    renderRunBody(hydrated),
-    actor,
-  );
-}
-
-function renderRunBody(run: DispatchRun): string {
-  const lines = [
-    '## Objective',
-    '',
-    run.objective,
-    '',
-    '## Status',
-    '',
-    run.status,
-    '',
-    '## Lease',
-    '',
-    run.leaseExpires
-      ? `expires: ${run.leaseExpires} (${run.leaseDurationMinutes ?? DEFAULT_LEASE_MINUTES} min lease)`
-      : 'none',
-    '',
-    '## External correlation',
-    '',
-    ...(run.external
-      ? [
-          `provider: ${run.external.provider}`,
-          `external_run_id: ${run.external.externalRunId}`,
-          `last_known_status: ${run.external.lastKnownStatus ?? 'unknown'}`,
-          `last_known_at: ${run.external.lastKnownAt ?? 'unknown'}`,
-          ...(run.external.externalAgentId ? [`external_agent_id: ${run.external.externalAgentId}`] : []),
-          ...(run.external.externalThreadId ? [`external_thread_id: ${run.external.externalThreadId}`] : []),
-          ...((run.external.correlationKeys ?? []).length > 0
-            ? [`correlation_keys: ${(run.external.correlationKeys ?? []).join(', ')}`]
-            : []),
-        ]
-      : ['none']),
-    '',
-    '## Dispatch tracking',
-    '',
-    `dispatched_at: ${run.dispatchTracking?.dispatchedAt ?? 'n/a'}`,
-    `last_sent_at: ${run.dispatchTracking?.lastSentAt ?? 'n/a'}`,
-    `acknowledged: ${run.dispatchTracking?.acknowledged === true ? 'yes' : 'no'}`,
-    `acknowledged_at: ${run.dispatchTracking?.acknowledgedAt ?? 'n/a'}`,
-    `retry_count: ${run.dispatchTracking?.retryCount ?? 0}`,
-    `last_reconciled_at: ${run.dispatchTracking?.lastReconciledAt ?? 'n/a'}`,
-    `reconciliation_error: ${run.dispatchTracking?.reconciliationError ?? 'n/a'}`,
-    `cancellation_requested_at: ${run.dispatchTracking?.cancellationRequestedAt ?? 'n/a'}`,
-    `cancellation_acknowledged_at: ${run.dispatchTracking?.cancellationAcknowledgedAt ?? 'n/a'}`,
-    '',
-    '## Logs',
-    '',
-    ...run.logs.slice(-20).map((entry) => `- ${entry.ts} [${entry.level}] ${entry.message}`),
-    '',
-  ];
-  if ((run.heartbeats ?? []).length > 0) {
-    lines.push('## Heartbeats');
-    lines.push('');
-    lines.push(...(run.heartbeats ?? []).slice(-20).map((ts) => `- ${ts}`));
-    lines.push('');
-  }
-  if (run.output) {
-    lines.push('## Output');
-    lines.push('');
-    lines.push(run.output);
-    lines.push('');
-  }
-  if (run.error) {
-    lines.push('## Error');
-    lines.push('');
-    lines.push(run.error);
-    lines.push('');
-  }
-  if (run.audit?.eventCount || run.evidenceChain?.count) {
-    lines.push('## Evidence & Audit');
-    lines.push('');
-    lines.push(`audit_events: ${run.audit?.eventCount ?? 0}`);
-    lines.push(`audit_head_hash: ${run.audit?.headHash ?? 'none'}`);
-    lines.push(`evidence_items: ${run.evidenceChain?.count ?? 0}`);
-    if (run.evidenceChain?.lastCollectedAt) {
-      lines.push(`evidence_last_collected_at: ${run.evidenceChain.lastCollectedAt}`);
-    }
-    if (run.evidenceChain?.byType && Object.keys(run.evidenceChain.byType).length > 0) {
-      lines.push('evidence_by_type:');
-      for (const [type, count] of Object.entries(run.evidenceChain.byType)) {
-        lines.push(`  - ${type}: ${count}`);
-      }
-    }
-    lines.push('');
-  }
-  if (run.context && Object.keys(run.context).length > 0) {
-    lines.push('## Context');
-    lines.push('');
-    lines.push('```json');
-    lines.push(JSON.stringify(run.context, null, 2));
-    lines.push('```');
-    lines.push('');
-  }
-  return lines.join('\n');
-}
-
-function hydrateRun(run: DispatchRun): DispatchRun {
-  return {
-    ...run,
-    leaseDurationMinutes: normalizeLeaseMinutes(run.leaseDurationMinutes),
-    heartbeats: Array.isArray(run.heartbeats) ? run.heartbeats : [],
-    external: normalizeExternalIdentity(run.external),
-    dispatchTracking: normalizeDispatchTracking(run.dispatchTracking),
-  };
-}
-
-function hydrateRunWithRuntimeMetadata(workspacePath: string, run: DispatchRun): DispatchRun {
-  const brokerState = readDispatchBrokerState(workspacePath, run.id);
-  const base = hydrateRunWithDispatchBrokerState(hydrateRun(run), brokerState);
-  const trail = listDispatchRunAuditEvents(workspacePath, run.id);
-  const evidenceCount = trail
-    .filter((entry) => entry.kind === 'run-evidence-collected')
-    .reduce((total, entry) => {
-      const items = Array.isArray(entry.data.items) ? entry.data.items : [];
-      return total + items.length;
-    }, 0);
-  const byType: Record<string, number> = {};
-  for (const item of listRunEvidenceFromTrail(trail)) {
-    byType[item.type] = (byType[item.type] ?? 0) + 1;
-  }
-  return {
-    ...base,
-    audit: {
-      eventCount: trail.length,
-      headHash: trail[trail.length - 1]?.hash,
-    },
-    evidenceChain: {
-      count: evidenceCount,
-      byType,
-      lastCollectedAt: trail.filter((entry) => entry.kind === 'run-evidence-collected').at(-1)?.ts,
-    },
-  };
-}
-
-function listRunEvidenceFromTrail(trail: DispatchRunAuditEvent[]): DispatchRunEvidenceItem[] {
-  const items: DispatchRunEvidenceItem[] = [];
-  for (const entry of trail) {
-    if (entry.kind !== 'run-evidence-collected') continue;
-    const rawItems = Array.isArray(entry.data.items) ? entry.data.items : [];
-    for (const item of rawItems) {
-      if (!item || typeof item !== 'object') continue;
-      items.push(item as DispatchRunEvidenceItem);
-    }
-  }
-  return items;
-}
-
-async function attemptExternalBrokerDispatch(
-  workspacePath: string,
-  run: DispatchRun,
-  actor: string,
-  adapter: ReturnType<typeof resolveDispatchAdapter>,
-): Promise<DispatchRun> {
-  if (!adapter.dispatch) {
-    throw new ConflictError(`Dispatch adapter "${run.adapter}" does not implement dispatch().`, {
-      workspacePath,
-      runId: run.id,
-      actor,
-      operation: 'dispatch.run.external-dispatch',
-    });
-  }
-  const now = new Date().toISOString();
-  const dispatchInput: DispatchAdapterDispatchInput = {
-    workspacePath,
-    runId: run.id,
-    actor,
-    objective: run.objective,
-    context: run.context,
-    followups: run.followups,
-    external: normalizeDispatchAdapterExternalIdentity(run.external),
-  };
-  const payloadDigest = hashExternalDispatchPayload(dispatchInput);
-  const trackingBefore = normalizeDispatchTracking(run.dispatchTracking);
-  const tracking: DispatchRunDispatchTracking = {
-    ...trackingBefore,
-    dispatchedAt: trackingBefore.dispatchedAt ?? now,
-    lastSentAt: now,
-    outboundPayloadDigest: payloadDigest,
-    retryCount: trackingBefore.retryCount + 1,
-    reconciliationError: undefined,
-  };
-  persistBrokerState(workspacePath, run.id, {
-    external: run.external,
-    tracking,
-  });
-  appendDispatchRunAuditEventSafe(workspacePath, {
-    runId: run.id,
-    actor,
-    kind: 'run-dispatch-attempted',
-    data: {
-      adapter: run.adapter,
-      payload_digest: payloadDigest,
-      retry_count: tracking.retryCount,
-      dispatched_at: tracking.dispatchedAt,
-      last_sent_at: tracking.lastSentAt,
-    },
-  }, {
-    runId: run.id,
-    actor,
-    operation: 'dispatch.run.external-dispatch',
-  });
-
-  let dispatched: DispatchAdapterExternalUpdate;
-  try {
-    dispatched = await adapter.dispatch(dispatchInput);
-  } catch (error) {
-    persistBrokerState(workspacePath, run.id, {
-      tracking: {
-        ...tracking,
-        reconciliationError: errorMessage(error),
-      },
-    });
-    appendDispatchRunAuditEventSafe(workspacePath, {
-      runId: run.id,
-      actor,
-      kind: 'run-dispatch-failed',
-      data: {
-        adapter: run.adapter,
-        error: errorMessage(error),
-      },
-    }, {
-      runId: run.id,
-      actor,
-      operation: 'dispatch.run.external-dispatch',
-    });
-    throw error;
-  }
-
-  const external = mergeExternalIdentity(run.external, normalizeExternalFromUpdate(run.adapter, dispatched));
-  if (!external) {
-    throw new ConflictError(`Dispatch adapter "${run.adapter}" did not return an external run identifier.`, {
-      workspacePath,
-      runId: run.id,
-      actor,
-      operation: 'dispatch.run.external-dispatch',
-    });
-  }
-  const mergedTracking = mergeDispatchTracking(tracking, {
-    acknowledged: dispatched.acknowledged,
-    acknowledgedAt: dispatched.acknowledgedAt ?? (dispatched.acknowledged === true ? now : undefined),
-    lastReconciledAt: dispatched.status ? (dispatched.lastKnownAt ?? now) : undefined,
-  });
-  persistBrokerState(workspacePath, run.id, {
-    external: mergeExternalIdentity(external, {
-      provider: external.provider,
-      externalRunId: external.externalRunId,
-      lastKnownStatus: dispatched.status,
-      lastKnownAt: dispatched.lastKnownAt ?? now,
-      correlationKeys: external?.correlationKeys,
-      metadata: {
-        ...(external?.metadata ?? {}),
-        ...(dispatched.metadata ?? {}),
-      },
-    }),
-    tracking: mergedTracking,
-  });
-  if ((dispatched.logs ?? []).length > 0) {
-    appendRunLogs(workspacePath, run.id, actor, dispatched.logs ?? []);
-  }
-  recordExternalCorrelationEvidence(workspacePath, run.id, actor, external, mergedTracking, dispatched.metadata);
-  appendDispatchRunAuditEventSafe(workspacePath, {
-    runId: run.id,
-    actor,
-    kind: 'run-dispatch-acknowledged',
-    data: {
-      adapter: run.adapter,
-      acknowledged: dispatched.acknowledged === true,
-      acknowledged_at: mergedTracking.acknowledgedAt,
-      external: external ? serializeExternalIdentityForAudit(external) : undefined,
-      status: dispatched.status,
-    },
-  }, {
-    runId: run.id,
-    actor,
-    operation: 'dispatch.run.external-dispatch',
-  });
-  if (dispatched.status || dispatched.output || dispatched.error || dispatched.acknowledged || external) {
-    reconcileExternalRun(workspacePath, {
-      actor,
-      runId: run.id,
-      source: 'dispatch',
-      status: dispatched.status,
-      output: dispatched.output,
-      error: dispatched.error,
-      acknowledged: dispatched.acknowledged,
-      acknowledgedAt: dispatched.acknowledgedAt,
-      external: external
-        ? {
-            ...external,
-            ...(dispatched.status ? { lastKnownStatus: dispatched.status } : {}),
-            lastKnownAt: dispatched.lastKnownAt ?? now,
-          }
-        : undefined,
-      metadata: dispatched.metadata,
-      logs: [],
-      ts: dispatched.lastKnownAt ?? now,
-    });
-  }
-  return status(workspacePath, run.id);
-}
-
-function requestBrokeredRunCancellation(
-  workspacePath: string,
-  run: DispatchRun,
-  actor: string,
-): DispatchRun {
-  const adapter = resolveDispatchAdapter(run.adapter);
-  const now = new Date().toISOString();
-  const tracking = mergeDispatchTracking(run.dispatchTracking, {
-    cancellationRequestedAt: now,
-    reconciliationError: undefined,
-  });
-  persistBrokerState(workspacePath, run.id, {
-    external: run.external,
-    tracking,
-  });
-  appendDispatchRunAuditEventSafe(workspacePath, {
-    runId: run.id,
-    actor,
-    kind: 'run-cancel-requested',
-    data: {
-      adapter: run.adapter,
-      external: run.external ? serializeExternalIdentityForAudit(run.external) : undefined,
-      cancellation_requested_at: now,
-    },
-  }, {
-    runId: run.id,
-    actor,
-    operation: 'dispatch.run.stop',
-  });
-
-  const cancelInput: DispatchAdapterCancelInput = {
-    workspacePath,
-    runId: run.id,
-    actor,
-    objective: run.objective,
-    context: run.context,
-    external: normalizeDispatchAdapterExternalIdentity(run.external),
-  };
-  const cancelPromise: Promise<DispatchAdapterExternalUpdate> = adapter.cancel
-    ? adapter.cancel(cancelInput)
-    : adapter.stop(run.id, actor).then((value) => ({ status: value.status } as DispatchAdapterExternalUpdate));
-  void cancelPromise
-    .then((result) => {
-      if ((result.logs ?? []).length > 0) {
-        appendRunLogs(workspacePath, run.id, actor, result.logs ?? []);
-      }
-      reconcileExternalRun(workspacePath, {
-        actor,
-        runId: run.id,
-        source: 'cancel',
-        status: result.status,
-        output: result.output,
-        error: result.error,
-        acknowledged: result.acknowledged,
-        acknowledgedAt: result.acknowledgedAt,
-        external: mergeExternalIdentity(run.external, normalizeExternalFromUpdate(run.adapter, result)),
-        metadata: result.metadata,
-        ts: result.lastKnownAt ?? new Date().toISOString(),
-      });
-    })
-    .catch((error) => {
-      persistBrokerState(workspacePath, run.id, {
-        external: run.external,
-        tracking: mergeDispatchTracking(tracking, {
-          lastReconciledAt: new Date().toISOString(),
-          reconciliationError: errorMessage(error),
-        }),
-      });
-      appendDispatchRunAuditEventSafe(workspacePath, {
-        runId: run.id,
-        actor,
-        kind: 'run-dispatch-failed',
-        data: {
-          adapter: run.adapter,
-          stage: 'cancel',
-          error: errorMessage(error),
-        },
-      }, {
-        runId: run.id,
-        actor,
-        operation: 'dispatch.run.stop',
-      });
-    });
-  return status(workspacePath, run.id);
-}
-
-export function reconcileExternalRun(
-  workspacePath: string,
-  input: DispatchExternalReconcileInput,
-): DispatchExternalReconcileResult {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.external-reconcile');
-  const safeActor = validateActorName(input.actor, {
-    workspacePath: safeWorkspacePath,
-    runId: input.runId,
-    actor: input.actor,
-    operation: 'dispatch.run.external-reconcile',
-  });
-  return withDispatchOperation('dispatch.run.external-reconcile', {
-    workspacePath: safeWorkspacePath,
-    runId: input.runId,
-    actor: safeActor,
-  }, () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.external-reconcile', input.runId ?? '.workgraph/dispatch-broker', [
-      'dispatch:run',
-    ]);
-    const normalizedInput = normalizeExternalReconcileInput(input);
-    const brokerState = findDispatchBrokerState(safeWorkspacePath, {
-      runId: normalizedInput.runId,
-      provider: normalizedInput.provider,
-      externalRunId: normalizedInput.externalRunId,
-      correlationKeys: normalizedInput.correlationKeys,
-    });
-    if (!brokerState) {
-      throw new ResourceNotFoundError('External run correlation not found.', {
-        workspacePath: safeWorkspacePath,
-        actor: safeActor,
-        operation: 'dispatch.run.external-reconcile',
-      });
-    }
-    const current = getRun(safeWorkspacePath, brokerState.runId);
-    if (!current) {
-      throw new ResourceNotFoundError(`Run not found: ${brokerState.runId}`, {
-        workspacePath: safeWorkspacePath,
-        runId: brokerState.runId,
-        actor: safeActor,
-        operation: 'dispatch.run.external-reconcile',
-      });
-    }
-    if ((normalizedInput.logs ?? []).length > 0) {
-      appendRunLogs(safeWorkspacePath, brokerState.runId, safeActor, normalizedInput.logs ?? []);
-    }
-    const nowIso = normalizedInput.ts ?? new Date().toISOString();
-    const nextExternal = mergeExternalIdentity(
-      mergeExternalIdentity(current.external, brokerState.external),
-      normalizedInput.external ?? (
-        normalizedInput.provider && normalizedInput.externalRunId
-          ? {
-              provider: normalizedInput.provider,
-              externalRunId: normalizedInput.externalRunId,
-              correlationKeys: normalizedInput.correlationKeys,
-              lastKnownStatus: normalizedInput.status,
-              lastKnownAt: nowIso,
-            }
-          : undefined
-      ),
-    );
-    const nextTracking = mergeDispatchTracking(
-      mergeDispatchTracking(current.dispatchTracking, brokerState.tracking),
-      {
-        acknowledged: normalizedInput.acknowledged,
-        acknowledgedAt: normalizedInput.acknowledgedAt,
-        lastReconciledAt: nowIso,
-        reconciliationError: undefined,
-        ...(normalizedInput.source === 'cancel' && normalizedInput.status === 'cancelled'
-          ? { cancellationAcknowledgedAt: nowIso }
-          : {}),
-      },
-    );
-    persistBrokerState(safeWorkspacePath, brokerState.runId, {
-      external: nextExternal,
-      tracking: nextTracking,
-    });
-    recordExternalCorrelationEvidence(
-      safeWorkspacePath,
-      brokerState.runId,
-      safeActor,
-      nextExternal,
-      nextTracking,
-      normalizedInput.metadata,
-    );
-
-    const previousStatus = current.status;
-    let nextStatus = current.status;
-    if (normalizedInput.status && canApplyExternalRunStatus(current.status, normalizedInput.status)) {
-      nextStatus = normalizedInput.status;
-    }
-    const statusChanged = withRunsMutation(safeWorkspacePath, (state) => {
-      const target = state.runs.find((candidate) => candidate.id === brokerState.runId);
-      if (!target) return false;
-      target.external = nextExternal;
-      target.dispatchTracking = nextTracking;
-      if (normalizedInput.output) target.output = normalizedInput.output;
-      if (normalizedInput.error) target.error = normalizedInput.error;
-      target.updatedAt = nowIso;
-      if (target.status !== nextStatus) {
-        target.status = nextStatus;
-        clearLease(target);
-        target.logs.push({
-          ts: nowIso,
-          level: 'info',
-          message: `External reconciliation (${normalizedInput.source}) set status to ${nextStatus}.`,
-        });
-        return true;
-      }
-      return false;
-    });
-    appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-      runId: brokerState.runId,
-      actor: safeActor,
-      kind: 'run-external-reconciled',
-      data: {
-        source: normalizedInput.source,
-        previous_status: previousStatus,
-        current_status: nextStatus,
-        acknowledged: nextTracking.acknowledged === true,
-        external: nextExternal ? serializeExternalIdentityForAudit(nextExternal) : undefined,
-      },
-    }, {
-      runId: brokerState.runId,
-      actor: safeActor,
-      operation: 'dispatch.run.external-reconcile',
-    });
-    if (normalizedInput.source === 'cancel' && nextStatus === 'cancelled') {
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: brokerState.runId,
-        actor: safeActor,
-        kind: 'run-cancel-acknowledged',
-        data: {
-          cancelled_at: nowIso,
-          external: nextExternal ? serializeExternalIdentityForAudit(nextExternal) : undefined,
-        },
-      }, {
-        runId: brokerState.runId,
-        actor: safeActor,
-        operation: 'dispatch.run.external-reconcile',
-      });
-    }
-    if (statusChanged) {
-      appendDispatchRunAuditEventSafe(safeWorkspacePath, {
-        runId: brokerState.runId,
-        actor: safeActor,
-        kind: 'run-status-changed',
-        data: {
-          from_status: previousStatus,
-          to_status: nextStatus,
-          reason: `external-reconcile:${normalizedInput.source}`,
-        },
-      }, {
-        runId: brokerState.runId,
-        actor: safeActor,
-        operation: 'dispatch.run.external-reconcile',
-      });
-      appendLedgerEventSafe(safeWorkspacePath, safeActor, 'update', `.workgraph/runs/${brokerState.runId}`, 'run', {
-        status: nextStatus,
-        external_reconcile: normalizedInput.source,
-      });
-    }
-    const reconciled = status(safeWorkspacePath, brokerState.runId);
-    syncRunPrimitiveSafe(safeWorkspacePath, reconciled, safeActor);
-    return {
-      reconciledAt: nowIso,
-      matchedRunId: brokerState.runId,
-      statusChanged,
-      previousStatus,
-      currentStatus: reconciled.status,
-      run: reconciled,
-    };
-  });
-}
-
-export async function pollExternalRuns(
-  workspacePath: string,
-  actor: string,
-  options: { runId?: string } = {},
-): Promise<DispatchPollExternalRunsResult> {
-  const safeWorkspacePath = validatedWorkspacePath(workspacePath, 'dispatch.run.external-poll');
-  const safeActor = validateActorName(actor, {
-    workspacePath: safeWorkspacePath,
-    runId: options.runId,
-    actor,
-    operation: 'dispatch.run.external-poll',
-  });
-  return withDispatchOperationAsync('dispatch.run.external-poll', {
-    workspacePath: safeWorkspacePath,
-    runId: options.runId,
-    actor: safeActor,
-  }, async () => {
-    assertDispatchMutationAuthorized(safeWorkspacePath, safeActor, 'dispatch.run.external-poll', options.runId ?? '.workgraph/dispatch-broker', [
-      'dispatch:run',
-    ]);
-    const candidateRuns = (options.runId
-      ? [status(safeWorkspacePath, options.runId)]
-      : listRuns(safeWorkspacePath)).filter((run) => !isTerminalRunStatus(run.status));
-    const brokered = candidateRuns.filter((run) => wantsExternalBroker(run));
-    const reconciledRuns: DispatchRun[] = [];
-    const failures: DispatchPollExternalRunsResult['failures'] = [];
-    for (const run of brokered) {
-      const adapter = resolveDispatchAdapter(run.adapter);
-      if (!adapter.poll || !run.external) continue;
-      try {
-        const polled = await adapter.poll({
-          workspacePath: safeWorkspacePath,
-          runId: run.id,
-          actor: safeActor,
-          objective: run.objective,
-          context: run.context,
-          external: normalizeDispatchAdapterExternalIdentity(run.external)!,
-        });
-        if (!polled) continue;
-        const reconciled = reconcileExternalRun(safeWorkspacePath, {
-          actor: safeActor,
-          runId: run.id,
-          source: 'poll',
-          status: polled.status,
-          output: polled.output,
-          error: polled.error,
-          acknowledged: polled.acknowledged,
-          acknowledgedAt: polled.acknowledgedAt,
-          external: mergeExternalIdentity(run.external, normalizeExternalFromUpdate(run.adapter, polled)),
-          metadata: polled.metadata,
-          logs: polled.logs,
-          ts: polled.lastKnownAt,
-        }).run;
-        if (reconciled) reconciledRuns.push(reconciled);
-      } catch (error) {
-        failures.push({
-          runId: run.id,
-          error: errorMessage(error),
-        });
-        persistBrokerState(safeWorkspacePath, run.id, {
-          external: run.external,
-          tracking: mergeDispatchTracking(run.dispatchTracking, {
-            lastReconciledAt: new Date().toISOString(),
-            reconciliationError: errorMessage(error),
-          }),
-        });
-      }
-    }
-    return {
-      reconciledAt: new Date().toISOString(),
-      inspectedRuns: brokered.length,
-      reconciledRuns,
-      failures,
-    };
-  });
-}
-
-function persistBrokerState(
-  workspacePath: string,
-  runId: string,
-  updates: {
-    external?: DispatchRunExternalIdentity;
-    tracking?: DispatchRunDispatchTracking;
-  },
-): void {
-  updateDispatchBrokerState(workspacePath, runId, (current) => ({
-    runId,
-    external: mergeExternalIdentity(current?.external, updates.external),
-    tracking: mergeDispatchTracking(current?.tracking, updates.tracking),
-    updatedAt: new Date().toISOString(),
-  }));
-}
-
-function recordExternalCorrelationEvidence(
-  workspacePath: string,
-  runId: string,
-  actor: string,
-  external: DispatchRunExternalIdentity | undefined,
-  tracking: DispatchRunDispatchTracking | undefined,
-  metadata?: Record<string, unknown>,
-): void {
-  try {
-    const evidence = collectDispatchExternalCorrelationEvidence({
-      runId,
-      external,
-      tracking,
-      metadata,
-    });
-    if (evidence.items.length === 0) return;
-    appendDispatchRunAuditEventSafe(workspacePath, {
-      runId,
-      actor,
-      kind: 'run-evidence-collected',
-      data: {
-        items: evidence.items,
-        summary: evidence.summary,
-      },
-    }, {
-      runId,
-      actor,
-      operation: 'dispatch.run.external-evidence',
-    });
-  } catch (error) {
-    logDispatchWarning('Failed to record external correlation evidence.', error, {
-      runId,
-      actor,
-    });
-  }
-}
-
-function failBrokeredRun(
-  workspacePath: string,
-  runId: string,
-  actor: string,
-  error: string,
-): DispatchRun {
-  const current = status(workspacePath, runId);
-  if (current.status !== 'queued') {
-    return markRun(workspacePath, runId, actor, 'failed', {
-      error,
-      contextPatch: {
-        external_broker_mode: true,
-      },
-    });
-  }
-  const now = new Date().toISOString();
-  const failed = withRunsMutation(workspacePath, (state) => {
-    const target = state.runs.find((entry) => entry.id === runId);
-    if (!target) {
-      throw new ResourceNotFoundError(`Run not found: ${runId}`, {
-        workspacePath,
-        runId,
-        actor,
-        operation: 'dispatch.run.external-fail',
-      });
-    }
-    target.status = 'failed';
-    target.error = error;
-    target.updatedAt = now;
-    clearLease(target);
-    target.logs.push({
-      ts: now,
-      level: 'error',
-      message: `External broker dispatch failed: ${error}`,
-    });
-    return target;
-  });
-  appendDispatchRunAuditEventSafe(workspacePath, {
-    runId,
-    actor,
-    kind: 'run-status-changed',
-    data: {
-      from_status: 'queued',
-      to_status: 'failed',
-      reason: 'external-dispatch-failed',
-    },
-  }, {
-    runId,
-    actor,
-    operation: 'dispatch.run.external-fail',
-  });
-  appendLedgerEventSafe(workspacePath, actor, 'update', `.workgraph/runs/${runId}`, 'run', {
-    status: 'failed',
-    external_dispatch_failed: true,
-  });
-  syncRunPrimitiveSafe(workspacePath, failed, actor);
-  return status(workspacePath, runId);
-}
-
-function normalizeExternalReconcileInput(input: DispatchExternalReconcileInput): DispatchExternalReconcileInput {
-  return {
-    ...input,
-    runId: readOptionalString(input.runId),
-    provider: readOptionalString(input.provider),
-    externalRunId: readOptionalString(input.externalRunId),
-    correlationKeys: (input.correlationKeys ?? []).map((entry) => String(entry).trim()).filter(Boolean),
-    status: normalizeRunStatusValue(input.status),
-    acknowledged: input.acknowledged === true ? true : undefined,
-    acknowledgedAt: readOptionalString(input.acknowledgedAt),
-    external: normalizeExternalIdentity(input.external),
-    metadata: isRecord(input.metadata) ? input.metadata : undefined,
-    source: input.source ?? 'event',
-    ts: readOptionalString(input.ts),
-    logs: Array.isArray(input.logs) ? input.logs : [],
-  };
-}
-
-function normalizeRunStatusValue(value: unknown): RunStatus | undefined {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (
-    normalized === 'queued'
-    || normalized === 'running'
-    || normalized === 'succeeded'
-    || normalized === 'failed'
-    || normalized === 'cancelled'
-  ) {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizeExternalFromUpdate(
-  fallbackProvider: string,
-  update: DispatchAdapterExternalUpdate,
-): DispatchRunExternalIdentity | undefined {
-  const external = normalizeDispatchAdapterExternalIdentity(update.external);
-  if (!external) return undefined;
-  return {
-    provider: external.provider || fallbackProvider,
-    externalRunId: external.externalRunId,
-    externalAgentId: external.externalAgentId,
-    externalThreadId: external.externalThreadId,
-    correlationKeys: external.correlationKeys,
-    metadata: external.metadata,
-    lastKnownStatus: update.status,
-    lastKnownAt: update.lastKnownAt,
-  };
-}
-
-function normalizeDispatchAdapterExternalIdentity(
-  external: DispatchRunExternalIdentity | DispatchAdapterExternalIdentity | undefined,
-): DispatchAdapterExternalIdentity | undefined {
-  const normalized = normalizeExternalIdentity(external as DispatchRunExternalIdentity | undefined);
-  if (!normalized) return undefined;
-  return {
-    provider: normalized.provider,
-    externalRunId: normalized.externalRunId,
-    externalAgentId: normalized.externalAgentId,
-    externalThreadId: normalized.externalThreadId,
-    correlationKeys: normalized.correlationKeys,
-    metadata: normalized.metadata,
-  };
-}
-
-function serializeExternalIdentityForAudit(external: DispatchRunExternalIdentity): Record<string, unknown> {
-  return {
-    provider: external.provider,
-    external_run_id: external.externalRunId,
-    external_agent_id: external.externalAgentId,
-    external_thread_id: external.externalThreadId,
-    correlation_keys: external.correlationKeys ?? [],
-    last_known_status: external.lastKnownStatus,
-    last_known_at: external.lastKnownAt,
-  };
-}
-
-function hashExternalDispatchPayload(input: DispatchAdapterDispatchInput): string {
-  return createStableHash({
-    workspacePath: input.workspacePath,
-    runId: input.runId,
-    actor: input.actor,
-    objective: input.objective,
-    context: input.context ?? {},
-    followups: input.followups ?? [],
-    external: input.external ?? null,
-  });
-}
-
-function canApplyExternalRunStatus(from: RunStatus, to: RunStatus): boolean {
-  if (from === to) return true;
-  if (isTerminalRunStatus(from)) return false;
-  if (from === 'queued') {
-    return to === 'running' || to === 'succeeded' || to === 'failed' || to === 'cancelled';
-  }
-  if (from === 'running') {
-    return to === 'succeeded' || to === 'failed' || to === 'cancelled';
-  }
-  return false;
-}
-
-function isTerminalRunStatus(status: RunStatus): boolean {
-  return status === 'succeeded' || status === 'failed' || status === 'cancelled';
-}
-
-function wantsExternalBroker(run: DispatchRun): boolean {
-  if (isBrokeredRun(run)) return true;
-  if (run.context?.external_broker_mode === true) return true;
-  if (run.adapter === 'cursor-cloud') {
-    return hasCursorExternalBrokerConfig(run.context);
-  }
-  return false;
-}
-
-function hasCursorExternalBrokerConfig(context: Record<string, unknown> | undefined): boolean {
-  return Boolean(
-    readOptionalString(context?.cursor_cloud_api_base_url)
-    || readOptionalString(context?.cursor_cloud_dispatch_url)
-    || readOptionalString(context?.cursor_cloud_status_url_template)
-    || readOptionalString(context?.cursor_cloud_cancel_url_template),
-  );
-}
-
-function createStableHash(value: unknown): string {
-  return createHash('sha256').update(stableStringify(value)).digest('hex');
-}
-
-function stableStringify(value: unknown): string {
-  if (value === null || typeof value !== 'object') {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
-  }
-  const record = value as Record<string, unknown>;
-  const keys = Object.keys(record).sort((left, right) => left.localeCompare(right));
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(',')}}`;
-}
-
-function sanitizeFrontmatterValue<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => sanitizeFrontmatterValue(entry))
-      .filter((entry) => entry !== undefined) as T;
-  }
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-  const cleaned: Record<string, unknown> = {};
-  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-    if (entry === undefined) continue;
-    cleaned[key] = sanitizeFrontmatterValue(entry);
-  }
-  return cleaned as T;
-}
-
-async function attemptSelfAssembly(
-  workspacePath: string,
-  run: DispatchRun,
-  input: DispatchExecuteInput,
-): Promise<{
-  ok: boolean;
-  logs: DispatchAdapterLogEntry[];
-  error?: string;
-}> {
-  const now = new Date().toISOString();
-  const agentName = input.selfAssemblyAgent
-    ?? readOptionalString(run.context?.self_assembly_agent)
-    ?? readOptionalString(input.selfAssemblyOptions?.agentName)
-    ?? input.actor;
-  const rawOptions = isRecord(run.context?.self_assembly_options)
-    ? run.context?.self_assembly_options
-    : undefined;
-  const mergedOptions = {
-    ...normalizeSelfAssemblyOptions(rawOptions),
-    ...normalizeSelfAssemblyOptions(input.selfAssemblyOptions),
-  };
-  try {
-    const module = await import('./agent-self-assembly.js');
-    const result = module.assembleAgent(workspacePath, agentName, {
-      ...mergedOptions,
-    });
-    return {
-      ok: true,
-      logs: [
-        {
-          ts: now,
-          level: 'info',
-          message: `Self-assembly dispatched agent "${result.agentName}" before run execution.`,
-        },
-        ...(result.claimedThread
-          ? [{
-              ts: now,
-              level: 'info' as const,
-              message: `Self-assembly claimed ${result.claimedThread.path}.`,
-            }]
-          : []),
-        ...(result.warnings.length > 0
-          ? result.warnings.map((warning) => ({
-              ts: now,
-              level: 'warn' as const,
-              message: `Self-assembly warning: ${warning}`,
-            }))
-          : []),
-      ],
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      logs: [{
-        ts: now,
-        level: 'error',
-        message: `Self-assembly failed: ${errorMessage(error)}`,
-      }],
-      error: `Self-assembly failed: ${errorMessage(error)}`,
-    };
-  }
-}
-
-function normalizeSelfAssemblyOptions(
-  value: Record<string, unknown> | undefined,
-): SelfAssemblyDispatchOptions {
-  if (!value) return {};
-  const normalized: SelfAssemblyDispatchOptions = {};
-  const credentialToken = readOptionalString(value.credentialToken);
-  const bootstrapToken = readOptionalString(value.bootstrapToken);
-  const role = readOptionalString(value.role);
-  const registerActor = readOptionalString(value.registerActor);
-  const recoveryActor = readOptionalString(value.recoveryActor);
-  const spaceRef = readOptionalString(value.spaceRef);
-  const recoveryLimit = readOptionalNumber(value.recoveryLimit);
-  const leaseTtlMinutes = readOptionalNumber(value.leaseTtlMinutes);
-  if (credentialToken) normalized.credentialToken = credentialToken;
-  if (bootstrapToken) normalized.bootstrapToken = bootstrapToken;
-  if (role) normalized.role = role;
-  if (registerActor) normalized.registerActor = registerActor;
-  if (typeof value.recoverStaleClaims === 'boolean') normalized.recoverStaleClaims = value.recoverStaleClaims;
-  if (recoveryActor) normalized.recoveryActor = recoveryActor;
-  if (typeof recoveryLimit === 'number') normalized.recoveryLimit = Math.trunc(recoveryLimit);
-  if (typeof value.recoveryRequired === 'boolean') normalized.recoveryRequired = value.recoveryRequired;
-  if (spaceRef) normalized.spaceRef = spaceRef;
-  if (typeof leaseTtlMinutes === 'number') normalized.leaseTtlMinutes = Math.trunc(leaseTtlMinutes);
-  if (typeof value.createPlanStepIfMissing === 'boolean') {
-    normalized.createPlanStepIfMissing = value.createPlanStepIfMissing;
-  }
-  return normalized;
-}
-
-interface SelfAssemblyDispatchOptions {
-  credentialToken?: string;
-  bootstrapToken?: string;
-  role?: string;
-  registerActor?: string;
-  recoverStaleClaims?: boolean;
-  recoveryActor?: string;
-  recoveryLimit?: number;
-  recoveryRequired?: boolean;
-  spaceRef?: string;
-  leaseTtlMinutes?: number;
-  createPlanStepIfMissing?: boolean;
-}
-
-function normalizeDispatchMode(rawValue: unknown): 'direct' | 'self-assembly' | undefined {
-  const normalized = String(rawValue ?? '').trim().toLowerCase();
-  if (normalized === 'direct' || normalized === 'self-assembly') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizeExecutionTimeoutMs(value: unknown): number {
-  const numeric = readOptionalNumber(value);
-  if (numeric === undefined || !Number.isFinite(numeric) || numeric <= 0) {
-    return DEFAULT_EXECUTE_TIMEOUT_MS;
-  }
-  return Math.trunc(Math.min(60 * 60_000, Math.max(1_000, numeric)));
-}
-
-function normalizeLeaseHeartbeatIntervalMs(value: unknown, leaseDurationMinutes: number | undefined): number {
-  const numeric = readOptionalNumber(value);
-  if (numeric !== undefined && Number.isFinite(numeric) && numeric > 0) {
-    return Math.trunc(Math.min(60 * 60_000, Math.max(100, numeric)));
-  }
-  const leaseMs = normalizeLeaseMinutes(leaseDurationMinutes) * 60_000;
-  return Math.trunc(Math.min(DEFAULT_LEASE_HEARTBEAT_INTERVAL_MS, Math.max(1_000, leaseMs / 3)));
-}
-
-async function withExecutionTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-  runId: string,
-  onTimeout?: () => Promise<void> | void,
-): Promise<T> {
-  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<T>((_resolve, reject) => {
-        timeoutHandle = setTimeout(() => {
-          void Promise.resolve(onTimeout?.()).catch(() => undefined);
-          reject(new Error(`Dispatch execution timed out after ${timeoutMs}ms for run ${runId}.`));
-        }, timeoutMs);
-      }),
-    ]);
-  } finally {
-    if (timeoutHandle) clearTimeout(timeoutHandle);
-  }
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function readOptionalNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function normalizeLeaseMinutes(value: unknown): number {
-  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
-    return Math.trunc(value);
-  }
-  return DEFAULT_LEASE_MINUTES;
-}
-
-function startRunLeaseHeartbeat(
-  workspacePath: string,
-  runId: string,
-  actor: string,
-  intervalMs: number,
-): () => void {
-  let stopped = false;
-  const tick = () => {
-    if (stopped) return;
-    const run = getRun(workspacePath, runId);
-    if (!run || run.status !== 'running') return;
-    void Promise.resolve(heartbeat(workspacePath, runId, { actor })).catch(() => undefined);
-  };
-  tick();
-  const timer = setInterval(tick, intervalMs);
-  timer.unref();
-  return () => {
-    stopped = true;
-    clearInterval(timer);
-  };
-}
-
-async function safeStopAdapterExecution(
-  adapter: ReturnType<typeof resolveDispatchAdapter>,
-  runId: string,
-  actor: string,
-): Promise<void> {
-  try {
-    await adapter.stop(runId, actor);
-  } catch {
-    // Best-effort stop should never mask the original timeout/cancellation path.
-  }
-}
-
-function applyLease(run: DispatchRun, nowIso: string, requestedLeaseMinutes?: number): void {
-  const leaseMinutes = normalizeLeaseMinutes(requestedLeaseMinutes ?? run.leaseDurationMinutes);
-  const expiresAt = new Date(Date.parse(nowIso) + leaseMinutes * 60_000).toISOString();
-  run.leaseDurationMinutes = leaseMinutes;
-  run.leaseExpires = expiresAt;
-}
-
-function clearLease(run: DispatchRun): void {
-  run.leaseExpires = undefined;
-}
-
-function latestHeartbeat(run: DispatchRun): string | undefined {
-  const heartbeats = run.heartbeats ?? [];
-  return heartbeats.length > 0 ? heartbeats[heartbeats.length - 1] : undefined;
-}
-
-const RUN_STATUS_TRANSITIONS: Record<RunStatus, RunStatus[]> = {
-  queued: ['running', 'cancelled'],
-  running: ['queued', 'succeeded', 'failed', 'cancelled'],
-  succeeded: [],
-  failed: [],
-  cancelled: [],
-};
-
-function assertRunStatusTransition(from: RunStatus, to: RunStatus, runId: string): void {
-  if (from === to) return;
-  const allowed = RUN_STATUS_TRANSITIONS[from] ?? [];
-  if (!allowed.includes(to)) {
-    throw new ConflictError(
-      `Invalid run transition for ${runId}: ${from} -> ${to}. Allowed: ${allowed.join(', ') || 'none'}.`,
-      { runId, operation: 'dispatch.run.status-transition' },
-    );
-  }
-}
-
-function resolveThreadRef(threadRef: string): string {
-  const raw = String(threadRef ?? '').trim();
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]')
-    ? raw.slice(2, -2)
-    : raw;
-  if (!unwrapped) {
-    throw new InputValidationError('Thread reference is required.', {
-      operation: 'dispatch.thread.claim',
-    });
-  }
-  if (unwrapped.includes('/')) {
-    return unwrapped.endsWith('.md') ? unwrapped : `${unwrapped}.md`;
-  }
-  return `threads/${unwrapped.endsWith('.md') ? unwrapped : `${unwrapped}.md`}`;
-}
-
-function assertDispatchMutationAuthorized(
-  workspacePath: string,
-  actor: string,
-  action: string,
-  target: string,
-  requiredCapabilities: string[],
-): void {
-  auth.assertAuthorizedMutation(workspacePath, {
-    actor,
-    action,
-    target,
-    requiredCapabilities,
-    metadata: {
-      module: 'dispatch',
-    },
-  });
-}
-
-function logDispatchWarning(
-  message: string,
-  error: unknown,
-  context: {
-    runId?: string;
-    actor?: string;
-    target?: string;
-  } = {},
-): void {
-  const rendered = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-  const suffixParts = [
-    context.runId ? `run=${context.runId}` : undefined,
-    context.actor ? `actor=${context.actor}` : undefined,
-    context.target ? `target=${context.target}` : undefined,
-  ].filter(Boolean);
-  const suffix = suffixParts.length > 0 ? ` (${suffixParts.join(', ')})` : '';
-  process.stderr.write(`[workgraph][warn][dispatch] ${message}${suffix} -> ${rendered}\n`);
-}
diff --git a/packages/kernel/src/dispatch/external-run-state.ts b/packages/kernel/src/dispatch/external-run-state.ts
deleted file mode 100644
index f8d12f6..0000000
--- a/packages/kernel/src/dispatch/external-run-state.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import matter from 'gray-matter';
-import type {
-  DispatchRun,
-  DispatchRunDispatchTracking,
-  DispatchRunExternalIdentity,
-  RunStatus,
-} from '../types.js';
-
-const DISPATCH_BROKER_DIRECTORY = '.workgraph/dispatch-broker';
-
-export interface DispatchRunBrokerState {
-  runId: string;
-  external?: DispatchRunExternalIdentity;
-  tracking: DispatchRunDispatchTracking;
-  updatedAt: string;
-}
-
-export interface FindBrokerStateInput {
-  runId?: string;
-  provider?: string;
-  externalRunId?: string;
-  correlationKeys?: string[];
-}
-
-export function dispatchBrokerStatePath(workspacePath: string, runId: string): string {
-  return path.join(workspacePath, DISPATCH_BROKER_DIRECTORY, `${runId}.md`);
-}
-
-export function readDispatchBrokerState(
-  workspacePath: string,
-  runId: string,
-): DispatchRunBrokerState | null {
-  const filePath = dispatchBrokerStatePath(workspacePath, runId);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const parsed = matter(fs.readFileSync(filePath, 'utf-8'));
-    return normalizeBrokerState({
-      runId,
-      ...asRecord(parsed.data),
-    });
-  } catch {
-    return null;
-  }
-}
-
-export function listDispatchBrokerStates(workspacePath: string): DispatchRunBrokerState[] {
-  const directory = path.join(workspacePath, DISPATCH_BROKER_DIRECTORY);
-  if (!fs.existsSync(directory)) return [];
-  return fs.readdirSync(directory)
-    .filter((entry) => entry.endsWith('.md'))
-    .map((entry) => readDispatchBrokerState(workspacePath, entry.slice(0, -3)))
-    .filter((entry): entry is DispatchRunBrokerState => entry !== null)
-    .sort((left, right) => left.runId.localeCompare(right.runId));
-}
-
-export function writeDispatchBrokerState(
-  workspacePath: string,
-  input: DispatchRunBrokerState,
-): DispatchRunBrokerState {
-  const state = normalizeBrokerState(input);
-  const filePath = dispatchBrokerStatePath(workspacePath, state.runId);
-  const directory = path.dirname(filePath);
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  const content = matter.stringify(renderBrokerStateBody(state), {
-    run_id: state.runId,
-    ...(state.external ? { external: stripUndefined(state.external) } : {}),
-    dispatch_tracking: stripUndefined(state.tracking),
-    updated_at: state.updatedAt,
-  });
-  fs.writeFileSync(filePath, content, 'utf-8');
-  return state;
-}
-
-export function updateDispatchBrokerState(
-  workspacePath: string,
-  runId: string,
-  updater: (current: DispatchRunBrokerState | null) => DispatchRunBrokerState | null,
-): DispatchRunBrokerState | null {
-  const current = readDispatchBrokerState(workspacePath, runId);
-  const next = updater(current);
-  if (!next) return null;
-  return writeDispatchBrokerState(workspacePath, next);
-}
-
-export function findDispatchBrokerState(
-  workspacePath: string,
-  input: FindBrokerStateInput,
-): DispatchRunBrokerState | null {
-  if (input.runId) {
-    return readDispatchBrokerState(workspacePath, input.runId);
-  }
-  const desiredProvider = normalizeOptionalString(input.provider);
-  const desiredExternalRunId = normalizeOptionalString(input.externalRunId);
-  const desiredCorrelationKeys = new Set(
-    (input.correlationKeys ?? [])
-      .map((entry) => String(entry).trim())
-      .filter(Boolean),
-  );
-  if (!desiredProvider && !desiredExternalRunId && desiredCorrelationKeys.size === 0) {
-    return null;
-  }
-  for (const candidate of listDispatchBrokerStates(workspacePath)) {
-    const external = candidate.external;
-    if (!external) continue;
-    if (desiredProvider && external.provider !== desiredProvider) continue;
-    if (desiredExternalRunId && external.externalRunId === desiredExternalRunId) {
-      return candidate;
-    }
-    if (desiredCorrelationKeys.size > 0) {
-      const keys = new Set(external.correlationKeys ?? []);
-      for (const key of desiredCorrelationKeys) {
-        if (keys.has(key)) return candidate;
-      }
-    }
-  }
-  return null;
-}
-
-export function hydrateRunWithDispatchBrokerState(
-  run: DispatchRun,
-  brokerState: DispatchRunBrokerState | null,
-): DispatchRun {
-  if (!brokerState) {
-    return {
-      ...run,
-      dispatchTracking: normalizeDispatchTracking(run.dispatchTracking),
-    };
-  }
-  return {
-    ...run,
-    external: mergeExternalIdentity(run.external, brokerState.external),
-    dispatchTracking: mergeDispatchTracking(run.dispatchTracking, brokerState.tracking),
-  };
-}
-
-export function isBrokeredRun(run: DispatchRun): boolean {
-  return Boolean(run.external?.provider || run.dispatchTracking?.dispatchedAt);
-}
-
-export function mergeExternalIdentity(
-  current: DispatchRunExternalIdentity | undefined,
-  incoming: DispatchRunExternalIdentity | undefined,
-): DispatchRunExternalIdentity | undefined {
-  if (!current && !incoming) return undefined;
-  if (!current) return normalizeExternalIdentity(incoming);
-  if (!incoming) return normalizeExternalIdentity(current);
-  const correlationKeys = [...new Set([
-    ...(current.correlationKeys ?? []),
-    ...(incoming.correlationKeys ?? []),
-  ])];
-  return {
-    provider: incoming.provider || current.provider,
-    externalRunId: incoming.externalRunId || current.externalRunId,
-    externalAgentId: incoming.externalAgentId ?? current.externalAgentId,
-    externalThreadId: incoming.externalThreadId ?? current.externalThreadId,
-    ...(correlationKeys.length > 0 ? { correlationKeys } : {}),
-    metadata: {
-      ...(current.metadata ?? {}),
-      ...(incoming.metadata ?? {}),
-    },
-    lastKnownStatus: incoming.lastKnownStatus ?? current.lastKnownStatus,
-    lastKnownAt: incoming.lastKnownAt ?? current.lastKnownAt,
-  };
-}
-
-export function mergeDispatchTracking(
-  current: Partial<DispatchRunDispatchTracking> | DispatchRunDispatchTracking | undefined,
-  incoming: Partial<DispatchRunDispatchTracking> | DispatchRunDispatchTracking | undefined,
-): DispatchRunDispatchTracking {
-  const normalizedCurrent = normalizeDispatchTracking(current);
-  const normalizedIncoming = normalizeDispatchTracking(incoming);
-  return {
-    dispatchedAt: normalizedIncoming.dispatchedAt ?? normalizedCurrent.dispatchedAt,
-    lastSentAt: normalizedIncoming.lastSentAt ?? normalizedCurrent.lastSentAt,
-    outboundPayloadDigest: normalizedIncoming.outboundPayloadDigest ?? normalizedCurrent.outboundPayloadDigest,
-    acknowledged: normalizedIncoming.acknowledged ?? normalizedCurrent.acknowledged,
-    acknowledgedAt: normalizedIncoming.acknowledgedAt ?? normalizedCurrent.acknowledgedAt,
-    retryCount: Math.max(normalizedCurrent.retryCount, normalizedIncoming.retryCount),
-    lastReconciledAt: normalizedIncoming.lastReconciledAt ?? normalizedCurrent.lastReconciledAt,
-    reconciliationError: normalizedIncoming.reconciliationError ?? normalizedCurrent.reconciliationError,
-    cancellationRequestedAt: normalizedIncoming.cancellationRequestedAt ?? normalizedCurrent.cancellationRequestedAt,
-    cancellationAcknowledgedAt: normalizedIncoming.cancellationAcknowledgedAt ?? normalizedCurrent.cancellationAcknowledgedAt,
-  };
-}
-
-export function normalizeDispatchTracking(
-  tracking: Partial<DispatchRunDispatchTracking> | DispatchRunDispatchTracking | undefined,
-): DispatchRunDispatchTracking {
-  return {
-    dispatchedAt: normalizeOptionalString(tracking?.dispatchedAt),
-    lastSentAt: normalizeOptionalString(tracking?.lastSentAt),
-    outboundPayloadDigest: normalizeOptionalString(tracking?.outboundPayloadDigest),
-    acknowledged: tracking?.acknowledged === true ? true : undefined,
-    acknowledgedAt: normalizeOptionalString(tracking?.acknowledgedAt),
-    retryCount: typeof tracking?.retryCount === 'number' && Number.isFinite(tracking.retryCount)
-      ? Math.max(0, Math.trunc(tracking.retryCount))
-      : 0,
-    lastReconciledAt: normalizeOptionalString(tracking?.lastReconciledAt),
-    reconciliationError: normalizeOptionalString(tracking?.reconciliationError),
-    cancellationRequestedAt: normalizeOptionalString(tracking?.cancellationRequestedAt),
-    cancellationAcknowledgedAt: normalizeOptionalString(tracking?.cancellationAcknowledgedAt),
-  };
-}
-
-export function normalizeExternalIdentity(
-  external: DispatchRunExternalIdentity | undefined,
-): DispatchRunExternalIdentity | undefined {
-  if (!external) return undefined;
-  const provider = normalizeOptionalString(external.provider);
-  const externalRunId = normalizeOptionalString(external.externalRunId);
-  if (!provider || !externalRunId) return undefined;
-  const correlationKeys = (external.correlationKeys ?? [])
-    .map((entry) => String(entry).trim())
-    .filter(Boolean);
-  return {
-    provider,
-    externalRunId,
-    externalAgentId: normalizeOptionalString(external.externalAgentId),
-    externalThreadId: normalizeOptionalString(external.externalThreadId),
-    ...(correlationKeys.length > 0 ? { correlationKeys: [...new Set(correlationKeys)] } : {}),
-    ...(isRecord(external.metadata) ? { metadata: external.metadata } : {}),
-    lastKnownStatus: normalizeRunStatus(external.lastKnownStatus),
-    lastKnownAt: normalizeOptionalString(external.lastKnownAt),
-  };
-}
-
-function normalizeBrokerState(value: unknown): DispatchRunBrokerState {
-  const root = asRecord(value);
-  const runId = normalizeOptionalString(root.runId) ?? normalizeOptionalString(root.run_id) ?? 'unknown';
-  const trackingRoot = asRecord(root.dispatch_tracking ?? root.tracking);
-  return {
-    runId,
-    external: normalizeExternalIdentity(asRecord(root.external) as unknown as DispatchRunExternalIdentity | undefined),
-    tracking: normalizeDispatchTracking(trackingRoot as unknown as DispatchRunDispatchTracking),
-    updatedAt: normalizeOptionalString(root.updatedAt) ?? normalizeOptionalString(root.updated_at) ?? new Date().toISOString(),
-  };
-}
-
-function renderBrokerStateBody(state: DispatchRunBrokerState): string {
-  const lines = [
-    '## External run broker state',
-    '',
-    `Run: ${state.runId}`,
-    `Updated: ${state.updatedAt}`,
-    '',
-    '## External',
-    '',
-  ];
-  if (state.external) {
-    lines.push(`Provider: ${state.external.provider}`);
-    lines.push(`External run id: ${state.external.externalRunId}`);
-    lines.push(`Last known status: ${state.external.lastKnownStatus ?? 'unknown'}`);
-    lines.push(`Last known at: ${state.external.lastKnownAt ?? 'unknown'}`);
-    if ((state.external.correlationKeys ?? []).length > 0) {
-      lines.push(`Correlation keys: ${(state.external.correlationKeys ?? []).join(', ')}`);
-    }
-  } else {
-    lines.push('No external identity recorded.');
-  }
-  lines.push('');
-  lines.push('## Dispatch tracking');
-  lines.push('');
-  lines.push(`Dispatched at: ${state.tracking.dispatchedAt ?? 'n/a'}`);
-  lines.push(`Last sent at: ${state.tracking.lastSentAt ?? 'n/a'}`);
-  lines.push(`Acknowledged: ${state.tracking.acknowledged === true ? 'yes' : 'no'}`);
-  lines.push(`Acknowledged at: ${state.tracking.acknowledgedAt ?? 'n/a'}`);
-  lines.push(`Retry count: ${state.tracking.retryCount}`);
-  lines.push(`Last reconciled at: ${state.tracking.lastReconciledAt ?? 'n/a'}`);
-  lines.push(`Reconciliation error: ${state.tracking.reconciliationError ?? 'n/a'}`);
-  lines.push(`Cancellation requested at: ${state.tracking.cancellationRequestedAt ?? 'n/a'}`);
-  lines.push(`Cancellation acknowledged at: ${state.tracking.cancellationAcknowledgedAt ?? 'n/a'}`);
-  return `${lines.join('\n')}\n`;
-}
-
-function normalizeRunStatus(value: unknown): RunStatus | undefined {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (
-    normalized === 'queued'
-    || normalized === 'running'
-    || normalized === 'succeeded'
-    || normalized === 'failed'
-    || normalized === 'cancelled'
-  ) {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizeOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function asRecord(value: unknown): Record<string, unknown> {
-  return isRecord(value) ? value : {};
-}
-
-function stripUndefined<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => stripUndefined(entry))
-      .filter((entry) => entry !== undefined) as T;
-  }
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-  const cleaned: Record<string, unknown> = {};
-  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-    if (entry === undefined) continue;
-    cleaned[key] = stripUndefined(entry);
-  }
-  return cleaned as T;
-}
diff --git a/packages/kernel/src/environment.test.ts b/packages/kernel/src/environment.test.ts
deleted file mode 100644
index 40ea0d3..0000000
--- a/packages/kernel/src/environment.test.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  detectEnvironment,
-  getEnvironmentInfo,
-  isFeatureEnabled,
-  listFeatureFlags,
-} from './environment.js';
-
-describe('environment detection', () => {
-  it('prefers WORKGRAPH_ENV when set to cloud/local', () => {
-    expect(detectEnvironment(asEnv({ WORKGRAPH_ENV: 'cloud' }))).toBe('cloud');
-    expect(detectEnvironment(asEnv({ WORKGRAPH_ENV: 'local', VERCEL: '1' }))).toBe('local');
-  });
-
-  it('falls back to cloud when known cloud signals are present', () => {
-    expect(detectEnvironment(asEnv({ VERCEL: '1' }))).toBe('cloud');
-    expect(detectEnvironment(asEnv({ K_SERVICE: 'workgraph-api' }))).toBe('cloud');
-  });
-
-  it('defaults to local when no signals are present', () => {
-    expect(detectEnvironment(asEnv({}))).toBe('local');
-  });
-
-  it('returns environment metadata including source and feature flags', () => {
-    const info = getEnvironmentInfo(asEnv({
-      WORKGRAPH_ENV: 'cloud',
-      WORKGRAPH_FEATURE_PORTABILITY: 'true',
-      WORKGRAPH_FEATURE_FAST_IMPORT: '0',
-    }));
-
-    expect(info.environment).toBe('cloud');
-    expect(info.source).toBe('explicit');
-    expect(info.featureFlags).toEqual({
-      portability: true,
-      'fast-import': false,
-    });
-  });
-});
-
-describe('feature flags', () => {
-  it('lists and normalizes WORKGRAPH_FEATURE_* flags', () => {
-    expect(listFeatureFlags(asEnv({
-      WORKGRAPH_FEATURE_LOCAL_EXPORT: 'yes',
-      WORKGRAPH_FEATURE_CLOUD_IMPORT: 'off',
-      WORKGRAPH_FEATURE_EMPTY: '',
-    }))).toEqual({
-      'local-export': true,
-      'cloud-import': false,
-      empty: false,
-    });
-  });
-
-  it('resolves one feature flag with defaults', () => {
-    const env = asEnv({
-      WORKGRAPH_FEATURE_LOCAL_EXPORT: 'true',
-    });
-    expect(isFeatureEnabled('local-export', env)).toBe(true);
-    expect(isFeatureEnabled('cloud-import', env)).toBe(false);
-    expect(isFeatureEnabled('unknown-flag', env, true)).toBe(true);
-  });
-});
-
-function asEnv(values: Record<string, string>): NodeJS.ProcessEnv {
-  return values as NodeJS.ProcessEnv;
-}
diff --git a/packages/kernel/src/environment.ts b/packages/kernel/src/environment.ts
deleted file mode 100644
index 8092b89..0000000
--- a/packages/kernel/src/environment.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-export type WorkgraphEnvironmentKind = 'local' | 'cloud';
-
-export interface WorkgraphEnvironmentInfo {
-  environment: WorkgraphEnvironmentKind;
-  source: 'explicit' | 'platform' | 'default';
-  featureFlags: Record<string, boolean>;
-}
-
-const CLOUD_PLATFORM_SIGNAL_KEYS = [
-  'VERCEL',
-  'K_SERVICE',
-  'AWS_EXECUTION_ENV',
-  'RAILWAY_ENVIRONMENT',
-  'RENDER',
-  'FLY_APP_NAME',
-] as const;
-
-export function detectEnvironment(env: NodeJS.ProcessEnv = process.env): WorkgraphEnvironmentKind {
-  const explicit = normalizeEnvironment(env.WORKGRAPH_ENV);
-  if (explicit) return explicit;
-  if (hasCloudPlatformSignals(env)) return 'cloud';
-  return 'local';
-}
-
-export function getEnvironmentInfo(env: NodeJS.ProcessEnv = process.env): WorkgraphEnvironmentInfo {
-  const explicit = normalizeEnvironment(env.WORKGRAPH_ENV);
-  if (explicit) {
-    return {
-      environment: explicit,
-      source: 'explicit',
-      featureFlags: listFeatureFlags(env),
-    };
-  }
-
-  if (hasCloudPlatformSignals(env)) {
-    return {
-      environment: 'cloud',
-      source: 'platform',
-      featureFlags: listFeatureFlags(env),
-    };
-  }
-
-  return {
-    environment: 'local',
-    source: 'default',
-    featureFlags: listFeatureFlags(env),
-  };
-}
-
-export function listFeatureFlags(env: NodeJS.ProcessEnv = process.env): Record<string, boolean> {
-  const flags: Record<string, boolean> = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (!key.startsWith('WORKGRAPH_FEATURE_')) continue;
-    const featureName = normalizeFeatureFlagName(key.slice('WORKGRAPH_FEATURE_'.length));
-    if (!featureName) continue;
-    flags[featureName] = parseBooleanFlag(value, false);
-  }
-  return flags;
-}
-
-export function isFeatureEnabled(
-  featureName: string,
-  env: NodeJS.ProcessEnv = process.env,
-  defaultValue = false,
-): boolean {
-  const normalizedFeatureName = normalizeFeatureFlagName(featureName);
-  if (!normalizedFeatureName) return defaultValue;
-  const envKey = `WORKGRAPH_FEATURE_${normalizedFeatureName.toUpperCase().replace(/-/g, '_')}`;
-  return parseBooleanFlag(env[envKey], defaultValue);
-}
-
-function normalizeEnvironment(raw: string | undefined): WorkgraphEnvironmentKind | undefined {
-  if (!raw) return undefined;
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === 'local' || normalized === 'cloud') return normalized;
-  return undefined;
-}
-
-function normalizeFeatureFlagName(raw: string): string {
-  return raw
-    .trim()
-    .toLowerCase()
-    .replaceAll('_', '-');
-}
-
-function hasCloudPlatformSignals(env: NodeJS.ProcessEnv): boolean {
-  return CLOUD_PLATFORM_SIGNAL_KEYS.some((key) => readNonEmptyString(env[key]) !== undefined);
-}
-
-function parseBooleanFlag(raw: string | undefined, defaultValue: boolean): boolean {
-  const normalized = readNonEmptyString(raw)?.toLowerCase();
-  if (!normalized) return defaultValue;
-  if (normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on') return true;
-  if (normalized === '0' || normalized === 'false' || normalized === 'no' || normalized === 'off') return false;
-  return defaultValue;
-}
-
-function readNonEmptyString(value: string | undefined): string | undefined {
-  if (!value) return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
diff --git a/packages/kernel/src/export-import.test.ts b/packages/kernel/src/export-import.test.ts
deleted file mode 100644
index 202fc4f..0000000
--- a/packages/kernel/src/export-import.test.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { initWorkspace } from './workspace.js';
-import { exportWorkspaceSnapshot, importWorkspaceSnapshot } from './export-import.js';
-
-let tempRoot: string;
-
-beforeEach(() => {
-  tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-export-import-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-
-const portabilityTest = hasTarCommand() ? it : it.skip;
-
-describe('workspace export/import', () => {
-  portabilityTest('exports a workspace to tar.gz and imports into a new path', () => {
-    const sourceWorkspacePath = path.join(tempRoot, 'source-workspace');
-    initWorkspace(sourceWorkspacePath);
-    fs.mkdirSync(path.join(sourceWorkspacePath, 'docs'), { recursive: true });
-    fs.writeFileSync(path.join(sourceWorkspacePath, 'docs', 'note.md'), '# Snapshot smoke test\n', 'utf-8');
-
-    const snapshotPath = path.join(tempRoot, 'snapshots', 'workspace.tar.gz');
-    const exportResult = exportWorkspaceSnapshot(sourceWorkspacePath, snapshotPath);
-    expect(fs.existsSync(snapshotPath)).toBe(true);
-    expect(exportResult.bytes).toBeGreaterThan(0);
-
-    const importedWorkspacePath = path.join(tempRoot, 'imported-workspace');
-    const importResult = importWorkspaceSnapshot(snapshotPath, importedWorkspacePath);
-    expect(importResult.filesImported).toBeGreaterThan(0);
-    expect(fs.existsSync(path.join(importedWorkspacePath, '.workgraph.json'))).toBe(true);
-    expect(fs.readFileSync(path.join(importedWorkspacePath, 'docs', 'note.md'), 'utf-8')).toContain('Snapshot');
-  });
-
-  portabilityTest('rejects importing into non-empty workspace unless overwrite is enabled', () => {
-    const sourceWorkspacePath = path.join(tempRoot, 'source-workspace');
-    initWorkspace(sourceWorkspacePath);
-    const snapshotPath = path.join(tempRoot, 'snapshots', 'workspace.tar.gz');
-    exportWorkspaceSnapshot(sourceWorkspacePath, snapshotPath);
-
-    const existingWorkspacePath = path.join(tempRoot, 'existing-workspace');
-    initWorkspace(existingWorkspacePath);
-
-    expect(() => importWorkspaceSnapshot(snapshotPath, existingWorkspacePath)).toThrow(
-      /already contains files/i,
-    );
-  });
-
-  portabilityTest('supports overwriting an existing workspace on import', () => {
-    const sourceWorkspacePath = path.join(tempRoot, 'source-workspace');
-    initWorkspace(sourceWorkspacePath);
-    fs.mkdirSync(path.join(sourceWorkspacePath, 'docs'), { recursive: true });
-    fs.writeFileSync(path.join(sourceWorkspacePath, 'docs', 'overwrite.md'), 'from source\n', 'utf-8');
-
-    const snapshotPath = path.join(tempRoot, 'snapshots', 'workspace.tar.gz');
-    exportWorkspaceSnapshot(sourceWorkspacePath, snapshotPath);
-
-    const existingWorkspacePath = path.join(tempRoot, 'existing-workspace');
-    initWorkspace(existingWorkspacePath);
-    fs.mkdirSync(path.join(existingWorkspacePath, 'docs'), { recursive: true });
-    fs.writeFileSync(path.join(existingWorkspacePath, 'docs', 'old.md'), 'stale\n', 'utf-8');
-
-    importWorkspaceSnapshot(snapshotPath, existingWorkspacePath, { overwrite: true });
-    expect(fs.existsSync(path.join(existingWorkspacePath, 'docs', 'overwrite.md'))).toBe(true);
-  });
-});
-
-function hasTarCommand(): boolean {
-  const result = spawnSync('tar', ['--version'], { encoding: 'utf-8' });
-  if (result.error) return false;
-  return result.status === 0;
-}
diff --git a/packages/kernel/src/export-import.ts b/packages/kernel/src/export-import.ts
deleted file mode 100644
index d5fff80..0000000
--- a/packages/kernel/src/export-import.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { LocalStorageAdapter, type StorageAdapter } from './storage-adapter.js';
-
-export interface ExportWorkspaceSnapshotOptions {
-  storageAdapter?: StorageAdapter;
-}
-
-export interface ExportWorkspaceSnapshotResult {
-  workspacePath: string;
-  snapshotPath: string;
-  bytes: number;
-  createdAt: string;
-  adapterKind: 'local';
-}
-
-export interface ImportWorkspaceSnapshotOptions {
-  overwrite?: boolean;
-  storageAdapter?: StorageAdapter;
-}
-
-export interface ImportWorkspaceSnapshotResult {
-  workspacePath: string;
-  snapshotPath: string;
-  filesImported: number;
-  importedAt: string;
-  adapterKind: 'local';
-}
-
-export function exportWorkspaceSnapshot(
-  workspacePath: string,
-  snapshotPath: string,
-  options: ExportWorkspaceSnapshotOptions = {},
-): ExportWorkspaceSnapshotResult {
-  const adapter = options.storageAdapter ?? new LocalStorageAdapter();
-  assertLocalAdapter(adapter, 'export');
-
-  const absoluteWorkspacePath = adapter.resolve(workspacePath);
-  if (!adapter.exists(absoluteWorkspacePath)) {
-    throw new Error(`Workspace path does not exist: ${absoluteWorkspacePath}`);
-  }
-  if (!adapter.stat(absoluteWorkspacePath).isDirectory()) {
-    throw new Error(`Workspace path must be a directory: ${absoluteWorkspacePath}`);
-  }
-
-  const absoluteSnapshotPath = adapter.resolve(snapshotPath);
-  adapter.mkdir(path.dirname(absoluteSnapshotPath), { recursive: true });
-
-  // Use tar so snapshots remain standard tar.gz archives across environments.
-  runTarCommand([
-    '-czf',
-    absoluteSnapshotPath,
-    '-C',
-    absoluteWorkspacePath,
-    '.',
-  ]);
-
-  const snapshotStats = adapter.stat(absoluteSnapshotPath);
-  return {
-    workspacePath: absoluteWorkspacePath,
-    snapshotPath: absoluteSnapshotPath,
-    bytes: snapshotStats.size,
-    createdAt: new Date().toISOString(),
-    adapterKind: 'local',
-  };
-}
-
-export function importWorkspaceSnapshot(
-  snapshotPath: string,
-  workspacePath: string,
-  options: ImportWorkspaceSnapshotOptions = {},
-): ImportWorkspaceSnapshotResult {
-  const adapter = options.storageAdapter ?? new LocalStorageAdapter();
-  assertLocalAdapter(adapter, 'import');
-
-  const absoluteSnapshotPath = adapter.resolve(snapshotPath);
-  if (!adapter.exists(absoluteSnapshotPath)) {
-    throw new Error(`Snapshot file does not exist: ${absoluteSnapshotPath}`);
-  }
-  if (!adapter.stat(absoluteSnapshotPath).isFile()) {
-    throw new Error(`Snapshot path must be a file: ${absoluteSnapshotPath}`);
-  }
-
-  const absoluteWorkspacePath = adapter.resolve(workspacePath);
-  const overwrite = options.overwrite === true;
-  if (adapter.exists(absoluteWorkspacePath) && !overwrite && !isDirectoryEmpty(adapter, absoluteWorkspacePath)) {
-    throw new Error(
-      `Workspace path already contains files. Use overwrite to replace existing content: ${absoluteWorkspacePath}`,
-    );
-  }
-
-  const extractionRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'workgraph-import-'));
-  try {
-    runTarCommand([
-      '-xzf',
-      absoluteSnapshotPath,
-      '-C',
-      extractionRoot,
-    ]);
-
-    if (overwrite && adapter.exists(absoluteWorkspacePath)) {
-      adapter.rm(absoluteWorkspacePath, { recursive: true, force: true });
-    }
-    adapter.mkdir(absoluteWorkspacePath, { recursive: true });
-
-    const entries = fs.readdirSync(extractionRoot);
-    for (const entry of entries) {
-      const sourceEntryPath = path.join(extractionRoot, entry);
-      const destinationEntryPath = path.join(absoluteWorkspacePath, entry);
-      fs.cpSync(sourceEntryPath, destinationEntryPath, {
-        recursive: true,
-        force: overwrite,
-        errorOnExist: !overwrite,
-      });
-    }
-
-    return {
-      workspacePath: absoluteWorkspacePath,
-      snapshotPath: absoluteSnapshotPath,
-      filesImported: countFilesRecursively(extractionRoot),
-      importedAt: new Date().toISOString(),
-      adapterKind: 'local',
-    };
-  } finally {
-    fs.rmSync(extractionRoot, { recursive: true, force: true });
-  }
-}
-
-function assertLocalAdapter(adapter: StorageAdapter, operation: 'export' | 'import'): void {
-  if (adapter.kind !== 'local') {
-    throw new Error(`Cloud storage adapter is not yet supported for workspace ${operation}.`);
-  }
-}
-
-function isDirectoryEmpty(adapter: StorageAdapter, targetPath: string): boolean {
-  if (!adapter.exists(targetPath)) return true;
-  if (!adapter.stat(targetPath).isDirectory()) return false;
-  return adapter.readdir(targetPath).length === 0;
-}
-
-function runTarCommand(args: string[]): void {
-  const result = spawnSync('tar', args, {
-    encoding: 'utf-8',
-  });
-  if (!result.error && result.status === 0) return;
-
-  if (result.error && (result.error as NodeJS.ErrnoException).code === 'ENOENT') {
-    throw new Error('Failed to execute tar command. Ensure tar is installed and available on PATH.');
-  }
-
-  const details = (result.stderr || result.stdout || '').trim();
-  throw new Error(`tar command failed: ${details || `exit status ${String(result.status)}`}`);
-}
-
-function countFilesRecursively(rootPath: string): number {
-  if (!fs.existsSync(rootPath)) return 0;
-  const stats = fs.statSync(rootPath);
-  if (stats.isFile()) return 1;
-  if (!stats.isDirectory()) return 0;
-
-  let total = 0;
-  for (const entry of fs.readdirSync(rootPath)) {
-    total += countFilesRecursively(path.join(rootPath, entry));
-  }
-  return total;
-}
diff --git a/packages/kernel/src/federation-helpers.ts b/packages/kernel/src/federation-helpers.ts
deleted file mode 100644
index 0250ead..0000000
--- a/packages/kernel/src/federation-helpers.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-
-export const FEDERATION_PROTOCOL_VERSION = 'wg-federation/v1';
-export const DEFAULT_FEDERATION_CAPABILITIES = [
-  'resolve-ref',
-  'search',
-  'read-primitive',
-  'read-thread',
-] as const;
-
-export type FederationTrustLevel = 'local' | 'read-only';
-export type FederationTransportKind = 'local-path' | 'http' | 'mcp';
-
-export interface FederationWorkspaceIdentity {
-  workspaceId: string;
-  protocolVersion: string;
-  capabilities: string[];
-  trustLevel: FederationTrustLevel;
-}
-
-export interface FederatedPrimitiveRef {
-  workspaceId: string;
-  primitiveType: string;
-  primitiveSlug: string;
-  protocolVersion: string;
-  transport: FederationTransportKind;
-  primitivePath?: string;
-  remoteAlias?: string;
-}
-
-export function deriveWorkspaceId(workspacePath: string): string {
-  const normalized = path.resolve(workspacePath).replace(/\\/g, '/');
-  const hash = createHash('sha256').update(`workgraph-federation:${normalized}`).digest('hex');
-  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
-}
-
-export function normalizeFederationWorkspaceIdentity(
-  value: unknown,
-  workspacePath: string,
-  fallbackTrustLevel: FederationTrustLevel = 'local',
-): FederationWorkspaceIdentity {
-  const record = asRecord(value);
-  return {
-    workspaceId: normalizeOptionalString(record.workspaceId) ?? normalizeOptionalString(record.workspace_id) ?? deriveWorkspaceId(workspacePath),
-    protocolVersion: normalizeProtocolVersion(record.protocolVersion ?? record.protocol_version),
-    capabilities: normalizeCapabilitySet(record.capabilities),
-    trustLevel: normalizeTrustLevel(record.trustLevel ?? record.trust_level, fallbackTrustLevel),
-  };
-}
-
-export function normalizeProtocolVersion(value: unknown): string {
-  return normalizeOptionalString(value) ?? FEDERATION_PROTOCOL_VERSION;
-}
-
-export function normalizeCapabilitySet(value: unknown): string[] {
-  const raw = Array.isArray(value)
-    ? value
-    : DEFAULT_FEDERATION_CAPABILITIES;
-  return [...new Set(raw.map((entry) => String(entry ?? '').trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
-}
-
-export function normalizeTrustLevel(value: unknown, fallback: FederationTrustLevel = 'read-only'): FederationTrustLevel {
-  const normalized = normalizeOptionalString(value)?.toLowerCase();
-  if (normalized === 'local' || normalized === 'read-only') return normalized;
-  return fallback;
-}
-
-export function normalizeTransportKind(value: unknown, fallback: FederationTransportKind = 'local-path'): FederationTransportKind {
-  const normalized = normalizeOptionalString(value)?.toLowerCase();
-  if (normalized === 'local-path' || normalized === 'http' || normalized === 'mcp') return normalized;
-  return fallback;
-}
-
-export function buildFederatedPrimitiveRef(input: {
-  workspaceId: string;
-  primitiveType: string;
-  primitivePath: string;
-  protocolVersion?: string;
-  transport?: FederationTransportKind;
-  remoteAlias?: string;
-}): FederatedPrimitiveRef {
-  return {
-    workspaceId: input.workspaceId,
-    primitiveType: input.primitiveType,
-    primitiveSlug: primitiveSlugFromPath(input.primitivePath),
-    protocolVersion: normalizeProtocolVersion(input.protocolVersion),
-    transport: input.transport ?? 'local-path',
-    primitivePath: normalizePrimitivePath(input.primitivePath),
-    ...(input.remoteAlias ? { remoteAlias: input.remoteAlias } : {}),
-  };
-}
-
-export function normalizeFederatedPrimitiveRef(value: unknown): FederatedPrimitiveRef | null {
-  const record = asRecord(value);
-  const workspaceId = normalizeOptionalString(record.workspaceId) ?? normalizeOptionalString(record.workspace_id);
-  const primitiveType = normalizeOptionalString(record.primitiveType) ?? normalizeOptionalString(record.primitive_type);
-  const primitiveSlug = normalizeOptionalString(record.primitiveSlug) ?? normalizeOptionalString(record.primitive_slug);
-  if (!workspaceId || !primitiveType || !primitiveSlug) return null;
-  return {
-    workspaceId,
-    primitiveType,
-    primitiveSlug,
-    protocolVersion: normalizeProtocolVersion(record.protocolVersion ?? record.protocol_version),
-    transport: normalizeTransportKind(record.transport),
-    ...(normalizeOptionalString(record.primitivePath) ?? normalizeOptionalString(record.primitive_path)
-      ? { primitivePath: normalizePrimitivePath(normalizeOptionalString(record.primitivePath) ?? normalizeOptionalString(record.primitive_path)!) }
-      : {}),
-    ...(normalizeOptionalString(record.remoteAlias) ?? normalizeOptionalString(record.remote_alias)
-      ? { remoteAlias: normalizeOptionalString(record.remoteAlias) ?? normalizeOptionalString(record.remote_alias)! }
-      : {}),
-  };
-}
-
-export function parseFederatedRef(value: unknown): FederatedPrimitiveRef | null {
-  if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-    return normalizeFederatedPrimitiveRef(value);
-  }
-  const raw = normalizeOptionalString(value);
-  if (!raw) return null;
-  if (!raw.startsWith('federation://')) return null;
-  const payload = raw.slice('federation://'.length);
-  const firstSlash = payload.indexOf('/');
-  if (firstSlash <= 0) return null;
-  const remoteAlias = payload.slice(0, firstSlash);
-  const primitivePath = normalizePrimitivePath(payload.slice(firstSlash + 1));
-  const primitiveType = primitiveTypeFromPath(primitivePath);
-  const primitiveSlug = primitiveSlugFromPath(primitivePath);
-  if (!primitiveType || !primitiveSlug) return null;
-  return {
-    workspaceId: remoteAlias,
-    primitiveType,
-    primitiveSlug,
-    protocolVersion: FEDERATION_PROTOCOL_VERSION,
-    transport: 'local-path',
-    primitivePath,
-    remoteAlias,
-  };
-}
-
-export function buildLegacyFederationLink(remoteAlias: string, primitivePath: string): string {
-  return `federation://${remoteAlias}/${normalizePrimitivePath(primitivePath)}`;
-}
-
-export function primitiveSlugFromPath(primitivePath: string): string {
-  const normalized = normalizePrimitivePath(primitivePath);
-  const basename = path.basename(normalized, '.md');
-  return basename;
-}
-
-export function primitiveTypeFromPath(primitivePath: string): string {
-  const normalized = normalizePrimitivePath(primitivePath);
-  const [directory] = normalized.split('/');
-  if (!directory) return '';
-  if (directory === 'threads') return 'thread';
-  return directory.endsWith('s') ? directory.slice(0, -1) : directory;
-}
-
-export function normalizePrimitivePath(value: unknown): string {
-  const raw = normalizeOptionalString(value) ?? '';
-  if (!raw) return '';
-  return raw.endsWith('.md') ? raw.replace(/\\/g, '/') : `${raw.replace(/\\/g, '/')}.md`;
-}
-
-export function normalizeOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-export function asRecord(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  return value as Record<string, unknown>;
-}
diff --git a/packages/kernel/src/federation-resolve.test.ts b/packages/kernel/src/federation-resolve.test.ts
deleted file mode 100644
index e5434b2..0000000
--- a/packages/kernel/src/federation-resolve.test.ts
+++ /dev/null
@@ -1,180 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as federation from './federation.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as store from './store.js';
-import { createThread } from './thread.js';
-
-let workspacePath: string;
-let remoteWorkspacePath: string;
-
-beforeEach(() => {
-  workspacePath = createWorkspace('wg-federation-resolve-');
-  remoteWorkspacePath = createWorkspace('wg-federation-resolve-remote-');
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-  fs.rmSync(remoteWorkspacePath, { recursive: true, force: true });
-});
-
-describe('federation identity and resolution', () => {
-  it('creates stable local workspace identity in federation config', () => {
-    const config = federation.ensureFederationConfig(workspacePath);
-    expect(config.workspace.workspaceId).toMatch(/^[0-9a-f-]{36}$/);
-    expect(config.workspace.protocolVersion).toBe('wg-federation/v1');
-    expect(config.workspace.capabilities).toContain('resolve-ref');
-    expect(config.workspace.trustLevel).toBe('local');
-  });
-
-  it('stores typed federated refs alongside legacy links and resolves them remotely', () => {
-    createThread(workspacePath, 'Local Thread', 'Local handoff', 'agent-local');
-    const remoteThread = createThread(remoteWorkspacePath, 'Remote Thread', 'Remote dependency', 'agent-remote');
-    federation.ensureFederationConfig(remoteWorkspacePath);
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-      name: 'Remote Main',
-    });
-
-    const linked = federation.linkThreadToRemoteWorkspace(
-      workspacePath,
-      'threads/local-thread.md',
-      'remote-main',
-      remoteThread.path,
-      'agent-local',
-    );
-    expect(linked.ref.workspaceId).toBe(federation.ensureFederationConfig(remoteWorkspacePath).workspace.workspaceId);
-    expect(linked.ref.primitiveType).toBe('thread');
-    expect(linked.ref.primitiveSlug).toBe('remote-thread');
-    expect(linked.ref.protocolVersion).toBe('wg-federation/v1');
-    expect(readRefs(linked.thread.fields.federation_refs)).toHaveLength(1);
-
-    const resolved = federation.resolveFederatedRef(workspacePath, linked.ref);
-    expect(resolved.source).toBe('remote');
-    expect(resolved.authority).toBe('remote');
-    expect(resolved.instance.path).toBe(remoteThread.path);
-  });
-
-  it('prefers local authority when local and remote primitive slugs collide', () => {
-    const localThread = createThread(workspacePath, 'Remote Thread', 'Local wins', 'agent-local');
-    const remoteThread = createThread(remoteWorkspacePath, 'Remote Thread', 'Remote collides', 'agent-remote');
-    federation.ensureFederationConfig(remoteWorkspacePath);
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-    });
-
-    const linked = federation.linkThreadToRemoteWorkspace(
-      workspacePath,
-      localThread.path,
-      'remote-main',
-      remoteThread.path,
-      'agent-local',
-    );
-    const resolved = federation.resolveFederatedRef(workspacePath, linked.ref);
-    expect(resolved.source).toBe('local');
-    expect(resolved.authority).toBe('local');
-    expect(resolved.instance.path).toBe(localThread.path);
-    expect(resolved.warning).toContain('overrides remote authority');
-  });
-
-  it('fails clearly on protocol or capability mismatch and surfaces staleness', () => {
-    const remoteThread = createThread(remoteWorkspacePath, 'Remote Capability', 'Remote capability target', 'agent-remote');
-    federation.saveFederationConfig(remoteWorkspacePath, {
-      version: 2,
-      updatedAt: new Date().toISOString(),
-      workspace: {
-        workspaceId: 'remote-capability-test',
-        protocolVersion: 'wg-federation/v999',
-        capabilities: ['search'],
-        trustLevel: 'read-only',
-      },
-      remotes: [],
-    });
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-    });
-
-    expect(() => federation.resolveFederatedRef(
-      workspacePath,
-      {
-        workspaceId: 'remote-capability-test',
-        primitiveType: 'thread',
-        primitiveSlug: 'remote-capability',
-        primitivePath: remoteThread.path,
-        protocolVersion: 'wg-federation/v999',
-        transport: 'local-path',
-        remoteAlias: 'remote-main',
-      },
-    )).toThrow('Protocol mismatch');
-
-    federation.saveFederationConfig(remoteWorkspacePath, {
-      version: 2,
-      updatedAt: new Date().toISOString(),
-      workspace: {
-        workspaceId: 'remote-capability-test',
-        protocolVersion: 'wg-federation/v1',
-        capabilities: ['search'],
-        trustLevel: 'read-only',
-      },
-      remotes: [],
-    });
-    expect(() => federation.resolveFederatedRef(
-      workspacePath,
-      {
-        workspaceId: 'remote-capability-test',
-        primitiveType: 'thread',
-        primitiveSlug: 'remote-capability',
-        primitivePath: remoteThread.path,
-        protocolVersion: 'wg-federation/v1',
-        transport: 'local-path',
-        remoteAlias: 'remote-main',
-      },
-    )).toThrow('does not support federated ref resolution');
-
-    federation.saveFederationConfig(remoteWorkspacePath, {
-      version: 2,
-      updatedAt: new Date().toISOString(),
-      workspace: {
-        workspaceId: 'remote-capability-test',
-        protocolVersion: 'wg-federation/v1',
-        capabilities: ['search', 'resolve-ref', 'read-thread'],
-        trustLevel: 'read-only',
-      },
-      remotes: [],
-    });
-    federation.syncFederation(workspacePath, 'sync-agent');
-    store.update(remoteWorkspacePath, remoteThread.path, { status: 'blocked' }, undefined, 'agent-remote');
-    const resolved = federation.resolveFederatedRef(
-      workspacePath,
-      {
-        workspaceId: 'remote-capability-test',
-        primitiveType: 'thread',
-        primitiveSlug: 'remote-capability',
-        primitivePath: remoteThread.path,
-        protocolVersion: 'wg-federation/v1',
-        transport: 'local-path',
-        remoteAlias: 'remote-main',
-      },
-    );
-    expect(resolved.stale).toBe(true);
-    expect(resolved.warning).toContain('stale');
-  });
-});
-
-function createWorkspace(prefix: string): string {
-  const target = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  const registry = loadRegistry(target);
-  saveRegistry(target, registry);
-  return target;
-}
-
-function readRefs(value: unknown): Array<Record<string, unknown>> {
-  return Array.isArray(value)
-    ? value.filter((entry): entry is Record<string, unknown> => !!entry && typeof entry === 'object')
-    : [];
-}
diff --git a/packages/kernel/src/federation.test.ts b/packages/kernel/src/federation.test.ts
deleted file mode 100644
index a2de0bd..0000000
--- a/packages/kernel/src/federation.test.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as federation from './federation.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { createThread } from './thread.js';
-
-let workspacePath: string;
-let remoteWorkspacePath: string;
-
-beforeEach(() => {
-  workspacePath = createWorkspace('wg-federation-');
-  remoteWorkspacePath = createWorkspace('wg-federation-remote-');
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-  fs.rmSync(remoteWorkspacePath, { recursive: true, force: true });
-});
-
-describe('federation config', () => {
-  it('adds, lists, and removes remote workspaces', () => {
-    const added = federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-      name: 'Remote Main',
-      tags: ['prod', 'shared'],
-    });
-    expect(added.created).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, '.workgraph/federation.yaml'))).toBe(true);
-
-    const remotes = federation.listRemoteWorkspaces(workspacePath);
-    expect(remotes).toHaveLength(1);
-    expect(remotes[0].id).toBe('remote-main');
-    expect(remotes[0].name).toBe('Remote Main');
-    expect(remotes[0].tags).toEqual(['prod', 'shared']);
-
-    const removed = federation.removeRemoteWorkspace(workspacePath, 'remote-main');
-    expect(removed.changed).toBe(true);
-    expect(removed.removed?.id).toBe('remote-main');
-    expect(federation.listRemoteWorkspaces(workspacePath)).toHaveLength(0);
-  });
-});
-
-describe('thread federation links', () => {
-  it('links a local thread to a remote thread idempotently', () => {
-    createThread(workspacePath, 'Local Thread', 'Coordinate cross-workspace handoff', 'agent-local');
-    createThread(remoteWorkspacePath, 'Remote Thread', 'Remote dependency', 'agent-remote');
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-      name: 'Remote Main',
-    });
-
-    const first = federation.linkThreadToRemoteWorkspace(
-      workspacePath,
-      'threads/local-thread.md',
-      'remote-main',
-      'threads/remote-thread.md',
-      'agent-local',
-    );
-    expect(first.created).toBe(true);
-    expect(first.link).toBe('federation://remote-main/threads/remote-thread.md');
-    expect(readStringList(first.thread.fields.federation_links)).toContain(first.link);
-    expect(first.thread.body).toContain('## Federated links');
-
-    const second = federation.linkThreadToRemoteWorkspace(
-      workspacePath,
-      'threads/local-thread.md',
-      'remote-main',
-      'threads/remote-thread.md',
-      'agent-local',
-    );
-    expect(second.created).toBe(false);
-    expect(readStringList(second.thread.fields.federation_links)).toEqual([
-      'federation://remote-main/threads/remote-thread.md',
-    ]);
-  });
-});
-
-describe('federated search', () => {
-  it('returns local and remote matches', () => {
-    createThread(workspacePath, 'Auth rollout', 'Coordinate auth migration', 'agent-local');
-    createThread(remoteWorkspacePath, 'Auth dashboard', 'Build dashboard for auth metrics', 'agent-remote');
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-    });
-
-    const result = federation.searchFederated(workspacePath, 'auth', {
-      type: 'thread',
-    });
-    expect(result.errors).toEqual([]);
-    expect(result.results.some((entry) => entry.workspaceId === 'local')).toBe(true);
-    expect(result.results.some((entry) => entry.workspaceId === 'remote-main')).toBe(true);
-  });
-});
-
-describe('federation sync', () => {
-  it('captures per-remote sync status and updates sync timestamps', () => {
-    createThread(remoteWorkspacePath, 'Remote queue item', 'Process the remote queue', 'agent-remote');
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-    });
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'missing-remote',
-      path: path.join(remoteWorkspacePath, 'missing'),
-    });
-
-    const syncResult = federation.syncFederation(workspacePath, 'sync-agent');
-    expect(syncResult.actor).toBe('sync-agent');
-    expect(syncResult.remotes).toHaveLength(2);
-
-    const remoteOk = syncResult.remotes.find((entry) => entry.id === 'remote-main');
-    expect(remoteOk?.status).toBe('synced');
-    expect(remoteOk?.threadCount).toBe(1);
-
-    const remoteMissing = syncResult.remotes.find((entry) => entry.id === 'missing-remote');
-    expect(remoteMissing?.status).toBe('error');
-    expect(remoteMissing?.error).toContain('not found');
-
-    const refreshed = federation.listRemoteWorkspaces(workspacePath);
-    const refreshedRemote = refreshed.find((entry) => entry.id === 'remote-main');
-    expect(typeof refreshedRemote?.lastSyncedAt).toBe('string');
-    expect(refreshedRemote?.lastSyncStatus).toBe('synced');
-  });
-});
-
-function createWorkspace(prefix: string): string {
-  const target = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  const registry = loadRegistry(target);
-  saveRegistry(target, registry);
-  return target;
-}
-
-function readStringList(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value.map((entry) => String(entry));
-}
diff --git a/packages/kernel/src/federation.ts b/packages/kernel/src/federation.ts
deleted file mode 100644
index d2d2172..0000000
--- a/packages/kernel/src/federation.ts
+++ /dev/null
@@ -1,912 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import YAML from 'yaml';
-import {
-  DEFAULT_FEDERATION_CAPABILITIES,
-  FEDERATION_PROTOCOL_VERSION,
-  asRecord,
-  buildFederatedPrimitiveRef,
-  buildLegacyFederationLink,
-  deriveWorkspaceId,
-  normalizeCapabilitySet,
-  normalizeFederatedPrimitiveRef,
-  normalizeFederationWorkspaceIdentity,
-  normalizeOptionalString,
-  normalizePrimitivePath,
-  normalizeProtocolVersion,
-  normalizeTransportKind,
-  normalizeTrustLevel,
-  parseFederatedRef,
-  primitiveSlugFromPath,
-  primitiveTypeFromPath,
-  type FederatedPrimitiveRef,
-  type FederationTransportKind,
-  type FederationTrustLevel,
-  type FederationWorkspaceIdentity,
-} from './federation-helpers.js';
-import * as query from './query.js';
-import * as store from './store.js';
-import type { PrimitiveInstance } from './types.js';
-
-const FEDERATION_CONFIG_FILE = '.workgraph/federation.yaml';
-
-export interface RemoteWorkspaceRef {
-  id: string;
-  workspaceId: string;
-  name: string;
-  path: string;
-  enabled: boolean;
-  tags: string[];
-  protocolVersion: string;
-  capabilities: string[];
-  trustLevel: FederationTrustLevel;
-  transport: FederationTransportKind;
-  addedAt: string;
-  lastHandshakeAt?: string;
-  lastSyncedAt?: string;
-  lastSyncStatus?: 'synced' | 'error';
-  lastSyncError?: string;
-}
-
-export interface FederationConfig {
-  version: number;
-  updatedAt: string;
-  workspace: FederationWorkspaceIdentity;
-  remotes: RemoteWorkspaceRef[];
-}
-
-export interface AddRemoteWorkspaceInput {
-  id: string;
-  path: string;
-  name?: string;
-  enabled?: boolean;
-  tags?: string[];
-}
-
-export interface AddRemoteWorkspaceResult {
-  configPath: string;
-  created: boolean;
-  remote: RemoteWorkspaceRef;
-  config: FederationConfig;
-}
-
-export interface RemoveRemoteWorkspaceResult {
-  configPath: string;
-  changed: boolean;
-  removed?: RemoteWorkspaceRef;
-  config: FederationConfig;
-}
-
-export interface LinkFederatedThreadResult {
-  thread: PrimitiveInstance;
-  created: boolean;
-  link: string;
-  ref: FederatedPrimitiveRef;
-}
-
-export interface FederatedSearchOptions {
-  type?: string;
-  limit?: number;
-  remoteIds?: string[];
-  includeLocal?: boolean;
-}
-
-export interface FederatedSearchResultItem {
-  workspaceId: string;
-  workspacePath: string;
-  protocolVersion: string;
-  trustLevel: FederationTrustLevel;
-  stale: boolean;
-  instance: PrimitiveInstance;
-}
-
-export interface FederatedSearchError {
-  workspaceId: string;
-  message: string;
-}
-
-export interface FederatedSearchResult {
-  query: string;
-  results: FederatedSearchResultItem[];
-  errors: FederatedSearchError[];
-}
-
-export interface SyncFederationOptions {
-  remoteIds?: string[];
-  includeDisabled?: boolean;
-}
-
-export interface FederationSyncRemoteResult {
-  id: string;
-  workspaceId: string;
-  workspacePath: string;
-  enabled: boolean;
-  status: 'synced' | 'skipped' | 'error';
-  threadCount: number;
-  openThreadCount: number;
-  protocolVersion?: string;
-  capabilities?: string[];
-  trustLevel?: FederationTrustLevel;
-  syncedAt?: string;
-  error?: string;
-}
-
-export interface FederationSyncResult {
-  actor: string;
-  syncedAt: string;
-  configPath: string;
-  remotes: FederationSyncRemoteResult[];
-}
-
-export interface FederationHandshakeResult {
-  remote: RemoteWorkspaceRef;
-  identity: FederationWorkspaceIdentity;
-  compatible: boolean;
-  supportsRead: boolean;
-  supportsSearch: boolean;
-  error?: string;
-}
-
-export interface FederationResolveResult {
-  ref: FederatedPrimitiveRef;
-  source: 'local' | 'remote';
-  authority: 'local' | 'remote';
-  workspaceId: string;
-  workspacePath: string;
-  protocolVersion: string;
-  trustLevel: FederationTrustLevel;
-  stale: boolean;
-  capabilityCheck: {
-    supportsRead: boolean;
-    supportsSearch: boolean;
-  };
-  instance: PrimitiveInstance;
-  warning?: string;
-}
-
-export interface FederationStatusResult {
-  workspace: FederationWorkspaceIdentity;
-  configPath: string;
-  remotes: FederationHandshakeResult[];
-}
-
-export function federationConfigPath(workspacePath: string): string {
-  return path.join(workspacePath, FEDERATION_CONFIG_FILE);
-}
-
-export function loadFederationConfig(workspacePath: string): FederationConfig {
-  const configPath = federationConfigPath(workspacePath);
-  if (!fs.existsSync(configPath)) {
-    return defaultFederationConfig(workspacePath);
-  }
-  try {
-    const raw = fs.readFileSync(configPath, 'utf-8');
-    const parsed = YAML.parse(raw) as unknown;
-    return normalizeFederationConfig(workspacePath, parsed);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse federation config at ${configPath}: ${message}`);
-  }
-}
-
-export function saveFederationConfig(workspacePath: string, config: FederationConfig): FederationConfig {
-  const normalized = normalizeFederationConfig(workspacePath, config);
-  const configPath = federationConfigPath(workspacePath);
-  const configDir = path.dirname(configPath);
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-  fs.writeFileSync(configPath, YAML.stringify(normalized), 'utf-8');
-  return normalized;
-}
-
-export function ensureFederationConfig(workspacePath: string): FederationConfig {
-  const configPath = federationConfigPath(workspacePath);
-  if (fs.existsSync(configPath)) {
-    return loadFederationConfig(workspacePath);
-  }
-  const created = defaultFederationConfig(workspacePath);
-  return saveFederationConfig(workspacePath, created);
-}
-
-export function listRemoteWorkspaces(
-  workspacePath: string,
-  options: { includeDisabled?: boolean } = {},
-): RemoteWorkspaceRef[] {
-  const includeDisabled = options.includeDisabled !== false;
-  const config = loadFederationConfig(workspacePath);
-  return includeDisabled
-    ? config.remotes
-    : config.remotes.filter((remote) => remote.enabled);
-}
-
-export function federationStatus(workspacePath: string): FederationStatusResult {
-  const config = ensureFederationConfig(workspacePath);
-  return {
-    workspace: config.workspace,
-    configPath: federationConfigPath(workspacePath),
-    remotes: config.remotes.map((remote) => handshakeRemoteWorkspace(workspacePath, remote)),
-  };
-}
-
-export function addRemoteWorkspace(
-  workspacePath: string,
-  input: AddRemoteWorkspaceInput,
-): AddRemoteWorkspaceResult {
-  const workspaceId = normalizeIdentifier(input.id, 'id');
-  const remotePath = normalizeRemoteWorkspacePath(input.path);
-  const workspaceRoot = path.resolve(workspacePath).replace(/\\/g, '/');
-  if (remotePath === workspaceRoot) {
-    throw new Error('Remote workspace path cannot point to the current workspace.');
-  }
-
-  const config = ensureFederationConfig(workspacePath);
-  const remoteIdentity = readRemoteWorkspaceIdentity(remotePath);
-  const now = new Date().toISOString();
-  const index = config.remotes.findIndex((remote) => remote.id === workspaceId);
-  const previous = index >= 0 ? config.remotes[index] : undefined;
-  const nextTags = input.tags === undefined
-    ? previous?.tags ?? []
-    : normalizeTags(input.tags);
-  const remote: RemoteWorkspaceRef = {
-    id: workspaceId,
-    workspaceId: previous?.workspaceId ?? remoteIdentity.workspaceId,
-    name: normalizeOptionalString(input.name) ?? previous?.name ?? workspaceId,
-    path: remotePath,
-    enabled: input.enabled ?? previous?.enabled ?? true,
-    tags: nextTags,
-    protocolVersion: previous?.protocolVersion ?? remoteIdentity.protocolVersion,
-    capabilities: previous?.capabilities ?? remoteIdentity.capabilities,
-    trustLevel: previous?.trustLevel ?? 'read-only',
-    transport: previous?.transport ?? 'local-path',
-    addedAt: previous?.addedAt ?? now,
-    lastHandshakeAt: previous?.lastHandshakeAt ?? now,
-    lastSyncedAt: previous?.lastSyncedAt,
-    lastSyncStatus: previous?.lastSyncStatus,
-    lastSyncError: previous?.lastSyncError,
-  };
-
-  const remotes = [...config.remotes];
-  if (index >= 0) {
-    remotes[index] = remote;
-  } else {
-    remotes.push(remote);
-  }
-
-  const updated: FederationConfig = {
-    ...config,
-    updatedAt: now,
-    remotes: remotes.sort((a, b) => a.id.localeCompare(b.id)),
-  };
-  const saved = saveFederationConfig(workspacePath, updated);
-  return {
-    configPath: federationConfigPath(workspacePath),
-    created: index === -1,
-    remote,
-    config: saved,
-  };
-}
-
-export function removeRemoteWorkspace(
-  workspacePath: string,
-  workspaceId: string,
-): RemoveRemoteWorkspaceResult {
-  const remoteId = normalizeIdentifier(workspaceId, 'id');
-  const config = ensureFederationConfig(workspacePath);
-  const removed = config.remotes.find((remote) => remote.id === remoteId);
-  if (!removed) {
-    return {
-      configPath: federationConfigPath(workspacePath),
-      changed: false,
-      config,
-    };
-  }
-
-  const updated: FederationConfig = {
-    ...config,
-    updatedAt: new Date().toISOString(),
-    remotes: config.remotes.filter((remote) => remote.id !== remoteId),
-  };
-  const saved = saveFederationConfig(workspacePath, updated);
-  return {
-    configPath: federationConfigPath(workspacePath),
-    changed: true,
-    removed,
-    config: saved,
-  };
-}
-
-export function linkThreadToRemoteWorkspace(
-  workspacePath: string,
-  threadRef: string,
-  remoteWorkspaceId: string,
-  remoteThreadRef: string,
-  actor: string,
-): LinkFederatedThreadResult {
-  const remoteId = normalizeIdentifier(remoteWorkspaceId, 'remoteWorkspaceId');
-  const localThreadPath = normalizeThreadPathRef(threadRef, 'threadRef');
-  const targetThreadPath = normalizeThreadPathRef(remoteThreadRef, 'remoteThreadRef');
-  const config = ensureFederationConfig(workspacePath);
-  const remote = config.remotes.find((entry) => entry.id === remoteId);
-  if (!remote) {
-    throw new Error(`Unknown federated workspace "${remoteId}". Add it first with \`workgraph federation add\`.`);
-  }
-  if (!remote.enabled) {
-    throw new Error(`Federated workspace "${remoteId}" is disabled. Re-enable it before linking.`);
-  }
-
-  const localThread = store.read(workspacePath, localThreadPath);
-  if (!localThread || localThread.type !== 'thread') {
-    throw new Error(`Thread not found: ${localThreadPath}`);
-  }
-
-  if (!fs.existsSync(remote.path)) {
-    throw new Error(`Federated workspace path not found for "${remoteId}": ${remote.path}`);
-  }
-  const handshake = handshakeRemoteWorkspace(workspacePath, remote);
-  if (!handshake.compatible) {
-    throw new Error(handshake.error ?? `Remote workspace "${remoteId}" is not protocol-compatible.`);
-  }
-  if (!handshake.supportsRead) {
-    throw new Error(`Remote workspace "${remoteId}" does not advertise read capabilities for thread resolution.`);
-  }
-  const remoteThread = store.read(remote.path, targetThreadPath);
-  if (!remoteThread || remoteThread.type !== 'thread') {
-    throw new Error(`Remote thread not found in "${remoteId}": ${targetThreadPath}`);
-  }
-
-  const link = buildLegacyFederationLink(remote.id, targetThreadPath);
-  const ref = buildFederatedPrimitiveRef({
-    workspaceId: handshake.identity.workspaceId,
-    primitiveType: remoteThread.type,
-    primitivePath: targetThreadPath,
-    protocolVersion: handshake.identity.protocolVersion,
-    transport: remote.transport,
-    remoteAlias: remote.id,
-  });
-  const existingLinks = readStringArray(localThread.fields.federation_links);
-  const existingRefs = readFederatedRefs(localThread.fields.federation_refs);
-  const created = !existingLinks.includes(link);
-  const links = created ? [...existingLinks, link] : existingLinks;
-  const refs = created
-    ? [...existingRefs, ref]
-    : existingRefs.some((entry) => entry.workspaceId === ref.workspaceId && entry.primitivePath === ref.primitivePath)
-      ? existingRefs
-      : [...existingRefs, ref];
-  const body = created
-    ? appendThreadFederationLink(localThread.body, link, remote.name)
-    : undefined;
-
-  const updated = store.update(
-    workspacePath,
-    localThread.path,
-    {
-      federation_links: links,
-      federation_refs: refs,
-    },
-    body,
-    actor,
-    {
-      skipAuthorization: true,
-      action: 'federation.thread-link',
-      requiredCapabilities: ['thread:update', 'thread:manage'],
-    },
-  );
-  return {
-    thread: updated,
-    created,
-    link,
-    ref,
-  };
-}
-
-export function searchFederated(
-  workspacePath: string,
-  text: string,
-  options: FederatedSearchOptions = {},
-): FederatedSearchResult {
-  const queryText = String(text ?? '').trim();
-  if (!queryText) {
-    throw new Error('Federated search query cannot be empty.');
-  }
-  const selectedRemoteIds = new Set((options.remoteIds ?? []).map((value) => normalizeIdentifier(value, 'remoteId')));
-  const includeAllRemotes = selectedRemoteIds.size === 0;
-  const includeLocal = options.includeLocal !== false;
-  const remotes = listRemoteWorkspaces(workspacePath, { includeDisabled: false })
-    .filter((remote) => includeAllRemotes || selectedRemoteIds.has(remote.id));
-
-  const results: FederatedSearchResultItem[] = [];
-  const errors: FederatedSearchError[] = [];
-
-  if (includeLocal) {
-    const localResults = query.keywordSearch(workspacePath, queryText, {
-      type: options.type,
-    });
-    for (const instance of localResults) {
-      results.push({
-        workspaceId: 'local',
-        workspacePath: path.resolve(workspacePath).replace(/\\/g, '/'),
-        protocolVersion: loadFederationConfig(workspacePath).workspace.protocolVersion,
-        trustLevel: 'local',
-        stale: false,
-        instance,
-      });
-    }
-  }
-
-  for (const remote of remotes) {
-    try {
-      const handshake = handshakeRemoteWorkspace(workspacePath, remote);
-      if (!handshake.compatible) {
-        throw new Error(handshake.error ?? `Remote workspace ${remote.id} is not protocol-compatible.`);
-      }
-      if (!handshake.supportsSearch) {
-        throw new Error(`Remote workspace ${remote.id} does not support federated search.`);
-      }
-      if (!fs.existsSync(remote.path)) {
-        throw new Error(`Remote workspace path not found: ${remote.path}`);
-      }
-      const remoteResults = query.keywordSearch(remote.path, queryText, {
-        type: options.type,
-      });
-      for (const instance of remoteResults) {
-        results.push({
-          workspaceId: remote.id,
-          workspacePath: remote.path,
-          protocolVersion: handshake.identity.protocolVersion,
-          trustLevel: handshake.identity.trustLevel,
-          stale: isRemoteResultStale(remote, instance),
-          instance,
-        });
-      }
-    } catch (error) {
-      errors.push({
-        workspaceId: remote.id,
-        message: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-
-  const limitedResults = typeof options.limit === 'number' && options.limit >= 0
-    ? results.slice(0, options.limit)
-    : results;
-  return {
-    query: queryText,
-    results: limitedResults,
-    errors,
-  };
-}
-
-export function resolveFederatedRef(
-  workspacePath: string,
-  ref: string | FederatedPrimitiveRef,
-): FederationResolveResult {
-  const parsedRef = typeof ref === 'string'
-    ? parseFederatedRef(ref)
-    : normalizeFederatedPrimitiveRef(ref);
-  if (!parsedRef) {
-    throw new Error('Invalid federated ref. Expected legacy federation:// link or typed federated ref.');
-  }
-  const config = ensureFederationConfig(workspacePath);
-  const remote = config.remotes.find((entry) =>
-    entry.id === parsedRef.remoteAlias
-    || entry.id === parsedRef.workspaceId
-    || entry.workspaceId === parsedRef.workspaceId);
-  if (!remote) {
-    throw new Error(`Federated workspace not configured for ref workspace id "${parsedRef.workspaceId}".`);
-  }
-  const localWinner = findLocalAuthorityWinner(workspacePath, parsedRef);
-  if (localWinner) {
-    return {
-      ref: parsedRef,
-      source: 'local',
-      authority: 'local',
-      workspaceId: config.workspace.workspaceId,
-      workspacePath: path.resolve(workspacePath).replace(/\\/g, '/'),
-      protocolVersion: config.workspace.protocolVersion,
-      trustLevel: config.workspace.trustLevel,
-      stale: false,
-      capabilityCheck: {
-        supportsRead: true,
-        supportsSearch: true,
-      },
-      instance: localWinner,
-      warning: `Local primitive "${localWinner.path}" overrides remote authority for slug "${parsedRef.primitiveSlug}".`,
-    };
-  }
-  const handshake = handshakeRemoteWorkspace(workspacePath, remote);
-  if (!handshake.compatible) {
-    throw new Error(handshake.error ?? `Remote workspace "${remote.id}" is not protocol-compatible.`);
-  }
-  if (!handshake.supportsRead) {
-    throw new Error(`Remote workspace "${remote.id}" does not support federated ref resolution.`);
-  }
-  const remoteInstance = resolveRemotePrimitive(remote.path, parsedRef);
-  if (!remoteInstance) {
-    throw new Error(`Remote primitive not found for ${parsedRef.primitiveType}:${parsedRef.primitiveSlug} in "${remote.id}".`);
-  }
-  const stale = isRemoteResultStale(remote, remoteInstance);
-  return {
-    ref: parsedRef,
-    source: 'remote',
-    authority: 'remote',
-    workspaceId: handshake.identity.workspaceId,
-    workspacePath: remote.path,
-    protocolVersion: handshake.identity.protocolVersion,
-    trustLevel: handshake.identity.trustLevel,
-    stale,
-    capabilityCheck: {
-      supportsRead: handshake.supportsRead,
-      supportsSearch: handshake.supportsSearch,
-    },
-    instance: remoteInstance,
-    ...(stale ? { warning: `Remote primitive "${remoteInstance.path}" may be stale relative to last federation sync.` } : {}),
-  };
-}
-
-export function syncFederation(
-  workspacePath: string,
-  actor: string,
-  options: SyncFederationOptions = {},
-): FederationSyncResult {
-  const config = ensureFederationConfig(workspacePath);
-  const now = new Date().toISOString();
-  const selectedRemoteIds = new Set((options.remoteIds ?? []).map((value) => normalizeIdentifier(value, 'remoteId')));
-  const syncAll = selectedRemoteIds.size === 0;
-  const remotesResult: FederationSyncRemoteResult[] = [];
-  const remotes = config.remotes.map((remote) => {
-    const selected = syncAll || selectedRemoteIds.has(remote.id);
-    if (!selected) {
-      remotesResult.push({
-        id: remote.id,
-        workspaceId: remote.workspaceId,
-        workspacePath: remote.path,
-        enabled: remote.enabled,
-        status: 'skipped',
-        threadCount: 0,
-        openThreadCount: 0,
-        protocolVersion: remote.protocolVersion,
-        capabilities: remote.capabilities,
-        trustLevel: remote.trustLevel,
-      });
-      return remote;
-    }
-    if (!remote.enabled && options.includeDisabled !== true) {
-      remotesResult.push({
-        id: remote.id,
-        workspaceId: remote.workspaceId,
-        workspacePath: remote.path,
-        enabled: remote.enabled,
-        status: 'skipped',
-        threadCount: 0,
-        openThreadCount: 0,
-        protocolVersion: remote.protocolVersion,
-        capabilities: remote.capabilities,
-        trustLevel: remote.trustLevel,
-      });
-      return remote;
-    }
-
-    try {
-      if (!fs.existsSync(remote.path)) {
-        throw new Error(`Remote workspace path not found: ${remote.path}`);
-      }
-      const handshake = handshakeRemoteWorkspace(workspacePath, remote);
-      if (!handshake.compatible) {
-        throw new Error(handshake.error ?? `Remote workspace ${remote.id} is not protocol-compatible.`);
-      }
-      const threads = store.list(remote.path, 'thread');
-      const openThreadCount = threads.filter((thread) => String(thread.fields.status ?? '') === 'open').length;
-      remotesResult.push({
-        id: remote.id,
-        workspaceId: handshake.identity.workspaceId,
-        workspacePath: remote.path,
-        enabled: remote.enabled,
-        status: 'synced',
-        threadCount: threads.length,
-        openThreadCount,
-        protocolVersion: handshake.identity.protocolVersion,
-        capabilities: handshake.identity.capabilities,
-        trustLevel: handshake.identity.trustLevel,
-        syncedAt: now,
-      });
-      return {
-        ...remote,
-        workspaceId: handshake.identity.workspaceId,
-        protocolVersion: handshake.identity.protocolVersion,
-        capabilities: handshake.identity.capabilities,
-        trustLevel: handshake.identity.trustLevel,
-        lastHandshakeAt: now,
-        lastSyncedAt: now,
-        lastSyncStatus: 'synced' as const,
-        lastSyncError: undefined,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      remotesResult.push({
-        id: remote.id,
-        workspaceId: remote.workspaceId,
-        workspacePath: remote.path,
-        enabled: remote.enabled,
-        status: 'error',
-        threadCount: 0,
-        openThreadCount: 0,
-        protocolVersion: remote.protocolVersion,
-        capabilities: remote.capabilities,
-        trustLevel: remote.trustLevel,
-        syncedAt: now,
-        error: message,
-      });
-      return {
-        ...remote,
-        lastHandshakeAt: now,
-        lastSyncedAt: now,
-        lastSyncStatus: 'error' as const,
-        lastSyncError: message,
-      };
-    }
-  });
-
-  saveFederationConfig(workspacePath, {
-    ...config,
-    updatedAt: now,
-    remotes,
-  });
-  return {
-    actor: String(actor || 'system'),
-    syncedAt: now,
-    configPath: federationConfigPath(workspacePath),
-    remotes: remotesResult,
-  };
-}
-
-function defaultFederationConfig(workspacePath: string, now: string = new Date().toISOString()): FederationConfig {
-  return {
-    version: 2,
-    updatedAt: now,
-    workspace: normalizeFederationWorkspaceIdentity(undefined, workspacePath),
-    remotes: [],
-  };
-}
-
-function normalizeFederationConfig(workspacePath: string, value: unknown): FederationConfig {
-  const root = asRecord(value);
-  const now = new Date().toISOString();
-  const remotes = asArray(root.remotes)
-    .map((entry) => normalizeRemoteWorkspaceRef(entry))
-    .filter((entry): entry is RemoteWorkspaceRef => entry !== null)
-    .sort((a, b) => a.id.localeCompare(b.id));
-  const version = typeof root.version === 'number' && Number.isFinite(root.version)
-    ? Math.max(1, Math.floor(root.version))
-    : 2;
-  return {
-    version,
-    updatedAt: normalizeOptionalString(root.updatedAt) ?? now,
-    workspace: normalizeFederationWorkspaceIdentity(root.workspace, workspacePath),
-    remotes,
-  };
-}
-
-function normalizeRemoteWorkspaceRef(value: unknown): RemoteWorkspaceRef | null {
-  const raw = asRecord(value);
-  const id = normalizeOptionalString(raw.id);
-  const workspacePath = normalizeOptionalString(raw.path);
-  if (!id || !workspacePath) return null;
-  const now = new Date().toISOString();
-  return {
-    id: normalizeIdentifier(id, 'remote.id'),
-    workspaceId: normalizeOptionalString(raw.workspaceId) ?? normalizeOptionalString(raw.workspace_id) ?? normalizeIdentifier(id, 'remote.id'),
-    name: normalizeOptionalString(raw.name) ?? normalizeIdentifier(id, 'remote.id'),
-    path: normalizeRemoteWorkspacePath(workspacePath),
-    enabled: asBoolean(raw.enabled, true),
-    tags: normalizeTags(asArray(raw.tags).map((entry) => String(entry))),
-    protocolVersion: normalizeProtocolVersion(raw.protocolVersion ?? raw.protocol_version),
-    capabilities: normalizeCapabilitySet(raw.capabilities),
-    trustLevel: normalizeTrustLevel(raw.trustLevel ?? raw.trust_level, 'read-only'),
-    transport: normalizeTransportKind(raw.transport, 'local-path'),
-    addedAt: normalizeOptionalString(raw.addedAt) ?? now,
-    lastHandshakeAt: normalizeOptionalString(raw.lastHandshakeAt ?? raw.last_handshake_at),
-    lastSyncedAt: normalizeOptionalString(raw.lastSyncedAt),
-    lastSyncStatus: normalizeSyncStatus(raw.lastSyncStatus),
-    lastSyncError: normalizeOptionalString(raw.lastSyncError),
-  };
-}
-
-function normalizeSyncStatus(value: unknown): 'synced' | 'error' | undefined {
-  const normalized = normalizeOptionalString(value)?.toLowerCase();
-  if (normalized === 'synced' || normalized === 'error') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function normalizeIdentifier(value: unknown, label: string): string {
-  const normalized = String(value ?? '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  if (!normalized) {
-    throw new Error(`Invalid ${label}. Expected a non-empty identifier.`);
-  }
-  return normalized;
-}
-
-function normalizeRemoteWorkspacePath(value: unknown): string {
-  const normalized = normalizeOptionalString(value);
-  if (!normalized) {
-    throw new Error('Invalid remote workspace path. Expected a non-empty path.');
-  }
-  return path.resolve(normalized).replace(/\\/g, '/');
-}
-
-function normalizeThreadPathRef(value: unknown, label: string): string {
-  const normalized = normalizeMarkdownRef(value);
-  if (!normalized) {
-    throw new Error(`Invalid ${label}. Expected a markdown thread reference.`);
-  }
-  if (!normalized.startsWith('threads/')) {
-    throw new Error(`Invalid ${label}. Expected a thread ref under "threads/". Received "${normalized}".`);
-  }
-  return normalized;
-}
-
-function normalizeMarkdownRef(value: unknown): string {
-  const raw = String(value ?? '').trim();
-  if (!raw) return '';
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]')
-    ? raw.slice(2, -2)
-    : raw;
-  const primary = unwrapped.split('|')[0].trim().split('#')[0].trim();
-  if (!primary) return '';
-  return primary.endsWith('.md') ? primary : `${primary}.md`;
-}
-
-function normalizeTags(values: unknown): string[] {
-  if (!Array.isArray(values)) return [];
-  const seen = new Set<string>();
-  for (const value of values) {
-    const tag = String(value ?? '').trim();
-    if (!tag) continue;
-    seen.add(tag);
-  }
-  return [...seen].sort((a, b) => a.localeCompare(b));
-}
-
-function appendThreadFederationLink(body: string, link: string, remoteName: string): string {
-  const currentBody = String(body ?? '');
-  if (currentBody.includes(link)) return currentBody;
-  const sectionTitle = '## Federated links';
-  const line = `- ${remoteName}: ${link}`;
-  if (currentBody.includes(sectionTitle)) {
-    return `${currentBody.trimEnd()}\n${line}\n`;
-  }
-  const trimmed = currentBody.trimEnd();
-  return trimmed
-    ? `${trimmed}\n\n${sectionTitle}\n\n${line}\n`
-    : `${sectionTitle}\n\n${line}\n`;
-}
-
-function readStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((entry) => String(entry ?? '').trim())
-    .filter((entry) => entry.length > 0);
-}
-
-function readFederatedRefs(value: unknown): FederatedPrimitiveRef[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((entry) => normalizeFederatedPrimitiveRef(entry))
-    .filter((entry): entry is FederatedPrimitiveRef => entry !== null);
-}
-
-function readRemoteWorkspaceIdentity(workspacePath: string): FederationWorkspaceIdentity {
-  const configPath = federationConfigPath(workspacePath);
-  if (!fs.existsSync(configPath)) {
-    return {
-      workspaceId: deriveWorkspaceId(workspacePath),
-      protocolVersion: FEDERATION_PROTOCOL_VERSION,
-      capabilities: [...DEFAULT_FEDERATION_CAPABILITIES],
-      trustLevel: 'read-only',
-    };
-  }
-  try {
-    const raw = YAML.parse(fs.readFileSync(configPath, 'utf-8')) as unknown;
-    const root = asRecord(raw);
-    return normalizeFederationWorkspaceIdentity(root.workspace, workspacePath, 'read-only');
-  } catch {
-    return {
-      workspaceId: deriveWorkspaceId(workspacePath),
-      protocolVersion: FEDERATION_PROTOCOL_VERSION,
-      capabilities: [...DEFAULT_FEDERATION_CAPABILITIES],
-      trustLevel: 'read-only',
-    };
-  }
-}
-
-function handshakeRemoteWorkspace(
-  workspacePath: string,
-  remote: RemoteWorkspaceRef,
-): FederationHandshakeResult {
-  const local = ensureFederationConfig(workspacePath).workspace;
-  if (!fs.existsSync(remote.path)) {
-    return {
-      remote,
-      identity: {
-        workspaceId: remote.workspaceId,
-        protocolVersion: remote.protocolVersion,
-        capabilities: remote.capabilities,
-        trustLevel: remote.trustLevel,
-      },
-      compatible: false,
-      supportsRead: false,
-      supportsSearch: false,
-      error: `Remote workspace path not found: ${remote.path}`,
-    };
-  }
-  const identity = readRemoteWorkspaceIdentity(remote.path);
-  const compatible = identity.protocolVersion === local.protocolVersion;
-  const supportsRead = identity.capabilities.includes('resolve-ref') && (
-    identity.capabilities.includes('read-primitive') || identity.capabilities.includes('read-thread')
-  );
-  const supportsSearch = identity.capabilities.includes('search');
-  return {
-    remote,
-    identity,
-    compatible,
-    supportsRead,
-    supportsSearch,
-    ...(compatible ? {} : {
-      error: `Protocol mismatch for remote "${remote.id}": local=${local.protocolVersion} remote=${identity.protocolVersion}.`,
-    }),
-  };
-}
-
-function resolveRemotePrimitive(
-  workspacePath: string,
-  ref: FederatedPrimitiveRef,
-): PrimitiveInstance | null {
-  if (ref.primitivePath) {
-    const direct = store.read(workspacePath, ref.primitivePath);
-    if (direct) return direct;
-  }
-  const instances = store.list(workspacePath, ref.primitiveType);
-  return instances.find((instance) => primitiveSlugFromPath(instance.path) === ref.primitiveSlug) ?? null;
-}
-
-function findLocalAuthorityWinner(
-  workspacePath: string,
-  ref: FederatedPrimitiveRef,
-): PrimitiveInstance | null {
-  return resolveRemotePrimitive(workspacePath, {
-    ...ref,
-    workspaceId: 'local',
-  });
-}
-
-function isRemoteResultStale(
-  remote: RemoteWorkspaceRef,
-  instance: PrimitiveInstance,
-): boolean {
-  if (!remote.lastSyncedAt) return true;
-  const syncedAt = Date.parse(remote.lastSyncedAt);
-  const updatedAt = Date.parse(String(instance.fields.updated ?? instance.fields.created ?? ''));
-  if (!Number.isFinite(syncedAt) || !Number.isFinite(updatedAt)) return true;
-  return updatedAt > syncedAt;
-}
-
-function asArray(value: unknown): unknown[] {
-  return Array.isArray(value) ? value : [];
-}
-
-function asBoolean(value: unknown, fallback: boolean): boolean {
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'number') return value !== 0;
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true' || normalized === '1' || normalized === 'yes') return true;
-    if (normalized === 'false' || normalized === '0' || normalized === 'no') return false;
-  }
-  return fallback;
-}
diff --git a/packages/kernel/src/gate.test.ts b/packages/kernel/src/gate.test.ts
index eb04723..f3f5276 100644
--- a/packages/kernel/src/gate.test.ts
+++ b/packages/kernel/src/gate.test.ts
@@ -5,7 +5,6 @@ import os from 'node:os';
 import * as registry from './registry.js';
 import * as store from './store.js';
 import * as thread from './thread.js';
-import * as dispatch from './dispatch.js';
 import * as gate from './gate.js';
 
 let workspacePath: string;
@@ -107,7 +106,7 @@ describe('quality gates', () => {
       'agent-dev',
     );
 
-    expect(() => dispatch.claimThread(workspacePath, createdThread.path, 'agent-worker'))
+    expect(() => thread.claim(workspacePath, createdThread.path, 'agent-worker'))
       .toThrow('Quality gates blocked claim');
 
     store.update(
@@ -119,9 +118,9 @@ describe('quality gates', () => {
       undefined,
       'agent-dev',
     );
-    const claimed = dispatch.claimThread(workspacePath, createdThread.path, 'agent-worker');
-    expect(claimed.thread.fields.status).toBe('active');
-    expect(claimed.thread.fields.owner).toBe('agent-worker');
-    expect(claimed.gateCheck.allowed).toBe(true);
+    const claimed = thread.claim(workspacePath, createdThread.path, 'agent-worker');
+    expect(claimed.fields.status).toBe('active');
+    expect(claimed.fields.owner).toBe('agent-worker');
+    expect(gate.checkThreadGates(workspacePath, createdThread.path).allowed).toBe(true);
   });
 });
diff --git a/packages/kernel/src/graph-board.test.ts b/packages/kernel/src/graph-board.test.ts
deleted file mode 100644
index b2a44d7..0000000
--- a/packages/kernel/src/graph-board.test.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as thread from './thread.js';
-import * as board from './board.js';
-import * as graph from './graph.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-graph-board-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('graph index and board generation', () => {
-  it('generates obsidian kanban-compatible board markdown', () => {
-    thread.createThread(workspacePath, 'Backlog item', 'todo', 'agent-a');
-    thread.createThread(workspacePath, 'Active item', 'in progress', 'agent-a');
-    thread.claim(workspacePath, 'threads/active-item.md', 'agent-a');
-    thread.createThread(workspacePath, 'Done item', 'done', 'agent-a');
-    thread.claim(workspacePath, 'threads/done-item.md', 'agent-a');
-    thread.done(workspacePath, 'threads/done-item.md', 'agent-a', 'done https://github.com/versatly/workgraph/pull/23');
-
-    const result = board.generateKanbanBoard(workspacePath, {
-      outputPath: 'ops/Kanban.md',
-    });
-    const boardFile = path.join(workspacePath, 'ops/Kanban.md');
-    expect(fs.existsSync(boardFile)).toBe(true);
-    expect(result.outputPath).toBe('ops/Kanban.md');
-
-    const content = fs.readFileSync(boardFile, 'utf-8');
-    expect(content).toContain('kanban-plugin: board');
-    expect(content).toContain('## Backlog');
-    expect(content).toContain('## In Progress');
-    expect(content).toContain('## Done');
-    expect(content).toContain('%% kanban:settings');
-  });
-
-  it('indexes wiki-links and reports hygiene findings', () => {
-    fs.writeFileSync(
-      path.join(workspacePath, 'alpha.md'),
-      '# Alpha\n\nLinks: [[beta#Section]] [[missing-note|Missing Note]]\n',
-      'utf-8',
-    );
-    fs.writeFileSync(
-      path.join(workspacePath, 'beta.md'),
-      '# Beta\n\nBacklink [[alpha]]\n',
-      'utf-8',
-    );
-    fs.writeFileSync(
-      path.join(workspacePath, 'orphan.md'),
-      '# Orphan\n\nNo links.\n',
-      'utf-8',
-    );
-
-    const index = graph.refreshWikiLinkGraphIndex(workspacePath);
-    expect(index.nodes).toContain('alpha.md');
-    expect(index.edges.length).toBeGreaterThanOrEqual(3);
-    expect(index.brokenLinks.some((entry) => entry.to === 'missing-note.md')).toBe(true);
-
-    const hygiene = graph.graphHygieneReport(workspacePath);
-    expect(hygiene.orphans).toContain('orphan.md');
-    expect(hygiene.brokenLinkCount).toBeGreaterThan(0);
-
-    const neighborhood = graph.graphNeighborhood(workspacePath, 'alpha.md');
-    expect(neighborhood.exists).toBe(true);
-    expect(neighborhood.outgoing).toContain('beta.md');
-    expect(neighborhood.outgoing).toContain('missing-note.md');
-    expect(neighborhood.outgoing).not.toContain('beta#Section.md');
-    expect(neighborhood.incoming).toContain('beta.md');
-  });
-});
diff --git a/packages/kernel/src/graph/hygiene.ts b/packages/kernel/src/graph/hygiene.ts
deleted file mode 100644
index efbaebf..0000000
--- a/packages/kernel/src/graph/hygiene.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { graphHygieneReport } from '../graph.js';
diff --git a/packages/kernel/src/graph/wiki-index.ts b/packages/kernel/src/graph/wiki-index.ts
deleted file mode 100644
index 14410a3..0000000
--- a/packages/kernel/src/graph/wiki-index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { buildWikiLinkGraph, readWikiLinkGraphIndex, refreshWikiLinkGraphIndex } from '../graph.js';
diff --git a/packages/kernel/src/index.ts b/packages/kernel/src/index.ts
index a806c23..79835a9 100644
--- a/packages/kernel/src/index.ts
+++ b/packages/kernel/src/index.ts
@@ -1,86 +1,31 @@
 export * from './types.js';
-export * as registry from './registry.js';
-export * as ledger from './ledger.js';
+export * as agent from './agent.js';
 export * as auth from './auth.js';
+export * as claimLease from './claim-lease.js';
+export * as contextGraphContract from './context-graph-contract.js';
+export * as conversation from './conversation.js';
+export * as errors from './errors.js';
+export * as evidence from './evidence.js';
+export * as fsReliability from './fs-reliability.js';
+export * as gate from './gate.js';
+export * as graph from './graph.js';
+export * as ledger from './ledger.js';
+export * as lens from './lens.js';
+export * as orientation from './orientation.js';
+export * as policy from './policy.js';
+export * as query from './query.js';
+export * as registry from './registry.js';
+export * as serverConfig from './server-config.js';
+export * as starterKit from './starter-kit.js';
 export * as store from './store.js';
 export * as thread from './thread.js';
+export * as threadAudit from './thread-audit.js';
 export * as threadContext from './thread-context.js';
-export * as mission from './mission.js';
-export * as missionOrchestrator from './mission-orchestrator.js';
-export * as capability from './capability.js';
+export * as validation from './validation.js';
+export * as workspace from './workspace.js';
 export {
   inviteThreadParticipant,
   joinThread,
   leaveThread,
   listThreadParticipants,
 } from './thread.js';
-export * as conversation from './conversation.js';
-export * as workspace from './workspace.js';
-export * as serverConfig from './server-config.js';
-export * as starterKit from './starter-kit.js';
-export * as query from './query.js';
-export * as orientation from './orientation.js';
-export * as lens from './lens.js';
-export * as graph from './graph.js';
-export * as claimLease from './claim-lease.js';
-export * as evidence from './evidence.js';
-export * as gate from './gate.js';
-export * as threadAudit from './thread-audit.js';
-export * as reconciler from './reconciler.js';
-export * as dispatch from './dispatch.js';
-export * as contextGraphContract from './context-graph-contract.js';
-export * as runtimeAdapterContracts from './runtime-adapter-contracts.js';
-export * as runtimeAdapterRegistry from './runtime-adapter-registry.js';
-export * as errors from './errors.js';
-export * as validation from './validation.js';
-export * as fsReliability from './fs-reliability.js';
-export * as adapterClaudeCode from './adapter-claude-code.js';
-export * as adapterCursorCloud from './adapter-cursor-cloud.js';
-export * as adapterHttpWebhook from './adapter-http-webhook.js';
-export * as adapterShellWorker from './adapter-shell-worker.js';
-export * as cursorBridge from './cursor-bridge.js';
-export * from './runtime-adapter-contracts.js';
-export * from './adapter-shell-worker.js';
-export * from './agent-self-assembly.js';
-export * from './skill.js';
-export * as policy from './policy.js';
-export * as bases from './bases.js';
-export * as cron from './cron.js';
-export * as triggerEngine from './trigger-engine.js';
-export * as trigger from './trigger.js';
-export * as autonomy from './autonomy.js';
-export * as autonomyDaemon from './autonomy-daemon.js';
-export * as safety from './safety.js';
-export * as commandCenter from './command-center.js';
-export * as board from './board.js';
-export * as agent from './agent.js';
-export * as agentSelfAssembly from './agent-self-assembly.js';
-export * as intake from './intake.js';
-export * as onboard from './onboard.js';
-export * as skill from './skill.js';
-export * as integration from './integration.js';
-export * from './integration-core.js';
-export * as searchQmdAdapter from './search-qmd-adapter.js';
-export * as swarm from './swarm.js';
-export * as clawdapus from './clawdapus.js';
-export * as mcpEvents from './mcp-events.js';
-export * from './cursor-bridge.js';
-export * as diagnostics from './diagnostics/index.js';
-export * from './context-graph-contract.js';
-export * as queryEngine from './query/engine.js';
-export * as queryFilters from './query/filters.js';
-export * as orientationStatus from './orientation/status.js';
-export * as orientationBrief from './orientation/brief.js';
-export * as orientationCheckpoint from './orientation/checkpoint.js';
-export * as orientationLens from './orientation/lens.js';
-export * as keywordSearch from './search/keyword.js';
-export * as wikiIndex from './graph/wiki-index.js';
-export * as graphHygiene from './graph/hygiene.js';
-export * as schemaValidation from './validation/schema.js';
-export * from './errors.js';
-export * as storageAdapter from './storage-adapter.js';
-export * as environment from './environment.js';
-export * as exportImport from './export-import.js';
-export * as federation from './federation.js';
-export * as transport from './transport/index.js';
-export * as projections from './projections/index.js';
diff --git a/packages/kernel/src/integration-core.test.ts b/packages/kernel/src/integration-core.test.ts
deleted file mode 100644
index 406e4b7..0000000
--- a/packages/kernel/src/integration-core.test.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { loadRegistry, saveRegistry } from './registry.js';
-import {
-  fetchSkillMarkdownFromUrl,
-  installSkillIntegration,
-  type SkillIntegrationProvider,
-} from './integration-core.js';
-import { loadSkill } from './skill.js';
-
-let workspacePath: string;
-
-const provider: SkillIntegrationProvider = {
-  id: 'provider-x',
-  defaultTitle: 'Provider Skill',
-  defaultSourceUrl: 'https://example.com/skill.md',
-  distribution: 'remote',
-  defaultTags: ['provider', 'docs'],
-  userAgent: 'workgraph-test-agent',
-};
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-integration-core-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('integration-core module', () => {
-  it('installs a skill integration with merged tags and metadata', async () => {
-    const result = await installSkillIntegration(workspacePath, provider, {
-      actor: 'agent-integrator',
-      owner: 'team-knowledge',
-      tags: ['custom', 'docs'],
-      fetchSkillMarkdown: async () => '# Imported Skill\n\nUse carefully.',
-    });
-
-    expect(result.provider).toBe('provider-x');
-    expect(result.replacedExisting).toBe(false);
-    expect(result.skill.path).toBe('skills/provider-skill/SKILL.md');
-    expect(result.sourceUrl).toBe(provider.defaultSourceUrl);
-    expect(result.skill.fields.owner).toBe('team-knowledge');
-    expect(result.skill.fields.distribution).toBe('remote');
-    expect(result.skill.fields.tags).toEqual(
-      expect.arrayContaining(['optional-integration', 'provider', 'docs', 'custom']),
-    );
-  });
-
-  it('requires a non-empty actor', async () => {
-    await expect(
-      installSkillIntegration(workspacePath, provider, {
-        actor: '   ',
-        fetchSkillMarkdown: async () => '# content',
-      }),
-    ).rejects.toThrow('requires a non-empty actor');
-  });
-
-  it('rejects install when skill already exists unless force is enabled', async () => {
-    await installSkillIntegration(workspacePath, provider, {
-      actor: 'agent-integrator',
-      fetchSkillMarkdown: async () => '# First content',
-    });
-
-    await expect(
-      installSkillIntegration(workspacePath, provider, {
-        actor: 'agent-integrator',
-        fetchSkillMarkdown: async () => '# Second content',
-      }),
-    ).rejects.toThrow('already exists');
-  });
-
-  it('replaces existing skill when force is true', async () => {
-    await installSkillIntegration(workspacePath, provider, {
-      actor: 'agent-integrator',
-      fetchSkillMarkdown: async () => '# Old version',
-    });
-
-    const refreshed = await installSkillIntegration(workspacePath, provider, {
-      actor: 'agent-integrator',
-      force: true,
-      fetchSkillMarkdown: async () => '# New version',
-    });
-
-    expect(refreshed.replacedExisting).toBe(true);
-    const loaded = loadSkill(workspacePath, 'provider-skill');
-    expect(loaded.body).toContain('New version');
-  });
-
-  it('fails when downloaded markdown is empty', async () => {
-    await expect(
-      installSkillIntegration(workspacePath, provider, {
-        actor: 'agent-integrator',
-        fetchSkillMarkdown: async () => '   \n\n',
-      }),
-    ).rejects.toThrow('is empty');
-  });
-
-  it('fetches skill markdown from URL and forwards custom user-agent', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      new Response('# Remote skill body', {
-        status: 200,
-        statusText: 'OK',
-      }),
-    );
-
-    const markdown = await fetchSkillMarkdownFromUrl(
-      'https://example.com/remote-skill.md',
-      'custom-agent/1.0',
-    );
-
-    expect(markdown).toBe('# Remote skill body');
-    expect(fetchSpy).toHaveBeenCalledWith(
-      'https://example.com/remote-skill.md',
-      expect.objectContaining({
-        headers: {
-          'user-agent': 'custom-agent/1.0',
-        },
-      }),
-    );
-  });
-
-  it('wraps network and HTTP failures during skill download', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch');
-    fetchSpy.mockRejectedValueOnce(new Error('socket hang up'));
-    await expect(
-      fetchSkillMarkdownFromUrl('https://example.com/fail-network.md'),
-    ).rejects.toThrow('Failed to download skill from https://example.com/fail-network.md: socket hang up');
-
-    fetchSpy.mockResolvedValueOnce(
-      new Response('not found', {
-        status: 404,
-        statusText: 'Not Found',
-      }),
-    );
-    await expect(
-      fetchSkillMarkdownFromUrl('https://example.com/fail-http.md'),
-    ).rejects.toThrow('HTTP 404 Not Found');
-  });
-});
diff --git a/packages/kernel/src/integration-core.ts b/packages/kernel/src/integration-core.ts
deleted file mode 100644
index ba4ee66..0000000
--- a/packages/kernel/src/integration-core.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-import { loadSkill, writeSkill, type WriteSkillOptions } from './skill.js';
-import type { PrimitiveInstance } from './types.js';
-
-export interface SkillIntegrationProvider {
-  id: string;
-  defaultTitle: string;
-  defaultSourceUrl: string;
-  distribution: string;
-  defaultTags: string[];
-  userAgent?: string;
-}
-
-export interface InstallSkillIntegrationOptions {
-  actor: string;
-  owner?: string;
-  title?: string;
-  sourceUrl?: string;
-  force?: boolean;
-  status?: WriteSkillOptions['status'];
-  tags?: string[];
-  fetchSkillMarkdown?: (sourceUrl: string) => Promise<string>;
-}
-
-export interface InstallSkillIntegrationResult {
-  provider: string;
-  skill: PrimitiveInstance;
-  sourceUrl: string;
-  importedAt: string;
-  replacedExisting: boolean;
-}
-
-export async function installSkillIntegration(
-  workspacePath: string,
-  provider: SkillIntegrationProvider,
-  options: InstallSkillIntegrationOptions,
-): Promise<InstallSkillIntegrationResult> {
-  const actor = options.actor.trim();
-  if (!actor) {
-    throw new Error(`${provider.id} integration requires a non-empty actor.`);
-  }
-
-  const title = options.title?.trim() || provider.defaultTitle;
-  const sourceUrl = options.sourceUrl?.trim() || provider.defaultSourceUrl;
-  const existing = loadSkillIfExists(workspacePath, title);
-  if (existing && !options.force) {
-    throw new Error(
-      `Skill "${title}" already exists at ${existing.path}. Use --force to refresh it from source.`,
-    );
-  }
-
-  const fetchSkillMarkdown =
-    options.fetchSkillMarkdown ??
-    ((url: string) => fetchSkillMarkdownFromUrl(url, provider.userAgent));
-  const markdown = await fetchSkillMarkdown(sourceUrl);
-  if (!markdown.trim()) {
-    throw new Error(`Downloaded ${provider.id} skill from ${sourceUrl} is empty.`);
-  }
-
-  const skill = writeSkill(workspacePath, title, markdown, actor, {
-    owner: options.owner ?? actor,
-    status: options.status,
-    distribution: provider.distribution,
-    tags: mergeTags(provider.defaultTags, options.tags),
-  });
-
-  return {
-    provider: provider.id,
-    skill,
-    sourceUrl,
-    importedAt: new Date().toISOString(),
-    replacedExisting: existing !== null,
-  };
-}
-
-export async function fetchSkillMarkdownFromUrl(
-  sourceUrl: string,
-  userAgent = '@versatly/workgraph optional-integration',
-): Promise<string> {
-  let response;
-  try {
-    response = await fetch(sourceUrl, {
-      headers: {
-        'user-agent': userAgent,
-      },
-    });
-  } catch (error) {
-    throw new Error(
-      `Failed to download skill from ${sourceUrl}: ${errorMessage(error)}`,
-    );
-  }
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to download skill from ${sourceUrl}: HTTP ${response.status} ${response.statusText}`,
-    );
-  }
-  return response.text();
-}
-
-function loadSkillIfExists(workspacePath: string, skillRef: string): PrimitiveInstance | null {
-  try {
-    return loadSkill(workspacePath, skillRef);
-  } catch (error) {
-    const message = errorMessage(error);
-    if (message.startsWith('Skill not found:')) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-function mergeTags(defaultTags: string[], tags: string[] | undefined): string[] {
-  const merged = new Set<string>(['optional-integration']);
-  for (const tag of defaultTags) {
-    const normalized = tag.trim();
-    if (normalized) merged.add(normalized);
-  }
-  for (const tag of tags ?? []) {
-    const normalized = tag.trim();
-    if (normalized) merged.add(normalized);
-  }
-  return [...merged];
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
diff --git a/packages/kernel/src/integration.test.ts b/packages/kernel/src/integration.test.ts
deleted file mode 100644
index 89e01b3..0000000
--- a/packages/kernel/src/integration.test.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { installIntegration, listIntegrations } from './integration.js';
-import { loadSkill } from './skill.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-integration-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('integration registry', () => {
-  it('lists supported optional integrations', () => {
-    const integrations = listIntegrations();
-    expect(integrations).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          id: 'clawdapus',
-          defaultTitle: 'clawdapus',
-        }),
-      ]),
-    );
-  });
-
-  it('installs clawdapus through generic integration dispatcher', async () => {
-    const result = await installIntegration(workspacePath, 'clawdapus', {
-      actor: 'agent-ops',
-      fetchSkillMarkdown: async () => '# Imported Through Registry',
-    });
-
-    expect(result.provider).toBe('clawdapus');
-    expect(result.skill.path).toBe('skills/clawdapus/SKILL.md');
-    expect(loadSkill(workspacePath, 'clawdapus').body).toContain('Imported Through Registry');
-  });
-
-  it('throws a clear error for unknown integrations', async () => {
-    await expect(
-      installIntegration(workspacePath, 'unknown-provider', {
-        actor: 'agent-ops',
-      }),
-    ).rejects.toThrow('Unknown integration "unknown-provider"');
-  });
-});
diff --git a/packages/kernel/src/integration.ts b/packages/kernel/src/integration.ts
deleted file mode 100644
index e7fba28..0000000
--- a/packages/kernel/src/integration.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import {
-  CLAWDAPUS_INTEGRATION_PROVIDER,
-  installClawdapusSkill,
-} from './clawdapus.js';
-import type {
-  InstallSkillIntegrationOptions,
-  InstallSkillIntegrationResult,
-  SkillIntegrationProvider,
-} from './integration-core.js';
-
-export interface IntegrationDescriptor {
-  id: string;
-  description: string;
-  defaultTitle: string;
-  defaultSourceUrl: string;
-}
-
-interface IntegrationRegistration {
-  provider: SkillIntegrationProvider;
-  description: string;
-  install: (
-    workspacePath: string,
-    options: InstallSkillIntegrationOptions,
-  ) => Promise<InstallSkillIntegrationResult>;
-}
-
-const INTEGRATIONS: Record<string, IntegrationRegistration> = {
-  clawdapus: {
-    provider: CLAWDAPUS_INTEGRATION_PROVIDER,
-    description: 'Infrastructure-layer governance skill import for AI agent containers.',
-    install: installClawdapusSkill,
-  },
-};
-
-export function listIntegrations(): IntegrationDescriptor[] {
-  return Object.values(INTEGRATIONS).map((integration) => ({
-    id: integration.provider.id,
-    description: integration.description,
-    defaultTitle: integration.provider.defaultTitle,
-    defaultSourceUrl: integration.provider.defaultSourceUrl,
-  }));
-}
-
-export async function installIntegration(
-  workspacePath: string,
-  integrationId: string,
-  options: InstallSkillIntegrationOptions,
-): Promise<InstallSkillIntegrationResult> {
-  const integration = INTEGRATIONS[integrationId.trim().toLowerCase()];
-  if (!integration) {
-    throw new Error(
-      `Unknown integration "${integrationId}". Supported integrations: ${supportedIntegrationList()}.`,
-    );
-  }
-  return integration.install(workspacePath, options);
-}
-
-function supportedIntegrationList(): string {
-  return Object.keys(INTEGRATIONS).sort().join(', ');
-}
diff --git a/packages/kernel/src/lens.test.ts b/packages/kernel/src/lens.test.ts
index 6a24131..7547c76 100644
--- a/packages/kernel/src/lens.test.ts
+++ b/packages/kernel/src/lens.test.ts
@@ -5,7 +5,6 @@ import path from 'node:path';
 import { loadRegistry, saveRegistry } from './registry.js';
 import * as thread from './thread.js';
 import * as store from './store.js';
-import * as dispatch from './dispatch.js';
 import * as lens from './lens.js';
 import * as ledger from './ledger.js';
 
@@ -98,29 +97,6 @@ describe('context lenses', () => {
     thread.claim(workspacePath, 'threads/finish-auth-rollout.md', 'agent-risk');
     thread.done(workspacePath, 'threads/finish-auth-rollout.md', 'agent-risk', 'Auth shipped https://github.com/versatly/workgraph/pull/22');
 
-    const failedRun = dispatch.createRun(workspacePath, {
-      actor: 'agent-ops',
-      objective: 'Run deployment checks',
-      adapter: 'cursor-cloud',
-      idempotencyKey: 'lens-failed-run',
-    });
-    dispatch.markRun(workspacePath, failedRun.id, 'agent-ops', 'running');
-    dispatch.markRun(workspacePath, failedRun.id, 'agent-ops', 'failed', {
-      error: 'Smoke test failed',
-    });
-
-    store.create(
-      workspacePath,
-      'incident',
-      {
-        title: 'Customer login outage',
-        severity: 'sev1',
-        status: 'active',
-        tags: ['customer'],
-      },
-      'Major login outage in production.',
-      'system',
-    );
     store.create(
       workspacePath,
       'decision',
@@ -140,8 +116,7 @@ describe('context lenses', () => {
       limit: 10,
     });
     expect(teamRisk.metrics.blockedHighPriority).toBe(1);
-    expect(teamRisk.metrics.failedRuns).toBe(1);
-    expect(teamRisk.metrics.activeHighSeverityIncidents).toBe(1);
+    expect(teamRisk.metrics.activeHighSeverityIncidents).toBe(0);
 
     const customerHealth = lens.generateContextLens(workspacePath, 'customer-health', {
       actor: 'agent-ops',
@@ -149,7 +124,7 @@ describe('context lenses', () => {
     });
     expect(customerHealth.metrics.activeCustomerThreads).toBeGreaterThanOrEqual(1);
     expect(customerHealth.metrics.blockedCustomerThreads).toBe(1);
-    expect(customerHealth.metrics.customerIncidents).toBe(1);
+    expect(customerHealth.metrics.customerIncidents).toBe(0);
 
     const execBrief = lens.generateContextLens(workspacePath, 'exec-brief', {
       actor: 'agent-ops',
diff --git a/packages/kernel/src/lens.ts b/packages/kernel/src/lens.ts
index a98c8e4..8723e88 100644
--- a/packages/kernel/src/lens.ts
+++ b/packages/kernel/src/lens.ts
@@ -4,7 +4,6 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import * as dispatch from './dispatch.js';
 import * as ledger from './ledger.js';
 import * as store from './store.js';
 import * as thread from './thread.js';
@@ -180,9 +179,6 @@ function buildTeamRiskLens(workspacePath: string, options: NormalizedLensOptions
     .filter((entry) => String(entry.instance.fields.status ?? '') === 'active')
     .filter((entry) => isStale(entry.instance, staleCutoffMs))
     .slice(0, options.limit);
-  const failedRuns = dispatch.listRuns(workspacePath, { status: 'failed' })
-    .filter((run) => parseTimestamp(run.updatedAt) >= lookbackCutoffMs)
-    .slice(0, options.limit);
   const highSeverityIncidents = store.list(workspacePath, 'incident')
     .filter((incident) => String(incident.fields.status ?? '') === 'active')
     .filter((incident) => HIGH_RISK_SEVERITIES.has(normalizeSeverity(incident.fields.severity)))
@@ -202,11 +198,6 @@ function buildTeamRiskLens(workspacePath: string, options: NormalizedLensOptions
         owner: entry.owner,
       })),
     },
-    {
-      id: 'failed_runs',
-      title: `Failed Runs (${options.lookbackHours}h window)`,
-      items: failedRuns.map(toRunItem),
-    },
     {
       id: 'active_high_severity_incidents',
       title: 'Active High-Severity Incidents',
@@ -220,7 +211,6 @@ function buildTeamRiskLens(workspacePath: string, options: NormalizedLensOptions
     metrics: {
       blockedHighPriority: blockedHighPriority.length,
       staleActiveClaims: staleActiveClaims.length,
-      failedRuns: failedRuns.length,
       activeHighSeverityIncidents: highSeverityIncidents.length,
     },
     sections,
@@ -304,9 +294,6 @@ function buildExecBriefLens(workspacePath: string, options: NormalizedLensOption
     .filter((instance) => HIGH_RISK_PRIORITIES.has(normalizePriority(instance.fields.priority)))
     .sort(compareThreadsByPriorityThenUpdated)
     .slice(0, options.limit);
-  const failedRuns = dispatch.listRuns(workspacePath, { status: 'failed' })
-    .filter((run) => parseTimestamp(run.updatedAt) >= lookbackCutoffMs)
-    .slice(0, options.limit);
   const decisions = store.list(workspacePath, 'decision')
     .filter((instance) => ['proposed', 'approved', 'active'].includes(String(instance.fields.status ?? '')))
     .filter((instance) => parseTimestamp(instance.fields.updated ?? instance.fields.date) >= lookbackCutoffMs)
@@ -326,10 +313,7 @@ function buildExecBriefLens(workspacePath: string, options: NormalizedLensOption
     {
       id: 'key_risks',
       title: 'Key Risks',
-      items: [
-        ...blockedHighPriority.map((instance) => toThreadItem(instance, nowMs)),
-        ...failedRuns.map(toRunItem),
-      ].slice(0, options.limit),
+      items: blockedHighPriority.map((instance) => toThreadItem(instance, nowMs)),
     },
     {
       id: 'recent_decisions',
@@ -350,7 +334,7 @@ function buildExecBriefLens(workspacePath: string, options: NormalizedLensOption
     metrics: {
       topPriorities: topPriorities.length,
       momentumDone: momentum.length,
-      risks: blockedHighPriority.length + failedRuns.length,
+      risks: blockedHighPriority.length,
       decisions: decisions.length,
     },
     sections,
diff --git a/packages/kernel/src/mission-orchestrator.test.ts b/packages/kernel/src/mission-orchestrator.test.ts
deleted file mode 100644
index b025150..0000000
--- a/packages/kernel/src/mission-orchestrator.test.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as dispatch from './dispatch.js';
-import * as mission from './mission.js';
-import * as missionOrchestrator from './mission-orchestrator.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as thread from './thread.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mission-orchestrator-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('mission orchestrator', () => {
-  it('dispatches features, validates milestones, and completes mission sequentially', () => {
-    const created = mission.createMission(
-      workspacePath,
-      'Launch payments service',
-      'Ship payments service to production',
-      'agent-pm',
-    );
-    mission.planMission(workspacePath, created.path, {
-      milestones: [
-        {
-          id: 'ms-api',
-          title: 'API readiness',
-          features: ['Build API', 'Add auth'],
-          validation: {
-            strategy: 'automated',
-            criteria: ['pnpm run test'],
-          },
-        },
-        {
-          id: 'ms-deploy',
-          title: 'Deployment',
-          deps: ['ms-api'],
-          features: ['Deploy service'],
-          validation: {
-            strategy: 'manual',
-            criteria: ['Smoke test endpoint'],
-          },
-        },
-      ],
-    }, 'agent-pm');
-    mission.approveMission(workspacePath, created.path, 'agent-pm');
-    mission.startMission(workspacePath, created.path, 'agent-pm');
-
-    const firstCycle = missionOrchestrator.runMissionOrchestratorCycle(workspacePath, created.path);
-    expect(firstCycle.dispatchedRuns.length).toBe(2);
-    const allRunsAfterFirst = dispatch.listRuns(workspacePath);
-    expect(allRunsAfterFirst.length).toBe(2);
-
-    completeThread(workspacePath, 'threads/mission-launch-payments-service/build-api.md', 'agent-pm');
-    completeThread(workspacePath, 'threads/mission-launch-payments-service/add-auth.md', 'agent-pm');
-
-    const validationCycleOne = missionOrchestrator.runMissionOrchestratorCycle(workspacePath, created.path);
-    expect(validationCycleOne.validationRunId).toBeDefined();
-    const validationRunOneId = validationCycleOne.validationRunId!;
-    dispatch.markRun(workspacePath, validationRunOneId, 'mission-orchestrator', 'running');
-    dispatch.markRun(workspacePath, validationRunOneId, 'mission-orchestrator', 'succeeded');
-
-    const passFirstMilestone = missionOrchestrator.runMissionOrchestratorCycle(workspacePath, created.path);
-    expect(passFirstMilestone.actions.some((action) => action.startsWith('milestone-passed:ms-api'))).toBe(true);
-
-    const dispatchSecondMilestone = missionOrchestrator.runMissionOrchestratorCycle(workspacePath, created.path);
-    expect(dispatchSecondMilestone.dispatchedRuns.length).toBe(1);
-    completeThread(workspacePath, 'threads/mission-launch-payments-service/deploy-service.md', 'agent-pm');
-
-    const validationCycleTwo = missionOrchestrator.runMissionOrchestratorCycle(workspacePath, created.path);
-    expect(validationCycleTwo.validationRunId).toBeDefined();
-    dispatch.markRun(workspacePath, validationCycleTwo.validationRunId!, 'mission-orchestrator', 'running');
-    dispatch.markRun(workspacePath, validationCycleTwo.validationRunId!, 'mission-orchestrator', 'succeeded');
-
-    const completionCycle = missionOrchestrator.runMissionOrchestratorCycle(workspacePath, created.path);
-    expect(completionCycle.missionStatus).toBe('completed');
-
-    const finalMission = mission.missionStatus(workspacePath, created.path);
-    expect(finalMission.fields.status).toBe('completed');
-    const progress = mission.missionProgress(workspacePath, created.path);
-    expect(progress.passedMilestones).toBe(2);
-    expect(progress.doneFeatures).toBe(3);
-  });
-});
-
-function completeThread(workspacePath: string, threadPath: string, actor: string): void {
-  thread.claim(workspacePath, threadPath, actor);
-  thread.done(
-    workspacePath,
-    threadPath,
-    actor,
-    `Completed ${threadPath} https://github.com/versatly/workgraph/pull/mission`,
-  );
-}
diff --git a/packages/kernel/src/mission-orchestrator.ts b/packages/kernel/src/mission-orchestrator.ts
deleted file mode 100644
index 30b1cc6..0000000
--- a/packages/kernel/src/mission-orchestrator.ts
+++ /dev/null
@@ -1,554 +0,0 @@
-/**
- * Mission orchestrator — sequential milestone dispatch and validation.
- */
-
-import * as dispatch from './dispatch.js';
-import * as ledger from './ledger.js';
-import * as mission from './mission.js';
-import * as store from './store.js';
-import type {
-  Milestone,
-  MilestoneValidationPlan,
-  Mission,
-  MissionStatus,
-  PrimitiveInstance,
-} from './types.js';
-
-export interface MissionOrchestratorCycleResult {
-  missionPath: string;
-  missionStatus: MissionStatus;
-  actions: string[];
-  dispatchedRuns: string[];
-  validationRunId?: string;
-  changed: boolean;
-}
-
-export function runMissionOrchestratorCycle(
-  workspacePath: string,
-  missionRef: string,
-  actor: string = 'mission-orchestrator',
-): MissionOrchestratorCycleResult {
-  const missionInstance = mission.missionStatus(workspacePath, missionRef);
-  const state = asMission(missionInstance);
-  const milestones = state.milestones.map(cloneMilestone);
-  const now = new Date().toISOString();
-  const actions: string[] = [];
-  const dispatchedRuns: string[] = [];
-  let changed = false;
-  let validationRunId: string | undefined;
-
-  if (state.status !== 'active' && state.status !== 'validating') {
-    return {
-      missionPath: missionInstance.path,
-      missionStatus: state.status,
-      actions: ['skipped:mission-not-active'],
-      dispatchedRuns,
-      changed: false,
-    };
-  }
-
-  if (state.status === 'active') {
-    let activeMilestone = milestones.find((milestone) => milestone.status === 'active');
-    if (!activeMilestone) {
-      const next = pickNextReadyMilestone(milestones);
-      if (next) {
-        next.status = 'active';
-        next.started_at = next.started_at ?? now;
-        activeMilestone = next;
-        actions.push(`milestone-activated:${next.id}`);
-        appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-milestone-activated', {
-          milestone_id: next.id,
-        });
-        changed = true;
-      }
-    }
-
-    if (activeMilestone) {
-      for (const featurePath of activeMilestone.features) {
-        const featureThread = store.read(workspacePath, featurePath);
-        if (!featureThread || featureThread.type !== 'thread') continue;
-        const featureStatus = String(featureThread.fields.status ?? '');
-        if (featureStatus !== 'open') continue;
-        const adapter = pickAdapterForFeature(featureThread);
-        if (!shouldDispatchFeatureRun(workspacePath, featureThread)) continue;
-        const run = dispatch.createRun(workspacePath, {
-          actor,
-          adapter,
-          objective: `Mission ${state.mid} / ${activeMilestone.title}: ${String(featureThread.fields.title ?? featureThread.path)}`,
-          context: {
-            missionId: state.mid,
-            missionPath: missionInstance.path,
-            milestoneId: activeMilestone.id,
-            featureThread: featureThread.path,
-          },
-        });
-        dispatchedRuns.push(run.id);
-        actions.push(`feature-dispatched:${featureThread.path}`);
-        incrementMissionRunStats(state, run.adapter);
-        changed = true;
-        appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-feature-dispatched', {
-          milestone_id: activeMilestone.id,
-          feature_thread: featureThread.path,
-          run_id: run.id,
-          adapter: run.adapter,
-        });
-        store.update(
-          workspacePath,
-          featureThread.path,
-          {
-            mission_dispatch_last_run_id: run.id,
-            mission_dispatch_last_adapter: run.adapter,
-            mission_dispatch_last_at: now,
-          },
-          undefined,
-          actor,
-          {
-            skipAuthorization: true,
-            action: 'mission.orchestrator.feature.store',
-            requiredCapabilities: ['thread:update', 'thread:manage', 'dispatch:run', 'mission:manage'],
-          },
-        );
-      }
-
-      if (areMilestoneFeaturesDone(workspacePath, activeMilestone)) {
-        activeMilestone.status = 'validating';
-        activeMilestone.validation = ensureMilestoneValidation(activeMilestone.validation);
-        state.status = 'validating';
-        actions.push(`milestone-validating:${activeMilestone.id}`);
-        appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-milestone-validating', {
-          milestone_id: activeMilestone.id,
-        });
-        const run = ensureValidationDispatch(
-          workspacePath,
-          missionInstance,
-          state,
-          activeMilestone,
-          actor,
-        );
-        validationRunId = run.id;
-        changed = true;
-      }
-    } else if (milestones.every((milestone) => milestone.status === 'passed')) {
-      state.status = 'completed';
-      state.completed_at = state.completed_at ?? now;
-      actions.push('mission-completed');
-      appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-completed', {});
-      changed = true;
-    }
-  }
-
-  if (state.status === 'validating') {
-    const validatingMilestone = milestones.find((milestone) => milestone.status === 'validating');
-    if (!validatingMilestone) {
-      state.status = 'active';
-      changed = true;
-      actions.push('no-validating-milestone-reset-to-active');
-    } else {
-      validatingMilestone.validation = ensureMilestoneValidation(validatingMilestone.validation);
-      if (!validatingMilestone.validation.run_id) {
-        const run = ensureValidationDispatch(workspacePath, missionInstance, state, validatingMilestone, actor);
-        validationRunId = run.id;
-        changed = true;
-      } else {
-        const validationRun = dispatch.status(workspacePath, validatingMilestone.validation.run_id);
-        validatingMilestone.validation.run_status = validationRun.status;
-        validationRunId = validationRun.id;
-        changed = true;
-        if (validationRun.status === 'succeeded') {
-          validatingMilestone.status = 'passed';
-          validatingMilestone.completed_at = now;
-          validatingMilestone.validation.validated_at = now;
-          state.status = 'active';
-          actions.push(`milestone-passed:${validatingMilestone.id}`);
-          appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-milestone-complete', {
-            milestone_id: validatingMilestone.id,
-            run_id: validationRun.id,
-          });
-          const nextMilestone = pickNextReadyMilestone(milestones);
-          if (nextMilestone) {
-            nextMilestone.status = 'active';
-            nextMilestone.started_at = nextMilestone.started_at ?? now;
-            actions.push(`milestone-activated:${nextMilestone.id}`);
-          } else if (milestones.every((milestone) => milestone.status === 'passed')) {
-            state.status = 'completed';
-            state.completed_at = state.completed_at ?? now;
-            actions.push('mission-completed');
-            appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-completed', {});
-          }
-        } else if (validationRun.status === 'failed' || validationRun.status === 'cancelled') {
-          validatingMilestone.status = 'failed';
-          validatingMilestone.failed_at = now;
-          state.status = 'failed';
-          actions.push(`milestone-failed:${validatingMilestone.id}`);
-          const fixThread = createValidationFixThread(workspacePath, missionInstance, validatingMilestone, actor);
-          actions.push(`fix-thread-created:${fixThread.path}`);
-          appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-validation-failed', {
-            milestone_id: validatingMilestone.id,
-            run_id: validationRun.id,
-            fix_thread: fixThread.path,
-          });
-        }
-      }
-    }
-  }
-
-  if (changed) {
-    store.update(
-      workspacePath,
-      missionInstance.path,
-      {
-        status: state.status,
-        milestones: sanitizeForYaml(milestones),
-        total_runs: state.total_runs,
-        total_cost_usd: state.total_cost_usd,
-        runs_by_adapter: sanitizeForYaml(state.runs_by_adapter),
-        ...(state.completed_at ? { completed_at: state.completed_at } : {}),
-      },
-      undefined,
-      actor,
-      {
-        skipAuthorization: true,
-        action: 'mission.orchestrator.store',
-        requiredCapabilities: ['mission:update', 'mission:manage', 'dispatch:run'],
-      },
-    );
-  }
-
-  return {
-    missionPath: missionInstance.path,
-    missionStatus: state.status,
-    actions,
-    dispatchedRuns,
-    validationRunId,
-    changed,
-  };
-}
-
-export function runMissionOrchestratorForActiveMissions(
-  workspacePath: string,
-  actor: string = 'mission-orchestrator',
-): MissionOrchestratorCycleResult[] {
-  return mission
-    .listMissions(workspacePath)
-    .filter((entry) => {
-      const status = String(entry.fields.status ?? '');
-      return status === 'active' || status === 'validating';
-    })
-    .map((entry) => runMissionOrchestratorCycle(workspacePath, entry.path, actor));
-}
-
-function shouldDispatchFeatureRun(workspacePath: string, featureThread: PrimitiveInstance): boolean {
-  const previousRunId = asOptionalString(featureThread.fields.mission_dispatch_last_run_id);
-  if (!previousRunId) return true;
-  try {
-    const previousRun = dispatch.status(workspacePath, previousRunId);
-    return previousRun.status === 'failed' || previousRun.status === 'cancelled';
-  } catch {
-    return true;
-  }
-}
-
-function ensureValidationDispatch(
-  workspacePath: string,
-  missionInstance: PrimitiveInstance,
-  missionState: Mission,
-  milestone: Milestone,
-  actor: string,
-) {
-  milestone.validation = ensureMilestoneValidation(milestone.validation);
-  const run = dispatch.createRun(workspacePath, {
-    actor,
-    adapter: 'cursor-cloud',
-    objective: `Validate milestone "${milestone.title}": ${milestone.validation.criteria.join('; ') || 'No explicit criteria provided.'}`,
-    context: {
-      missionId: missionState.mid,
-      missionPath: missionInstance.path,
-      milestoneId: milestone.id,
-      isValidation: true,
-    },
-  });
-  milestone.validation.run_id = run.id;
-  milestone.validation.run_status = run.status;
-  incrementMissionRunStats(missionState, run.adapter);
-  appendMissionEvent(workspacePath, actor, missionInstance.path, 'mission-validation-dispatched', {
-    milestone_id: milestone.id,
-    run_id: run.id,
-  });
-  return run;
-}
-
-function createValidationFixThread(
-  workspacePath: string,
-  missionInstance: PrimitiveInstance,
-  milestone: Milestone,
-  actor: string,
-): PrimitiveInstance {
-  const missionId = String(missionInstance.fields.mid ?? 'mission');
-  const fixSlug = `${normalizeSlug(milestone.id)}-validation-fix`;
-  const pathOverride = `threads/mission-${missionId}/fix-${fixSlug}.md`;
-  const existing = store.read(workspacePath, pathOverride);
-  if (existing) return existing;
-  return store.create(
-    workspacePath,
-    'thread',
-    {
-      tid: `fix-${normalizeSlug(milestone.id)}`,
-      title: `Fix validation failures: ${milestone.title}`,
-      goal: `Resolve validation failures for milestone "${milestone.title}" in mission ${missionInstance.path}.`,
-      status: 'open',
-      priority: 'high',
-      deps: [],
-      parent: missionInstance.path,
-      context_refs: [missionInstance.path],
-      tags: ['fix', 'validation-failure', 'mission-feature'],
-    },
-    `## Goal\n\nResolve failing validation outcomes for milestone "${milestone.title}".\n`,
-    actor,
-    {
-      pathOverride,
-      skipAuthorization: true,
-      action: 'mission.orchestrator.fix-thread.store',
-      requiredCapabilities: ['thread:create', 'thread:manage', 'mission:manage'],
-    },
-  );
-}
-
-function pickAdapterForFeature(featureThread: PrimitiveInstance): string {
-  const tags = asStringArray(featureThread.fields.tags).map((tag) => tag.toLowerCase());
-  if (tags.includes('claude-code') || tags.includes('claude')) return 'claude-code';
-  if (tags.includes('manual')) return 'manual';
-  if (tags.includes('cursor') || tags.includes('cursor-cloud')) return 'cursor-cloud';
-  return 'cursor-cloud';
-}
-
-function areMilestoneFeaturesDone(workspacePath: string, milestone: Milestone): boolean {
-  if (milestone.features.length === 0) return false;
-  return milestone.features.every((threadPath) => {
-    const thread = store.read(workspacePath, threadPath);
-    return !!thread && String(thread.fields.status ?? '') === 'done';
-  });
-}
-
-function pickNextReadyMilestone(milestones: Milestone[]): Milestone | undefined {
-  return milestones.find((milestone) => {
-    if (milestone.status !== 'open') return false;
-    const deps = milestone.deps ?? [];
-    return deps.every((depId) => milestones.some((candidate) => candidate.id === depId && candidate.status === 'passed'));
-  });
-}
-
-function incrementMissionRunStats(state: Mission, adapter: string): void {
-  state.total_runs = (state.total_runs ?? 0) + 1;
-  state.runs_by_adapter = state.runs_by_adapter ?? {};
-  state.runs_by_adapter[adapter] = (state.runs_by_adapter[adapter] ?? 0) + 1;
-}
-
-function ensureMilestoneValidation(validation: MilestoneValidationPlan | undefined): MilestoneValidationPlan {
-  return {
-    strategy: validation?.strategy ?? 'automated',
-    criteria: validation?.criteria ?? [],
-    ...(validation?.run_id ? { run_id: validation.run_id } : {}),
-    ...(validation?.run_status ? { run_status: validation.run_status } : {}),
-    ...(validation?.validated_at ? { validated_at: validation.validated_at } : {}),
-  };
-}
-
-function appendMissionEvent(
-  workspacePath: string,
-  actor: string,
-  missionPath: string,
-  eventType: string,
-  details: Record<string, unknown>,
-): void {
-  ledger.append(workspacePath, actor, 'update', missionPath, 'mission', {
-    mission_event: eventType,
-    ...details,
-  });
-}
-
-function asMission(instance: PrimitiveInstance): Mission {
-  const milestones = normalizeMilestones(instance.fields.milestones);
-  return {
-    mid: String(instance.fields.mid ?? instance.path),
-    title: String(instance.fields.title ?? instance.path),
-    description: asOptionalString(instance.fields.description),
-    status: normalizeMissionStatus(instance.fields.status),
-    priority: normalizePriority(instance.fields.priority),
-    owner: asOptionalString(instance.fields.owner),
-    project: asOptionalString(instance.fields.project),
-    space: asOptionalString(instance.fields.space),
-    plan: {
-      goal: asOptionalString((instance.fields.plan as Record<string, unknown> | undefined)?.goal) ?? '',
-      constraints: asStringArray((instance.fields.plan as Record<string, unknown> | undefined)?.constraints),
-      estimated_runs: asNumber((instance.fields.plan as Record<string, unknown> | undefined)?.estimated_runs),
-      estimated_cost_usd: asNullableNumber((instance.fields.plan as Record<string, unknown> | undefined)?.estimated_cost_usd),
-    },
-    milestones,
-    started_at: asOptionalString(instance.fields.started_at),
-    completed_at: asOptionalString(instance.fields.completed_at),
-    total_runs: asNumber(instance.fields.total_runs) ?? 0,
-    total_cost_usd: asNumber(instance.fields.total_cost_usd) ?? 0,
-    runs_by_adapter: asStringNumberRecord(instance.fields.runs_by_adapter),
-    tags: asStringArray(instance.fields.tags),
-    created: asOptionalString(instance.fields.created) ?? new Date(0).toISOString(),
-    updated: asOptionalString(instance.fields.updated) ?? new Date(0).toISOString(),
-  };
-}
-
-function normalizeMilestones(value: unknown): Milestone[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((entry, index) => normalizeMilestone(entry, index))
-    .filter((entry): entry is Milestone => !!entry);
-}
-
-function normalizeMilestone(value: unknown, index: number): Milestone | null {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-  const record = value as Record<string, unknown>;
-  const id = asOptionalString(record.id) ?? `ms-${index + 1}`;
-  const title = asOptionalString(record.title) ?? id;
-  return {
-    id,
-    title,
-    status: normalizeMilestoneStatus(record.status),
-    deps: dedupeStrings(asStringArray(record.deps)),
-    features: dedupeStrings(asStringArray(record.features)),
-    validation: normalizeValidation(record.validation),
-    ...(asOptionalString(record.started_at) ? { started_at: asOptionalString(record.started_at) } : {}),
-    ...(asOptionalString(record.completed_at) ? { completed_at: asOptionalString(record.completed_at) } : {}),
-    ...(asOptionalString(record.failed_at) ? { failed_at: asOptionalString(record.failed_at) } : {}),
-  };
-}
-
-function normalizeValidation(value: unknown): MilestoneValidationPlan | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const record = value as Record<string, unknown>;
-  return {
-    strategy: normalizeValidationStrategy(record.strategy),
-    criteria: asStringArray(record.criteria),
-    ...(asOptionalString(record.run_id) ? { run_id: asOptionalString(record.run_id) } : {}),
-    ...(asOptionalString(record.run_status)
-      ? { run_status: asOptionalString(record.run_status) as MilestoneValidationPlan['run_status'] }
-      : {}),
-    ...(asOptionalString(record.validated_at) ? { validated_at: asOptionalString(record.validated_at) } : {}),
-  };
-}
-
-function sanitizeForYaml<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => sanitizeForYaml(entry))
-      .filter((entry) => entry !== undefined) as unknown as T;
-  }
-  if (!value || typeof value !== 'object') return value;
-  const output: Record<string, unknown> = {};
-  for (const [key, innerValue] of Object.entries(value as Record<string, unknown>)) {
-    if (innerValue === undefined) continue;
-    const sanitized = sanitizeForYaml(innerValue);
-    if (sanitized === undefined) continue;
-    output[key] = sanitized;
-  }
-  return output as T;
-}
-
-function cloneMilestone(milestone: Milestone): Milestone {
-  return {
-    ...milestone,
-    deps: [...(milestone.deps ?? [])],
-    features: [...milestone.features],
-    validation: milestone.validation ? { ...milestone.validation } : undefined,
-  };
-}
-
-function normalizeMissionStatus(value: unknown): MissionStatus {
-  const normalized = String(value ?? 'planning').trim().toLowerCase();
-  if (
-    normalized === 'planning'
-    || normalized === 'approved'
-    || normalized === 'active'
-    || normalized === 'validating'
-    || normalized === 'completed'
-    || normalized === 'failed'
-  ) {
-    return normalized;
-  }
-  return 'planning';
-}
-
-function normalizeMilestoneStatus(value: unknown): Milestone['status'] {
-  const normalized = String(value ?? 'open').trim().toLowerCase();
-  if (
-    normalized === 'open'
-    || normalized === 'active'
-    || normalized === 'validating'
-    || normalized === 'passed'
-    || normalized === 'failed'
-  ) {
-    return normalized;
-  }
-  return 'open';
-}
-
-function normalizePriority(value: unknown): Mission['priority'] {
-  const normalized = String(value ?? 'medium').trim().toLowerCase();
-  if (normalized === 'urgent' || normalized === 'high' || normalized === 'medium' || normalized === 'low') {
-    return normalized;
-  }
-  return 'medium';
-}
-
-function normalizeValidationStrategy(value: unknown): MilestoneValidationPlan['strategy'] {
-  const normalized = String(value ?? 'automated').trim().toLowerCase();
-  if (normalized === 'automated' || normalized === 'manual' || normalized === 'hybrid') {
-    return normalized;
-  }
-  return 'automated';
-}
-
-function asOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((entry) => asOptionalString(entry))
-    .filter((entry): entry is string => !!entry);
-}
-
-function asNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function asNullableNumber(value: unknown): number | null | undefined {
-  if (value === null) return null;
-  return asNumber(value);
-}
-
-function asStringNumberRecord(value: unknown): Record<string, number> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  const output: Record<string, number> = {};
-  for (const [key, rawValue] of Object.entries(value as Record<string, unknown>)) {
-    output[key] = asNumber(rawValue) ?? 0;
-  }
-  return output;
-}
-
-function dedupeStrings(values: string[]): string[] {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}
-
-function normalizeSlug(value: string): string {
-  return String(value ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 80);
-}
diff --git a/packages/kernel/src/mission.test.ts b/packages/kernel/src/mission.test.ts
deleted file mode 100644
index 642c9b6..0000000
--- a/packages/kernel/src/mission.test.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as mission from './mission.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as store from './store.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mission-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('mission lifecycle', () => {
-  it('creates, plans, approves, and starts a mission', () => {
-    const created = mission.createMission(
-      workspacePath,
-      'Deploy cloud backend',
-      'Ship backend to production',
-      'agent-planner',
-      {
-        constraints: ['Use zero downtime deploys'],
-        tags: ['deployment'],
-      },
-    );
-    expect(created.path).toBe('missions/deploy-cloud-backend.md');
-    expect(created.fields.status).toBe('planning');
-
-    const planned = mission.planMission(workspacePath, created.path, {
-      goal: 'Production-ready backend rollout',
-      constraints: ['No downtime', 'Database migrations must be reversible'],
-      estimated_runs: 6,
-      milestones: [
-        {
-          id: 'ms-1',
-          title: 'Core API',
-          features: [
-            'Database migrations',
-            { title: 'Authentication hardening', goal: 'Harden authentication flows' },
-          ],
-          validation: {
-            strategy: 'automated',
-            criteria: ['pnpm run test', 'pnpm run build'],
-          },
-        },
-        {
-          id: 'ms-2',
-          title: 'Deploy and monitor',
-          deps: ['ms-1'],
-          features: ['Production deployment'],
-          validation: {
-            strategy: 'manual',
-            criteria: ['Smoke test production endpoint'],
-          },
-        },
-      ],
-    }, 'agent-planner');
-    expect(Array.isArray(planned.fields.milestones)).toBe(true);
-    expect((planned.fields.milestones as unknown[]).length).toBe(2);
-
-    const missionInstance = store.read(workspacePath, created.path);
-    expect(missionInstance).not.toBeNull();
-    const milestones = missionInstance?.fields.milestones as Array<{ features: string[] }>;
-    expect(milestones[0]?.features.length).toBe(2);
-    expect(milestones[1]?.features.length).toBe(1);
-
-    const featureThreads = store.list(workspacePath, 'thread');
-    expect(featureThreads.length).toBe(3);
-    for (const featureThread of featureThreads) {
-      expect(String(featureThread.fields.parent)).toBe(created.path);
-      expect(featureThread.path.startsWith('threads/mission-deploy-cloud-backend/')).toBe(true);
-    }
-
-    const approved = mission.approveMission(workspacePath, created.path, 'agent-planner');
-    expect(approved.fields.status).toBe('approved');
-
-    const started = mission.startMission(workspacePath, created.path, 'agent-planner');
-    expect(started.fields.status).toBe('active');
-    const startedMilestones = started.fields.milestones as Array<{ id: string; status: string }>;
-    expect(startedMilestones.find((entry) => entry.id === 'ms-1')?.status).toBe('active');
-  });
-
-  it('reports mission progress and supports interventions', () => {
-    const created = mission.createMission(
-      workspacePath,
-      'Release app v2',
-      'Ship v2 safely',
-      'agent-release',
-    );
-    mission.planMission(workspacePath, created.path, {
-      milestones: [
-        {
-          id: 'ms-core',
-          title: 'Core',
-          features: ['API', 'Auth'],
-        },
-      ],
-    }, 'agent-release');
-
-    const before = mission.missionProgress(workspacePath, created.path);
-    expect(before.totalMilestones).toBe(1);
-    expect(before.totalFeatures).toBe(2);
-    expect(before.doneFeatures).toBe(0);
-
-    const intervened = mission.interveneMission(workspacePath, created.path, {
-      reason: 'Scope narrowed after incident review.',
-      skipFeature: {
-        milestoneId: 'ms-core',
-        threadPath: 'threads/mission-release-app-v2/auth.md',
-      },
-      appendMilestones: [
-        {
-          id: 'ms-monitoring',
-          title: 'Monitoring',
-          deps: ['ms-core'],
-          features: ['Dashboards'],
-        },
-      ],
-      setPriority: 'high',
-    }, 'agent-release');
-    expect(intervened.fields.priority).toBe('high');
-
-    const after = mission.missionProgress(workspacePath, created.path);
-    expect(after.totalMilestones).toBe(2);
-    expect(after.totalFeatures).toBe(2);
-    const missionInstance = mission.missionStatus(workspacePath, created.path);
-    const milestones = missionInstance.fields.milestones as Array<{ id: string; features: string[] }>;
-    expect(milestones.find((entry) => entry.id === 'ms-core')?.features).toEqual([
-      'threads/mission-release-app-v2/api.md',
-    ]);
-  });
-
-  it('normalizes completed mission milestones on the read path', () => {
-    const created = mission.createMission(
-      workspacePath,
-      'Research A2A',
-      'Document the integration shape',
-      'agent-research',
-    );
-    mission.planMission(workspacePath, created.path, {
-      milestones: [
-        {
-          id: 'ms-1',
-          title: 'Research',
-          features: ['Read spec'],
-          validation: {
-            strategy: 'automated',
-            criteria: ['write summary'],
-          },
-        },
-        {
-          id: 'ms-2',
-          title: 'Design',
-          features: ['Design bridge'],
-        },
-      ],
-    }, 'agent-research');
-
-    const rawMission = store.read(workspacePath, created.path);
-    expect(rawMission).not.toBeNull();
-    const rawMilestones = rawMission?.fields.milestones as Array<{ status: string }>;
-    expect(rawMilestones.map((entry) => entry.status)).toEqual(['open', 'open']);
-
-    store.list(workspacePath, 'thread').forEach((featureThread) => {
-      store.update(workspacePath, featureThread.path, { status: 'done' }, undefined, 'system', {
-        skipAuthorization: true,
-      });
-    });
-
-    store.update(workspacePath, created.path, {
-      status: 'completed',
-      completed_at: '2026-03-10T05:00:00.000Z',
-    }, undefined, 'system', {
-      skipAuthorization: true,
-    });
-
-    const normalized = mission.missionStatus(workspacePath, created.path);
-    const normalizedMilestones = normalized.fields.milestones as Array<{
-      status: string;
-      completed_at?: string;
-      validation?: { run_status?: string; validated_at?: string };
-    }>;
-    expect(normalizedMilestones.map((entry) => entry.status)).toEqual(['passed', 'passed']);
-    expect(normalizedMilestones[0]?.validation?.run_status).toBe('succeeded');
-    expect(normalizedMilestones[0]?.validation?.validated_at).toBe('2026-03-10T05:00:00.000Z');
-    expect(normalized.body).toContain('status: passed');
-
-    const progress = mission.missionProgress(workspacePath, created.path);
-    expect(progress.passedMilestones).toBe(2);
-    expect(progress.doneFeatures).toBe(2);
-    expect(progress.percentComplete).toBe(100);
-  });
-});
diff --git a/packages/kernel/src/mission.ts b/packages/kernel/src/mission.ts
deleted file mode 100644
index 47c4e69..0000000
--- a/packages/kernel/src/mission.ts
+++ /dev/null
@@ -1,981 +0,0 @@
-/**
- * Mission primitive lifecycle operations.
- */
-
-import * as auth from './auth.js';
-import * as ledger from './ledger.js';
-import * as store from './store.js';
-import {
-  MISSION_STATUS_TRANSITIONS,
-  type Milestone,
-  type MilestoneValidationPlan,
-  type Mission,
-  type MissionPlan,
-  type MissionStatus,
-  type PrimitiveInstance,
-} from './types.js';
-
-export interface CreateMissionOptions {
-  mid?: string;
-  description?: string;
-  priority?: 'urgent' | 'high' | 'medium' | 'low';
-  owner?: string;
-  project?: string;
-  space?: string;
-  constraints?: string[];
-  tags?: string[];
-}
-
-export interface MissionFeaturePlanInput {
-  title?: string;
-  goal?: string;
-  threadPath?: string;
-  priority?: 'urgent' | 'high' | 'medium' | 'low';
-  deps?: string[];
-  tags?: string[];
-}
-
-export interface MissionMilestonePlanInput {
-  id?: string;
-  title: string;
-  deps?: string[];
-  features: Array<string | MissionFeaturePlanInput>;
-  validation?: {
-    strategy?: 'automated' | 'manual' | 'hybrid';
-    criteria?: string[];
-  };
-}
-
-export interface PlanMissionInput {
-  goal?: string;
-  constraints?: string[];
-  estimated_runs?: number;
-  estimated_cost_usd?: number | null;
-  milestones: MissionMilestonePlanInput[];
-  replaceMilestones?: boolean;
-}
-
-export interface MissionInterventionInput {
-  reason: string;
-  setPriority?: 'urgent' | 'high' | 'medium' | 'low';
-  setStatus?: MissionStatus;
-  skipFeature?: {
-    milestoneId: string;
-    threadPath: string;
-  };
-  appendMilestones?: MissionMilestonePlanInput[];
-}
-
-export interface MissionProgressMilestoneSummary {
-  id: string;
-  title: string;
-  status: string;
-  featuresTotal: number;
-  featuresDone: number;
-}
-
-export interface MissionProgressReport {
-  missionPath: string;
-  mid: string;
-  status: MissionStatus;
-  totalMilestones: number;
-  passedMilestones: number;
-  totalFeatures: number;
-  doneFeatures: number;
-  percentComplete: number;
-  totalRuns: number;
-  totalCostUsd: number;
-  runsByAdapter: Record<string, number>;
-  milestones: MissionProgressMilestoneSummary[];
-}
-
-export function createMission(
-  workspacePath: string,
-  title: string,
-  goal: string,
-  actor: string,
-  options: CreateMissionOptions = {},
-): PrimitiveInstance {
-  assertMissionMutationAuthorized(workspacePath, actor, 'mission.create', 'missions', [
-    'mission:create',
-    'mission:manage',
-    'policy:manage',
-  ]);
-  const mid = options.mid ? normalizeSlug(options.mid) : mintMissionId(title);
-  const pathOverride = `missions/${mid}.md`;
-  const created = store.create(
-    workspacePath,
-    'mission',
-    {
-      mid,
-      title,
-      description: options.description,
-      status: 'planning',
-      priority: options.priority ?? 'medium',
-      owner: options.owner ?? actor,
-      project: normalizeOptionalRef(options.project),
-      space: normalizeOptionalRef(options.space),
-      plan: {
-        goal,
-        constraints: options.constraints ?? [],
-      } satisfies MissionPlan,
-      milestones: [],
-      total_runs: 0,
-      total_cost_usd: 0,
-      runs_by_adapter: {},
-      tags: options.tags ?? [],
-    },
-    renderMissionBody({
-      goal,
-      constraints: options.constraints ?? [],
-    }),
-    actor,
-    {
-      pathOverride,
-      skipAuthorization: true,
-      action: 'mission.create.store',
-      requiredCapabilities: ['mission:create', 'mission:manage', 'policy:manage'],
-    },
-  );
-  ledger.append(workspacePath, actor, 'update', created.path, 'mission', {
-    mission_event: 'mission-created',
-    mid,
-  });
-  return created;
-}
-
-export function planMission(
-  workspacePath: string,
-  missionRef: string,
-  input: PlanMissionInput,
-  actor: string,
-): PrimitiveInstance {
-  assertMissionMutationAuthorized(workspacePath, actor, 'mission.plan', missionRef, [
-    'mission:update',
-    'mission:manage',
-    'thread:create',
-    'thread:manage',
-  ]);
-  const mission = requireMission(workspacePath, missionRef);
-  const missionState = asMission(mission);
-  if (missionState.status !== 'planning' && missionState.status !== 'approved') {
-    throw new Error(`Cannot plan mission in "${missionState.status}" state.`);
-  }
-  if (!Array.isArray(input.milestones) || input.milestones.length === 0) {
-    throw new Error('Mission plan requires at least one milestone.');
-  }
-
-  const existingMilestones = indexMilestones(missionState.milestones);
-  const nextMilestones = input.milestones.map((milestoneInput, index) =>
-    materializeMilestonePlan(
-      workspacePath,
-      mission,
-      milestoneInput,
-      index,
-      actor,
-      existingMilestones.get(normalizeMilestoneId(milestoneInput.id, index)),
-    ),
-  );
-  const mergedMilestones = input.replaceMilestones === false
-    ? mergeMilestones(missionState.milestones, nextMilestones)
-    : nextMilestones;
-
-  const nextPlan: MissionPlan = {
-    goal: input.goal ?? missionState.plan?.goal ?? String(mission.fields.title ?? mission.path),
-    constraints: input.constraints ?? missionState.plan?.constraints ?? [],
-    estimated_runs: input.estimated_runs ?? missionState.plan?.estimated_runs,
-    estimated_cost_usd: input.estimated_cost_usd ?? missionState.plan?.estimated_cost_usd ?? null,
-  };
-  const safePlan = sanitizeForYaml(nextPlan);
-  const safeMilestones = sanitizeForYaml(mergedMilestones);
-  const updated = store.update(
-    workspacePath,
-    mission.path,
-    {
-      plan: safePlan,
-      milestones: safeMilestones,
-    },
-    renderMissionBody(safePlan, safeMilestones),
-    actor,
-    {
-      skipAuthorization: true,
-      action: 'mission.plan.store',
-      requiredCapabilities: ['mission:update', 'mission:manage', 'thread:create', 'thread:manage'],
-    },
-  );
-  ledger.append(workspacePath, actor, 'update', mission.path, 'mission', {
-    mission_event: 'mission-planned',
-    milestone_count: mergedMilestones.length,
-    feature_count: mergedMilestones.reduce((sum, milestone) => sum + milestone.features.length, 0),
-  });
-  return updated;
-}
-
-export function approveMission(workspacePath: string, missionRef: string, actor: string): PrimitiveInstance {
-  assertMissionMutationAuthorized(workspacePath, actor, 'mission.approve', missionRef, [
-    'mission:update',
-    'mission:manage',
-    'policy:manage',
-  ]);
-  const mission = requireMission(workspacePath, missionRef);
-  const missionState = asMission(mission);
-  assertMissionStatusTransition(missionState.status, 'approved');
-  if (missionState.milestones.length === 0) {
-    throw new Error('Cannot approve mission without planned milestones.');
-  }
-  const updated = store.update(
-    workspacePath,
-    mission.path,
-    {
-      status: 'approved',
-      approved_at: new Date().toISOString(),
-    },
-    undefined,
-    actor,
-    {
-      skipAuthorization: true,
-      action: 'mission.approve.store',
-      requiredCapabilities: ['mission:update', 'mission:manage', 'policy:manage'],
-    },
-  );
-  ledger.append(workspacePath, actor, 'update', mission.path, 'mission', {
-    mission_event: 'mission-approved',
-  });
-  return updated;
-}
-
-export function startMission(workspacePath: string, missionRef: string, actor: string): PrimitiveInstance {
-  assertMissionMutationAuthorized(workspacePath, actor, 'mission.start', missionRef, [
-    'mission:update',
-    'mission:manage',
-    'dispatch:run',
-  ]);
-  const mission = requireMission(workspacePath, missionRef);
-  const missionState = asMission(mission);
-  assertMissionStatusTransition(missionState.status, 'active');
-  if (missionState.milestones.length === 0) {
-    throw new Error('Cannot start mission without milestones.');
-  }
-  const now = new Date().toISOString();
-  const nextMilestones = missionState.milestones.map((milestone) => ({ ...milestone }));
-  const activeOrValidating = nextMilestones.some((milestone) =>
-    milestone.status === 'active' || milestone.status === 'validating',
-  );
-  if (!activeOrValidating) {
-    const firstReady = pickNextReadyMilestone(nextMilestones);
-    if (firstReady) {
-      firstReady.status = 'active';
-      firstReady.started_at = firstReady.started_at ?? now;
-    }
-  }
-  const updated = store.update(
-    workspacePath,
-    mission.path,
-    {
-      status: 'active',
-      started_at: missionState.started_at ?? now,
-      milestones: sanitizeForYaml(nextMilestones),
-    },
-    renderMissionBody(missionState.plan, nextMilestones),
-    actor,
-    {
-      skipAuthorization: true,
-      action: 'mission.start.store',
-      requiredCapabilities: ['mission:update', 'mission:manage', 'dispatch:run'],
-    },
-  );
-  ledger.append(workspacePath, actor, 'update', mission.path, 'mission', {
-    mission_event: 'mission-started',
-  });
-  return updated;
-}
-
-export function missionStatus(workspacePath: string, missionRef: string): PrimitiveInstance {
-  const mission = requireMission(workspacePath, missionRef);
-  return normalizeMissionReadModel(workspacePath, mission);
-}
-
-export function missionProgress(workspacePath: string, missionRef: string): MissionProgressReport {
-  const mission = normalizeMissionReadModel(workspacePath, requireMission(workspacePath, missionRef));
-  const missionState = asMission(mission);
-  const milestoneSummaries: MissionProgressMilestoneSummary[] = [];
-  let totalFeatures = 0;
-  let doneFeatures = 0;
-  for (const milestone of missionState.milestones) {
-    const featureStats = summarizeMilestoneFeatures(workspacePath, milestone);
-    totalFeatures += featureStats.total;
-    doneFeatures += featureStats.done;
-    milestoneSummaries.push({
-      id: milestone.id,
-      title: milestone.title,
-      status: milestone.status,
-      featuresTotal: featureStats.total,
-      featuresDone: featureStats.done,
-    });
-  }
-  const passedMilestones = missionState.milestones.filter((milestone) => milestone.status === 'passed').length;
-  const percentComplete = totalFeatures > 0
-    ? Math.round((doneFeatures / totalFeatures) * 100)
-    : missionState.status === 'completed'
-      ? 100
-      : 0;
-  return {
-    missionPath: mission.path,
-    mid: missionState.mid,
-    status: missionState.status,
-    totalMilestones: missionState.milestones.length,
-    passedMilestones,
-    totalFeatures,
-    doneFeatures,
-    percentComplete,
-    totalRuns: missionState.total_runs,
-    totalCostUsd: missionState.total_cost_usd,
-    runsByAdapter: missionState.runs_by_adapter ?? {},
-    milestones: milestoneSummaries,
-  };
-}
-
-export function interveneMission(
-  workspacePath: string,
-  missionRef: string,
-  input: MissionInterventionInput,
-  actor: string,
-): PrimitiveInstance {
-  assertMissionMutationAuthorized(workspacePath, actor, 'mission.intervene', missionRef, [
-    'mission:update',
-    'mission:manage',
-    'thread:update',
-    'thread:manage',
-  ]);
-  const mission = requireMission(workspacePath, missionRef);
-  const missionState = asMission(mission);
-  const reason = String(input.reason ?? '').trim();
-  if (!reason) {
-    throw new Error('Mission intervention requires a non-empty reason.');
-  }
-  const milestones: Milestone[] = missionState.milestones.map(cloneMilestone);
-  const skipFeature = input.skipFeature;
-  if (skipFeature) {
-    const normalizedFeature = normalizeThreadPath(skipFeature.threadPath);
-    const milestone = milestones.find((entry) => entry.id === skipFeature.milestoneId);
-    if (!milestone) {
-      throw new Error(`Milestone not found: ${skipFeature.milestoneId}`);
-    }
-    milestone.features = milestone.features.filter((threadPath) => normalizeThreadPath(threadPath) !== normalizedFeature);
-  }
-  if (Array.isArray(input.appendMilestones) && input.appendMilestones.length > 0) {
-    const existingById = indexMilestones(milestones);
-    for (let index = 0; index < input.appendMilestones.length; index += 1) {
-      const appendInput = input.appendMilestones[index]!;
-      const id = normalizeMilestoneId(appendInput.id, milestones.length + index);
-      if (existingById.has(id)) {
-        throw new Error(`Cannot append milestone "${id}" because it already exists.`);
-      }
-      milestones.push(materializeMilestonePlan(
-        workspacePath,
-        mission,
-        appendInput,
-        milestones.length + index,
-        actor,
-      ));
-    }
-  }
-
-  const nextStatus = input.setStatus ?? missionState.status;
-  if (nextStatus !== missionState.status) {
-    assertMissionStatusTransition(missionState.status, nextStatus);
-  }
-  const updated = store.update(
-    workspacePath,
-    mission.path,
-    {
-      ...(input.setPriority ? { priority: input.setPriority } : {}),
-      ...(nextStatus !== missionState.status ? { status: nextStatus } : {}),
-      milestones: sanitizeForYaml(milestones),
-      ...(nextStatus === 'completed' ? { completed_at: new Date().toISOString() } : {}),
-    },
-    renderMissionBody(missionState.plan, milestones),
-    actor,
-    {
-      skipAuthorization: true,
-      action: 'mission.intervene.store',
-      requiredCapabilities: ['mission:update', 'mission:manage', 'thread:update', 'thread:manage'],
-    },
-  );
-  ledger.append(workspacePath, actor, 'update', mission.path, 'mission', {
-    mission_event: 'mission-intervened',
-    reason,
-    ...(input.setPriority ? { priority: input.setPriority } : {}),
-    ...(input.setStatus ? { status: input.setStatus } : {}),
-    ...(input.skipFeature ? { skipped_feature: normalizeThreadPath(input.skipFeature.threadPath) } : {}),
-    ...(input.appendMilestones ? { appended_milestones: input.appendMilestones.length } : {}),
-  });
-  return updated;
-}
-
-export function listMissions(workspacePath: string): PrimitiveInstance[] {
-  return store.list(workspacePath, 'mission').sort((left, right) =>
-    String(right.fields.updated ?? '').localeCompare(String(left.fields.updated ?? '')),
-  );
-}
-
-export function mintMissionId(title: string): string {
-  const slug = normalizeSlug(title);
-  return slug || 'mission';
-}
-
-function materializeMilestonePlan(
-  workspacePath: string,
-  mission: PrimitiveInstance,
-  milestoneInput: MissionMilestonePlanInput,
-  index: number,
-  actor: string,
-  existing?: Milestone,
-): Milestone {
-  const milestoneId = normalizeMilestoneId(milestoneInput.id, index);
-  const milestoneTitle = String(milestoneInput.title ?? '').trim();
-  if (!milestoneTitle) {
-    throw new Error(`Milestone ${milestoneId} requires a title.`);
-  }
-  if (!Array.isArray(milestoneInput.features) || milestoneInput.features.length === 0) {
-    throw new Error(`Milestone ${milestoneId} requires at least one feature.`);
-  }
-  const featureRefs = milestoneInput.features.map((feature, featureIndex) =>
-    materializeFeatureThread(workspacePath, mission, feature, milestoneId, featureIndex, actor),
-  );
-  const validation = normalizeValidationPlan(milestoneInput.validation, existing?.validation);
-  return {
-    id: milestoneId,
-    title: milestoneTitle,
-    status: existing?.status ?? 'open',
-    deps: dedupeStrings(milestoneInput.deps ?? existing?.deps ?? []),
-    features: dedupeStrings(featureRefs),
-    ...(validation ? { validation } : {}),
-    ...(existing?.started_at ? { started_at: existing.started_at } : {}),
-    ...(existing?.completed_at ? { completed_at: existing.completed_at } : {}),
-    ...(existing?.failed_at ? { failed_at: existing.failed_at } : {}),
-  };
-}
-
-function cloneMilestone(milestone: Milestone): Milestone {
-  return {
-    ...milestone,
-    deps: [...(milestone.deps ?? [])],
-    features: [...milestone.features],
-    ...(milestone.validation ? { validation: { ...milestone.validation } } : {}),
-  };
-}
-
-function materializeFeatureThread(
-  workspacePath: string,
-  mission: PrimitiveInstance,
-  input: string | MissionFeaturePlanInput,
-  milestoneId: string,
-  featureIndex: number,
-  actor: string,
-): string {
-  const missionMid = String(mission.fields.mid ?? '').trim();
-  const missionPath = mission.path;
-  const missionSpace = normalizeOptionalRef(mission.fields.space);
-  if (typeof input === 'string') {
-    return ensureMissionFeatureThread(
-      workspacePath,
-      mission,
-      {
-        title: input,
-        goal: `Complete feature "${input}" for milestone ${milestoneId}.`,
-      },
-      `threads/mission-${missionMid}/${normalizeSlug(input) || `feature-${featureIndex + 1}`}.md`,
-      actor,
-      missionSpace,
-      missionPath,
-    );
-  }
-  const explicitPath = normalizeThreadPath(input.threadPath);
-  if (explicitPath) {
-    const existing = store.read(workspacePath, explicitPath);
-    if (existing) return existing.path;
-    if (!input.title) {
-      throw new Error(`Feature thread "${explicitPath}" does not exist and no title was provided to create it.`);
-    }
-  }
-  const title = String(input.title ?? '').trim();
-  if (!title) {
-    throw new Error(`Feature at milestone ${milestoneId} index ${featureIndex + 1} requires a title.`);
-  }
-  const featurePath = explicitPath || `threads/mission-${missionMid}/${normalizeSlug(title) || `feature-${featureIndex + 1}`}.md`;
-  return ensureMissionFeatureThread(
-    workspacePath,
-    mission,
-    input,
-    featurePath,
-    actor,
-    missionSpace,
-    missionPath,
-  );
-}
-
-function ensureMissionFeatureThread(
-  workspacePath: string,
-  mission: PrimitiveInstance,
-  input: MissionFeaturePlanInput,
-  featurePath: string,
-  actor: string,
-  missionSpace: string | undefined,
-  missionPath: string,
-): string {
-  const existing = store.read(workspacePath, featurePath);
-  if (existing) return existing.path;
-  const title = String(input.title ?? '').trim();
-  if (!title) {
-    throw new Error(`Cannot create mission feature thread without title (${featurePath}).`);
-  }
-  const goal = String(input.goal ?? `Complete feature "${title}" for mission ${mission.fields.title}.`).trim();
-  const now = new Date().toISOString();
-  const feature = store.create(
-    workspacePath,
-    'thread',
-    {
-      tid: normalizeSlug(title) || 'feature',
-      title,
-      goal,
-      status: 'open',
-      priority: input.priority ?? 'medium',
-      deps: dedupeStrings(input.deps ?? []),
-      parent: mission.path,
-      space: missionSpace,
-      context_refs: dedupeStrings([missionPath, ...(missionSpace ? [missionSpace] : [])]),
-      participants: [{
-        actor: actor.toLowerCase(),
-        role: 'owner',
-        joined_at: now,
-        invited_by: actor.toLowerCase(),
-      }],
-      tags: dedupeStrings([...(input.tags ?? []), 'mission-feature']),
-    },
-    `## Goal\n\n${goal}\n`,
-    actor,
-    {
-      pathOverride: featurePath,
-      skipAuthorization: true,
-      action: 'mission.plan.feature.store',
-      requiredCapabilities: ['thread:create', 'thread:manage', 'mission:update', 'mission:manage'],
-    },
-  );
-  ledger.append(workspacePath, actor, 'update', mission.path, 'mission', {
-    mission_event: 'mission-feature-created',
-    feature_thread: feature.path,
-  });
-  return feature.path;
-}
-
-function summarizeMilestoneFeatures(workspacePath: string, milestone: Milestone): { total: number; done: number } {
-  let done = 0;
-  for (const threadPath of milestone.features) {
-    const thread = store.read(workspacePath, threadPath);
-    if (thread && String(thread.fields.status ?? '') === 'done') {
-      done += 1;
-    }
-  }
-  return {
-    total: milestone.features.length,
-    done,
-  };
-}
-
-function mergeMilestones(existing: Milestone[], next: Milestone[]): Milestone[] {
-  const byId = indexMilestones(existing);
-  for (const milestone of next) {
-    byId.set(milestone.id, milestone);
-  }
-  return [...byId.values()];
-}
-
-function indexMilestones(milestones: Milestone[]): Map<string, Milestone> {
-  const map = new Map<string, Milestone>();
-  for (const milestone of milestones) {
-    map.set(milestone.id, milestone);
-  }
-  return map;
-}
-
-function normalizeValidationPlan(
-  input: MissionMilestonePlanInput['validation'],
-  existing?: MilestoneValidationPlan,
-): MilestoneValidationPlan {
-  const strategy = input?.strategy ?? existing?.strategy ?? 'automated';
-  return {
-    strategy,
-    criteria: dedupeStrings(input?.criteria ?? existing?.criteria ?? []),
-    ...(existing?.run_id ? { run_id: existing.run_id } : {}),
-    ...(existing?.run_status ? { run_status: existing.run_status } : {}),
-    ...(existing?.validated_at ? { validated_at: existing.validated_at } : {}),
-  };
-}
-
-function requireMission(workspacePath: string, missionRef: string): PrimitiveInstance {
-  const missionPath = resolveMissionPath(workspacePath, missionRef);
-  const mission = store.read(workspacePath, missionPath);
-  if (!mission) {
-    throw new Error(`Mission not found: ${missionRef}`);
-  }
-  if (mission.type !== 'mission') {
-    throw new Error(`Target is not a mission primitive: ${missionRef}`);
-  }
-  return mission;
-}
-
-function resolveMissionPath(workspacePath: string, missionRef: string): string {
-  const normalizedRef = normalizeOptionalRef(missionRef);
-  if (!normalizedRef) {
-    throw new Error('Mission reference is required.');
-  }
-  if (normalizedRef.startsWith('missions/')) {
-    return normalizedRef;
-  }
-  const missionPath = `missions/${normalizeSlug(normalizedRef)}.md`;
-  if (store.read(workspacePath, missionPath)) {
-    return missionPath;
-  }
-  const foundByMid = store.list(workspacePath, 'mission').find((mission) =>
-    String(mission.fields.mid ?? '') === normalizedRef || String(mission.fields.mid ?? '') === normalizeSlug(normalizedRef),
-  );
-  if (foundByMid) {
-    return foundByMid.path;
-  }
-  return missionPath;
-}
-
-function asMission(mission: PrimitiveInstance): Mission {
-  const milestones = normalizeMilestones(mission.fields.milestones);
-  return {
-    mid: String(mission.fields.mid ?? mission.path.split('/').pop()?.replace(/\.md$/, '') ?? 'mission'),
-    title: String(mission.fields.title ?? mission.path),
-    description: normalizeOptionalString(mission.fields.description),
-    status: normalizeMissionStatus(mission.fields.status),
-    priority: normalizePriority(mission.fields.priority),
-    owner: normalizeOptionalString(mission.fields.owner),
-    project: normalizeOptionalRef(mission.fields.project),
-    space: normalizeOptionalRef(mission.fields.space),
-    plan: normalizeMissionPlan(mission.fields.plan),
-    milestones,
-    started_at: normalizeOptionalString(mission.fields.started_at),
-    completed_at: normalizeOptionalString(mission.fields.completed_at),
-    total_runs: asFiniteNumber(mission.fields.total_runs, 0),
-    total_cost_usd: asFiniteNumber(mission.fields.total_cost_usd, 0),
-    runs_by_adapter: asStringNumberRecord(mission.fields.runs_by_adapter),
-    tags: asStringArray(mission.fields.tags),
-    created: normalizeOptionalString(mission.fields.created) ?? new Date(0).toISOString(),
-    updated: normalizeOptionalString(mission.fields.updated) ?? new Date(0).toISOString(),
-  };
-}
-
-function normalizeMissionReadModel(workspacePath: string, mission: PrimitiveInstance): PrimitiveInstance {
-  const missionState = asMission(mission);
-  if (missionState.status !== 'completed') {
-    return mission;
-  }
-
-  let changed = false;
-  const normalizedMilestones = missionState.milestones.map((milestone) => {
-    if (milestone.status === 'passed') {
-      return milestone;
-    }
-
-    changed = true;
-    return {
-      ...milestone,
-      status: 'passed' as const,
-      completed_at: milestone.completed_at ?? missionState.completed_at ?? missionState.updated,
-      ...(milestone.validation
-        ? {
-            validation: {
-              ...milestone.validation,
-              run_status: milestone.validation.run_status ?? 'succeeded',
-              validated_at: milestone.validation.validated_at ?? missionState.completed_at ?? missionState.updated,
-            },
-          }
-        : {}),
-    };
-  });
-
-  if (!changed) {
-    return mission;
-  }
-
-  return {
-    ...mission,
-    fields: {
-      ...mission.fields,
-      milestones: sanitizeForYaml(normalizedMilestones),
-    },
-    body: renderMissionBody(missionState.plan, normalizedMilestones),
-  };
-}
-
-function normalizeMissionPlan(value: unknown): MissionPlan {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return { goal: '' };
-  }
-  const record = value as Record<string, unknown>;
-  return {
-    goal: String(record.goal ?? ''),
-    constraints: asStringArray(record.constraints),
-    estimated_runs: asFiniteNumber(record.estimated_runs, undefined),
-    estimated_cost_usd: asNullableFiniteNumber(record.estimated_cost_usd, null),
-  };
-}
-
-function normalizeMilestones(value: unknown): Milestone[] {
-  if (!Array.isArray(value)) return [];
-  const milestones: Milestone[] = [];
-  for (let index = 0; index < value.length; index += 1) {
-    const rawMilestone = value[index];
-    if (!rawMilestone || typeof rawMilestone !== 'object' || Array.isArray(rawMilestone)) continue;
-    const record = rawMilestone as Record<string, unknown>;
-    const id = normalizeMilestoneId(asOptionalString(record.id), index);
-    const title = asOptionalString(record.title) ?? id;
-    const features = dedupeStrings(asStringArray(record.features).map((entry) => normalizeThreadPath(entry)));
-    const status = normalizeMilestoneStatus(record.status);
-    const validation = normalizeExistingValidation(record.validation);
-    milestones.push({
-      id,
-      title,
-      status,
-      deps: dedupeStrings(asStringArray(record.deps)),
-      features,
-      ...(validation ? { validation } : {}),
-      ...(asOptionalString(record.started_at) ? { started_at: asOptionalString(record.started_at) } : {}),
-      ...(asOptionalString(record.completed_at) ? { completed_at: asOptionalString(record.completed_at) } : {}),
-      ...(asOptionalString(record.failed_at) ? { failed_at: asOptionalString(record.failed_at) } : {}),
-    });
-  }
-  return milestones;
-}
-
-function normalizeExistingValidation(value: unknown): MilestoneValidationPlan | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const record = value as Record<string, unknown>;
-  return {
-    strategy: normalizeValidationStrategy(record.strategy),
-    criteria: asStringArray(record.criteria),
-    ...(asOptionalString(record.run_id) ? { run_id: asOptionalString(record.run_id) } : {}),
-    ...(asOptionalString(record.run_status) ? { run_status: asOptionalString(record.run_status) as MilestoneValidationPlan['run_status'] } : {}),
-    ...(asOptionalString(record.validated_at) ? { validated_at: asOptionalString(record.validated_at) } : {}),
-  };
-}
-
-function normalizeMilestoneStatus(value: unknown): Milestone['status'] {
-  const normalized = String(value ?? 'open').trim().toLowerCase();
-  if (
-    normalized === 'open' ||
-    normalized === 'active' ||
-    normalized === 'validating' ||
-    normalized === 'passed' ||
-    normalized === 'failed'
-  ) {
-    return normalized;
-  }
-  return 'open';
-}
-
-function normalizeMissionStatus(value: unknown): MissionStatus {
-  const normalized = String(value ?? 'planning').trim().toLowerCase();
-  if (
-    normalized === 'planning' ||
-    normalized === 'approved' ||
-    normalized === 'active' ||
-    normalized === 'validating' ||
-    normalized === 'completed' ||
-    normalized === 'failed'
-  ) {
-    return normalized;
-  }
-  return 'planning';
-}
-
-function normalizeValidationStrategy(value: unknown): MilestoneValidationPlan['strategy'] {
-  const normalized = String(value ?? 'automated').trim().toLowerCase();
-  if (normalized === 'manual' || normalized === 'hybrid' || normalized === 'automated') {
-    return normalized;
-  }
-  return 'automated';
-}
-
-function normalizePriority(value: unknown): Mission['priority'] {
-  const normalized = String(value ?? 'medium').trim().toLowerCase();
-  if (normalized === 'urgent' || normalized === 'high' || normalized === 'medium' || normalized === 'low') {
-    return normalized;
-  }
-  return 'medium';
-}
-
-function normalizeMilestoneId(id: string | undefined, index: number): string {
-  const normalized = normalizeSlug(id ?? '');
-  if (normalized) return normalized;
-  return `ms-${index + 1}`;
-}
-
-function normalizeThreadPath(value: unknown): string {
-  const raw = String(value ?? '').trim();
-  if (!raw) return '';
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]') ? raw.slice(2, -2) : raw;
-  const withPrefix = unwrapped.includes('/') ? unwrapped : `threads/${unwrapped}`;
-  return withPrefix.endsWith('.md') ? withPrefix : `${withPrefix}.md`;
-}
-
-function normalizeOptionalRef(value: unknown): string | undefined {
-  const raw = String(value ?? '').trim();
-  if (!raw) return undefined;
-  const unwrapped = raw.startsWith('[[') && raw.endsWith(']]') ? raw.slice(2, -2) : raw;
-  return unwrapped.endsWith('.md') ? unwrapped : `${unwrapped}.md`;
-}
-
-function normalizeOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : undefined;
-}
-
-function asOptionalString(value: unknown): string | undefined {
-  return normalizeOptionalString(value);
-}
-
-function asFiniteNumber(value: unknown, fallback: number | undefined): number {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return fallback ?? 0;
-}
-
-function asNullableFiniteNumber(value: unknown, fallback: number | null): number | null {
-  if (value === null) return null;
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return fallback;
-}
-
-function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value
-    .map((entry) => String(entry ?? '').trim())
-    .filter(Boolean);
-}
-
-function asStringNumberRecord(value: unknown): Record<string, number> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  const record = value as Record<string, unknown>;
-  const output: Record<string, number> = {};
-  for (const [key, rawValue] of Object.entries(record)) {
-    const numeric = asFiniteNumber(rawValue, 0);
-    output[key] = numeric;
-  }
-  return output;
-}
-
-function dedupeStrings(values: string[]): string[] {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}
-
-function normalizeSlug(value: string): string {
-  return String(value ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 80);
-}
-
-function assertMissionStatusTransition(from: MissionStatus, to: MissionStatus): void {
-  if (from === to) return;
-  const allowed = MISSION_STATUS_TRANSITIONS[from] ?? [];
-  if (!allowed.includes(to)) {
-    throw new Error(`Invalid mission transition: "${from}" -> "${to}". Allowed: ${allowed.join(', ') || 'none'}`);
-  }
-}
-
-function pickNextReadyMilestone(milestones: Milestone[]): Milestone | undefined {
-  return milestones.find((milestone) => {
-    if (milestone.status !== 'open') return false;
-    const deps = milestone.deps ?? [];
-    return deps.every((depId) => milestones.some((candidate) => candidate.id === depId && candidate.status === 'passed'));
-  });
-}
-
-function renderMissionBody(plan?: MissionPlan, milestones: Milestone[] = []): string {
-  const lines: string[] = [];
-  const goal = plan?.goal?.trim();
-  lines.push('## Goal');
-  lines.push('');
-  lines.push(goal && goal.length > 0 ? goal : 'TBD');
-  lines.push('');
-  if (plan?.constraints && plan.constraints.length > 0) {
-    lines.push('## Constraints');
-    lines.push('');
-    for (const constraint of plan.constraints) {
-      lines.push(`- ${constraint}`);
-    }
-    lines.push('');
-  }
-  if (milestones.length > 0) {
-    lines.push('## Milestones');
-    lines.push('');
-    for (const milestone of milestones) {
-      lines.push(`### ${milestone.id}: ${milestone.title}`);
-      lines.push('');
-      lines.push(`status: ${milestone.status}`);
-      if (milestone.deps && milestone.deps.length > 0) {
-        lines.push(`deps: ${milestone.deps.join(', ')}`);
-      }
-      if (milestone.validation && milestone.validation.criteria.length > 0) {
-        lines.push(`validation: ${milestone.validation.strategy}`);
-        lines.push(...milestone.validation.criteria.map((criterion) => `- ${criterion}`));
-      }
-      if (milestone.features.length > 0) {
-        lines.push('features:');
-        lines.push(...milestone.features.map((featurePath) => `- [[${featurePath}]]`));
-      }
-      lines.push('');
-    }
-  }
-  return `${lines.join('\n')}\n`;
-}
-
-function sanitizeForYaml<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => sanitizeForYaml(entry))
-      .filter((entry) => entry !== undefined) as unknown as T;
-  }
-  if (!value || typeof value !== 'object') return value;
-  const output: Record<string, unknown> = {};
-  for (const [key, innerValue] of Object.entries(value as Record<string, unknown>)) {
-    if (innerValue === undefined) continue;
-    const sanitized = sanitizeForYaml(innerValue);
-    if (sanitized === undefined) continue;
-    output[key] = sanitized;
-  }
-  return output as T;
-}
-
-function assertMissionMutationAuthorized(
-  workspacePath: string,
-  actor: string,
-  action: string,
-  target: string,
-  requiredCapabilities: string[],
-): void {
-  auth.assertAuthorizedMutation(workspacePath, {
-    actor,
-    action,
-    target,
-    requiredCapabilities,
-    metadata: {
-      module: 'mission',
-    },
-  });
-}
diff --git a/packages/kernel/src/onboard.test.ts b/packages/kernel/src/onboard.test.ts
deleted file mode 100644
index 17562e9..0000000
--- a/packages/kernel/src/onboard.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { onboardWorkspace, updateOnboardingStatus } from './onboard.js';
-import { read as readPrimitive } from './store.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-onboard-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('onboard workspace', () => {
-  it('creates onboarding artifacts including onboarding primitive', () => {
-    const result = onboardWorkspace(workspacePath, {
-      actor: 'agent-setup',
-      spaces: ['platform', 'product'],
-      createDemoThreads: true,
-    });
-
-    expect(result.spacesCreated.length).toBe(2);
-    expect(result.threadsCreated.length).toBeGreaterThan(0);
-    expect(result.boardPath).toBe('ops/Onboarding Board.md');
-    expect(result.commandCenterPath).toBe('ops/Onboarding Command Center.md');
-    expect(result.onboardingPath).toContain('onboarding/');
-
-    const onboarding = readPrimitive(workspacePath, result.onboardingPath);
-    expect(onboarding).not.toBeNull();
-    expect(onboarding?.type).toBe('onboarding');
-    expect(onboarding?.fields.actor).toBe('agent-setup');
-    expect(onboarding?.fields.status).toBe('active');
-  });
-
-  it('supports onboarding lifecycle transitions with guards', () => {
-    const result = onboardWorkspace(workspacePath, {
-      actor: 'agent-setup',
-      spaces: ['platform'],
-      createDemoThreads: false,
-    });
-
-    const paused = updateOnboardingStatus(workspacePath, result.onboardingPath, 'paused', 'agent-setup');
-    expect(paused.fields.status).toBe('paused');
-
-    const completed = updateOnboardingStatus(workspacePath, result.onboardingPath, 'completed', 'agent-setup');
-    expect(completed.fields.status).toBe('completed');
-
-    expect(() => updateOnboardingStatus(workspacePath, result.onboardingPath, 'active', 'agent-setup'))
-      .toThrow('Invalid onboarding transition');
-  });
-});
diff --git a/packages/kernel/src/onboard.ts b/packages/kernel/src/onboard.ts
deleted file mode 100644
index ef57cfd..0000000
--- a/packages/kernel/src/onboard.ts
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- * Agent-first onboarding flow for new workgraph workspaces.
- */
-
-import * as board from './board.js';
-import * as commandCenter from './command-center.js';
-import * as orientation from './orientation.js';
-import * as store from './store.js';
-import type { PrimitiveInstance } from './types.js';
-
-export interface OnboardOptions {
-  actor: string;
-  spaces?: string[];
-  createDemoThreads?: boolean;
-}
-
-export interface OnboardResult {
-  actor: string;
-  spacesCreated: string[];
-  threadsCreated: string[];
-  boardPath: string;
-  commandCenterPath: string;
-  checkpointPath: string;
-  onboardingPath: string;
-}
-
-export type OnboardingStatus = 'active' | 'completed' | 'paused';
-
-export function onboardWorkspace(workspacePath: string, options: OnboardOptions): OnboardResult {
-  const spaces = options.spaces && options.spaces.length > 0
-    ? options.spaces
-    : ['platform', 'product', 'operations'];
-
-  const spacesCreated: string[] = [];
-  for (const space of spaces) {
-    const title = titleCase(space);
-    const created = store.create(
-      workspacePath,
-      'space',
-      {
-        title,
-        description: `${title} workspace lane`,
-        members: [options.actor],
-        tags: ['onboarded'],
-      },
-      `# ${title}\n\nAuto-created during onboarding.\n`,
-      options.actor,
-    );
-    spacesCreated.push(created.path);
-  }
-
-  const threadsCreated: string[] = [];
-  if (options.createDemoThreads !== false) {
-    const templates = [
-      { title: 'Review workspace policy gates', goal: 'Validate sensitive transitions are governed.', space: spacesCreated[0] },
-      { title: 'Configure board sync cadence', goal: 'Set board update expectations for all agents.', space: spacesCreated[1] ?? spacesCreated[0] },
-      { title: 'Establish daily checkpoint routine', goal: 'Agents leave actionable hand-off notes.', space: spacesCreated[2] ?? spacesCreated[0] },
-    ];
-
-    for (const template of templates) {
-      const created = store.create(
-        workspacePath,
-        'thread',
-        {
-          title: template.title,
-          goal: template.goal,
-          status: 'open',
-          priority: 'medium',
-          space: template.space,
-          context_refs: [template.space],
-          tags: ['onboarding'],
-        },
-        `## Goal\n\n${template.goal}\n`,
-        options.actor,
-      );
-      threadsCreated.push(created.path);
-    }
-  }
-
-  const boardResult = board.generateKanbanBoard(workspacePath, { outputPath: 'ops/Onboarding Board.md' });
-  const commandCenterResult = commandCenter.generateCommandCenter(workspacePath, {
-    outputPath: 'ops/Onboarding Command Center.md',
-    actor: options.actor,
-  });
-  const checkpointResult = orientation.checkpoint(
-    workspacePath,
-    options.actor,
-    'Onboarding completed and workspace views initialized.',
-    {
-      next: ['Claim your next ready thread via `workgraph thread next --claim`'],
-      blocked: [],
-      tags: ['onboarding'],
-    },
-  );
-  const onboarding = store.create(
-    workspacePath,
-    'onboarding',
-    {
-      title: `Onboarding for ${options.actor}`,
-      actor: options.actor,
-      status: 'active',
-      spaces: spacesCreated,
-      thread_refs: threadsCreated,
-      board: boardResult.outputPath,
-      command_center: commandCenterResult.outputPath,
-      tags: ['onboarding'],
-    },
-    [
-      '# Onboarding',
-      '',
-      `Actor: ${options.actor}`,
-      '',
-      '## Spaces',
-      '',
-      ...spacesCreated.map((space) => `- [[${space}]]`),
-      '',
-      '## Starter Threads',
-      '',
-      ...threadsCreated.map((threadRef) => `- [[${threadRef}]]`),
-      '',
-      `Board: [[${boardResult.outputPath}]]`,
-      `Command Center: [[${commandCenterResult.outputPath}]]`,
-      '',
-    ].join('\n'),
-    options.actor,
-  );
-
-  return {
-    actor: options.actor,
-    spacesCreated,
-    threadsCreated,
-    boardPath: boardResult.outputPath,
-    commandCenterPath: commandCenterResult.outputPath,
-    checkpointPath: checkpointResult.path,
-    onboardingPath: onboarding.path,
-  };
-}
-
-export function updateOnboardingStatus(
-  workspacePath: string,
-  onboardingPath: string,
-  status: OnboardingStatus,
-  actor: string,
-): PrimitiveInstance {
-  const onboarding = store.read(workspacePath, onboardingPath);
-  if (!onboarding) throw new Error(`Onboarding primitive not found: ${onboardingPath}`);
-  if (onboarding.type !== 'onboarding') {
-    throw new Error(`Target is not an onboarding primitive: ${onboardingPath}`);
-  }
-  const current = String(onboarding.fields.status ?? 'active') as OnboardingStatus;
-  const allowed = ONBOARDING_STATUS_TRANSITIONS[current] ?? [];
-  if (!allowed.includes(status)) {
-    throw new Error(`Invalid onboarding transition: ${current} -> ${status}. Allowed: ${allowed.join(', ') || 'none'}`);
-  }
-  return store.update(
-    workspacePath,
-    onboardingPath,
-    { status },
-    undefined,
-    actor,
-  );
-}
-
-const ONBOARDING_STATUS_TRANSITIONS: Record<OnboardingStatus, OnboardingStatus[]> = {
-  active: ['paused', 'completed'],
-  paused: ['active', 'completed'],
-  completed: [],
-};
-
-function titleCase(value: string): string {
-  return value
-    .split(/[-_\s]/g)
-    .filter(Boolean)
-    .map((part) => part[0].toUpperCase() + part.slice(1))
-    .join(' ');
-}
diff --git a/packages/kernel/src/orientation.test.ts b/packages/kernel/src/orientation.test.ts
index ec96f6a..5841535 100644
--- a/packages/kernel/src/orientation.test.ts
+++ b/packages/kernel/src/orientation.test.ts
@@ -157,28 +157,6 @@ describe('orientation core module', () => {
       'Org context',
       'agent-seed',
     );
-    store.create(
-      workspacePath,
-      'team',
-      {
-        title: 'Platform',
-        members: ['agent-focus', 'agent-other'],
-        responsibilities: ['runtime', 'mcp'],
-      },
-      'Team context',
-      'agent-seed',
-    );
-    store.create(
-      workspacePath,
-      'client',
-      {
-        name: 'Acme Corp',
-        status: 'active',
-        description: 'Strategic customer',
-      },
-      'Client context',
-      'agent-seed',
-    );
     store.create(
       workspacePath,
       'decision',
@@ -193,12 +171,14 @@ describe('orientation core module', () => {
     );
     store.create(
       workspacePath,
-      'pattern',
+      'fact',
       {
-        title: 'Weekly context sync',
-        description: 'Capture and refresh context every Friday',
+        title: 'Thread ownership fact',
+        subject: 'thread-collaboration',
+        predicate: 'supported-by',
+        object: 'context graph',
       },
-      'Pattern context',
+      'Fact context',
       'agent-seed',
     );
     store.create(
@@ -215,10 +195,10 @@ describe('orientation core module', () => {
 
     const brief = orientation.brief(workspacePath, 'agent-focus');
     expect(brief.companyContext.org?.title).toBe('Versatly');
-    expect(brief.companyContext.teams[0]?.title).toBe('Platform');
-    expect(brief.companyContext.clients[0]?.title).toBe('Acme Corp');
+    expect(brief.companyContext.teams).toEqual([]);
+    expect(brief.companyContext.clients).toEqual([]);
     expect(brief.companyContext.recentDecisions[0]?.decidedBy).toBe('agent-focus');
-    expect(brief.companyContext.patterns[0]?.title).toBe('Weekly context sync');
+    expect(brief.companyContext.patterns).toEqual([]);
     expect(brief.companyContext.agentProfile?.name).toBe('agent-focus');
     expect(brief.companyContext.agentProfile?.permissions).toEqual(['mcp:write']);
   });
diff --git a/packages/kernel/src/orientation/brief.ts b/packages/kernel/src/orientation/brief.ts
deleted file mode 100644
index 9cd6d78..0000000
--- a/packages/kernel/src/orientation/brief.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { brief, companyContext } from '../orientation.js';
diff --git a/packages/kernel/src/orientation/checkpoint.ts b/packages/kernel/src/orientation/checkpoint.ts
deleted file mode 100644
index a77f071..0000000
--- a/packages/kernel/src/orientation/checkpoint.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { checkpoint, intake } from '../orientation.js';
diff --git a/packages/kernel/src/orientation/lens.ts b/packages/kernel/src/orientation/lens.ts
deleted file mode 100644
index 8999a5b..0000000
--- a/packages/kernel/src/orientation/lens.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-export {
-  listContextLenses,
-  generateContextLens,
-  materializeContextLens,
-} from '../lens.js';
diff --git a/packages/kernel/src/orientation/status.ts b/packages/kernel/src/orientation/status.ts
deleted file mode 100644
index 202789f..0000000
--- a/packages/kernel/src/orientation/status.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { statusSnapshot } from '../orientation.js';
diff --git a/packages/kernel/src/policy-dispatch.test.ts b/packages/kernel/src/policy-dispatch.test.ts
deleted file mode 100644
index 53275f2..0000000
--- a/packages/kernel/src/policy-dispatch.test.ts
+++ /dev/null
@@ -1,276 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as store from './store.js';
-import * as policy from './policy.js';
-import * as dispatch from './dispatch.js';
-import * as ledger from './ledger.js';
-import * as trigger from './trigger.js';
-import * as thread from './thread.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-policy-dispatch-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('policy gates and dispatch contract', () => {
-  it('blocks sensitive promotion without policy capability and allows after grant', () => {
-    const decision = store.create(workspacePath, 'decision', {
-      title: 'Choose runtime',
-      date: new Date().toISOString(),
-      status: 'draft',
-    }, '# Decision\n', 'agent-a');
-
-    expect(() => store.update(workspacePath, decision.path, { status: 'approved' }, undefined, 'agent-a'))
-      .toThrow('Policy gate blocked transition');
-
-    policy.upsertParty(workspacePath, 'agent-a', {
-      roles: ['reviewer'],
-      capabilities: ['promote:sensitive'],
-    });
-
-    const approved = store.update(workspacePath, decision.path, { status: 'approved' }, undefined, 'agent-a');
-    expect(approved.fields.status).toBe('approved');
-  });
-
-  it('blocks creating sensitive primitive directly in active state without capability', () => {
-    expect(() => store.create(workspacePath, 'policy', {
-      title: 'Direct active policy',
-      status: 'active',
-    }, '# policy\n', 'agent-plain')).toThrow('Policy gate blocked transition');
-
-    policy.upsertParty(workspacePath, 'agent-plain', {
-      roles: ['admin'],
-      capabilities: ['promote:sensitive'],
-    });
-    const created = store.create(workspacePath, 'policy', {
-      title: 'Direct active policy',
-      status: 'active',
-    }, '# policy\n', 'agent-plain');
-    expect(created.fields.status).toBe('active');
-  });
-
-  it('adds status transition audit metadata into ledger updates', () => {
-    const incident = store.create(workspacePath, 'incident', {
-      title: 'Service degradation',
-      status: 'draft',
-    }, '# incident\n', 'agent-x');
-    policy.upsertParty(workspacePath, 'agent-x', {
-      roles: ['reviewer'],
-      capabilities: ['promote:sensitive'],
-    });
-    store.update(workspacePath, incident.path, { status: 'approved' }, undefined, 'agent-x');
-    const entries = ledger.historyOf(workspacePath, incident.path);
-    const updateEntry = entries.find((entry) => entry.op === 'update');
-    expect(updateEntry?.data?.from_status).toBe('draft');
-    expect(updateEntry?.data?.to_status).toBe('approved');
-  });
-
-  it('supports dispatch create/status/followup/stop/logs flow', () => {
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Process backlog',
-      idempotencyKey: 'abc-123',
-    });
-    expect(created.status).toBe('queued');
-
-    const duplicate = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Process backlog',
-      idempotencyKey: 'abc-123',
-    });
-    expect(duplicate.id).toBe(created.id);
-
-    const followed = dispatch.followup(workspacePath, created.id, 'agent-runner', 'Begin phase 1');
-    expect(followed.status).toBe('queued');
-    expect(followed.followups).toHaveLength(1);
-
-    const stopped = dispatch.stop(workspacePath, created.id, 'agent-operator');
-    expect(stopped.status).toBe('cancelled');
-    expect(dispatch.logs(workspacePath, created.id).length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('supports marking runs as succeeded and failed', () => {
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Mark state transitions',
-    });
-    const running = dispatch.markRun(workspacePath, created.id, 'agent-runner', 'running');
-    expect(running.status).toBe('running');
-
-    const succeeded = dispatch.markRun(workspacePath, created.id, 'agent-runner', 'succeeded', {
-      output: 'All checks complete',
-    });
-    expect(succeeded.status).toBe('succeeded');
-    expect(succeeded.output).toBe('All checks complete');
-
-    const second = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Failure flow',
-    });
-    dispatch.markRun(workspacePath, second.id, 'agent-runner', 'running');
-    const failed = dispatch.markRun(workspacePath, second.id, 'agent-runner', 'failed', {
-      error: 'runtime timeout',
-    });
-    expect(failed.status).toBe('failed');
-    expect(failed.error).toBe('runtime timeout');
-  });
-
-  it('tracks run leases with heartbeat and requeues expired leases during reconcile', () => {
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Lease lifecycle',
-    });
-    const running = dispatch.markRun(workspacePath, created.id, 'agent-runner', 'running');
-    expect(running.leaseExpires).toBeDefined();
-    expect(running.leaseDurationMinutes).toBe(30);
-
-    const heartbeated = dispatch.heartbeat(workspacePath, created.id, {
-      actor: 'agent-runner',
-      leaseMinutes: 45,
-    });
-    expect(heartbeated.heartbeats).toHaveLength(1);
-    expect(heartbeated.leaseDurationMinutes).toBe(45);
-    expect(Date.parse(String(heartbeated.leaseExpires))).toBeGreaterThan(Date.now());
-
-    const runPrimitive = store.list(workspacePath, 'run')
-      .find((entry) => String(entry.fields.run_id) === created.id);
-    expect(runPrimitive).toBeDefined();
-    expect(runPrimitive?.fields.heartbeat_timestamps).toHaveLength(1);
-
-    const dispatchStatePath = path.join(workspacePath, '.workgraph', 'dispatch-runs.json');
-    const dispatchState = JSON.parse(fs.readFileSync(dispatchStatePath, 'utf-8')) as { version: number; runs: Array<Record<string, unknown>> };
-    const idx = dispatchState.runs.findIndex((entry) => entry.id === created.id);
-    dispatchState.runs[idx].leaseExpires = '2000-01-01T00:00:00.000Z';
-    fs.writeFileSync(dispatchStatePath, JSON.stringify(dispatchState, null, 2) + '\n', 'utf-8');
-
-    const reconciled = dispatch.reconcileExpiredLeases(workspacePath, 'agent-ops');
-    expect(reconciled.requeuedRuns.map((run) => run.id)).toContain(created.id);
-    const requeued = dispatch.status(workspacePath, created.id);
-    expect(requeued.status).toBe('queued');
-    expect(requeued.leaseExpires).toBeUndefined();
-  });
-
-  it('creates structured handoff runs and logs handoff entries', () => {
-    const source = dispatch.createRun(workspacePath, {
-      actor: 'agent-source',
-      objective: 'Investigate production issue',
-      context: {
-        thread_slug: 'threads/prod-incident.md',
-        incident_id: 'inc-123',
-      },
-    });
-
-    const handoff = dispatch.handoffRun(workspacePath, source.id, {
-      actor: 'agent-source',
-      to: 'agent-specialist',
-      reason: 'Needs database specialist',
-    });
-
-    expect(handoff.sourceRun.id).toBe(source.id);
-    expect(handoff.handoffRun.id).not.toBe(source.id);
-    expect(handoff.handoffRun.actor).toBe('agent-specialist');
-    expect(handoff.handoffRun.objective).toBe(source.objective);
-    expect(handoff.handoffRun.context?.thread_slug).toBe('threads/prod-incident.md');
-    expect(handoff.handoffRun.context?.handoff_from_run_id).toBe(source.id);
-    expect(handoff.handoffRun.context?.handoff_reason).toBe('Needs database specialist');
-
-    const handoffEntries = ledger.readAll(workspacePath).filter((entry) => entry.op === 'handoff');
-    expect(handoffEntries).toHaveLength(1);
-    expect(handoffEntries[0].data?.from_run_id).toBe(source.id);
-    expect(handoffEntries[0].data?.to_run_id).toBe(handoff.handoffRun.id);
-  });
-
-  it('rejects invalid run status transitions and followups after terminal state', () => {
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-runner',
-      objective: 'Transition guard validation',
-    });
-
-    expect(() => dispatch.markRun(workspacePath, created.id, 'agent-runner', 'succeeded'))
-      .toThrow(`Invalid run transition for ${created.id}: queued -> succeeded.`);
-
-    dispatch.markRun(workspacePath, created.id, 'agent-runner', 'running');
-    dispatch.markRun(workspacePath, created.id, 'agent-runner', 'cancelled');
-
-    expect(() => dispatch.followup(workspacePath, created.id, 'agent-runner', 'post-cancel followup'))
-      .toThrow(`Cannot send follow-up to run ${created.id} in terminal status "cancelled".`);
-  });
-
-  it('fires approved trigger and dispatches run with idempotency', () => {
-    policy.upsertParty(workspacePath, 'agent-gate', {
-      roles: ['reviewer'],
-      capabilities: ['promote:sensitive'],
-    });
-    const trig = store.create(workspacePath, 'trigger', {
-      title: 'Escalate blocked high-priority thread',
-      event: 'thread.blocked',
-      action: 'dispatch.review',
-      status: 'draft',
-    }, '# Trigger\n', 'agent-gate');
-    store.update(workspacePath, trig.path, { status: 'approved' }, undefined, 'agent-gate');
-
-    const fired1 = trigger.fireTrigger(workspacePath, trig.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-123',
-    });
-    const fired2 = trigger.fireTrigger(workspacePath, trig.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-123',
-    });
-    expect(fired1.run.id).toBe(fired2.run.id);
-
-    const fired3 = trigger.fireTrigger(workspacePath, trig.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-124',
-    });
-    expect(fired3.run.id).not.toBe(fired1.run.id);
-  });
-
-  it('executes an autonomous multi-agent run and closes ready dependency chains', async () => {
-    const a = thread.createThread(workspacePath, 'Build parser', 'Parser baseline', 'agent-lead', { priority: 'high' });
-    const b = thread.createThread(workspacePath, 'Build validator', 'Validator baseline', 'agent-lead', { priority: 'high' });
-    const c = thread.createThread(workspacePath, 'Wire parser+validator', 'Integrate parser and validator', 'agent-lead', {
-      deps: [a.path, b.path],
-      priority: 'medium',
-    });
-    const d = thread.createThread(workspacePath, 'Finalize release note', 'Prepare release note', 'agent-lead', {
-      deps: [c.path],
-      priority: 'low',
-    });
-
-    const queued = dispatch.createRun(workspacePath, {
-      actor: 'agent-lead',
-      objective: 'Autonomous execution test',
-      adapter: 'cursor-cloud',
-    });
-
-    const finished = await dispatch.executeRun(workspacePath, queued.id, {
-      actor: 'agent-lead',
-      agents: ['agent-a', 'agent-b', 'agent-c'],
-      maxSteps: 50,
-      stepDelayMs: 0,
-      createCheckpoint: true,
-    });
-
-    expect(finished.status).toBe('succeeded');
-    expect(finished.output).toContain('Completed threads');
-    expect(finished.logs.some((entry) => entry.message.includes('claimed'))).toBe(true);
-    expect(dispatch.status(workspacePath, queued.id).status).toBe('succeeded');
-    expect(store.read(workspacePath, a.path)?.fields.status).toBe('done');
-    expect(store.read(workspacePath, b.path)?.fields.status).toBe('done');
-    expect(store.read(workspacePath, c.path)?.fields.status).toBe('done');
-    expect(store.read(workspacePath, d.path)?.fields.status).toBe('done');
-  });
-});
diff --git a/packages/kernel/src/projections/autonomy-health.ts b/packages/kernel/src/projections/autonomy-health.ts
deleted file mode 100644
index 846c211..0000000
--- a/packages/kernel/src/projections/autonomy-health.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import * as autonomyDaemon from '../autonomy-daemon.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface AutonomyHealthProjection extends ProjectionSummary {
-  scope: 'autonomy';
-  summary: {
-    running: boolean;
-    lastHeartbeatAt?: string;
-    driftIssues?: number;
-  };
-  status: ReturnType<typeof autonomyDaemon.readAutonomyDaemonStatus>;
-}
-
-export function buildAutonomyHealthProjection(workspacePath: string): AutonomyHealthProjection {
-  const status = autonomyDaemon.readAutonomyDaemonStatus(workspacePath, {
-    cleanupStalePidFile: true,
-  });
-  return {
-    scope: 'autonomy',
-    generatedAt: new Date().toISOString(),
-    healthy: !status.running || Boolean(status.heartbeat?.driftOk ?? status.heartbeat?.finalDriftOk ?? true),
-    summary: {
-      running: status.running,
-      lastHeartbeatAt: status.heartbeat?.ts,
-      driftIssues: status.heartbeat?.driftIssues,
-    },
-    status,
-  };
-}
diff --git a/packages/kernel/src/projections/federation-status.ts b/packages/kernel/src/projections/federation-status.ts
deleted file mode 100644
index 6061398..0000000
--- a/packages/kernel/src/projections/federation-status.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import * as federation from '../federation.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface FederationStatusProjection extends ProjectionSummary {
-  scope: 'federation';
-  summary: {
-    remotes: number;
-    compatibleRemotes: number;
-    staleRemotes: number;
-  };
-  status: ReturnType<typeof federation.federationStatus>;
-}
-
-export function buildFederationStatusProjection(workspacePath: string): FederationStatusProjection {
-  const status = federation.federationStatus(workspacePath);
-  const compatibleRemotes = status.remotes.filter((entry) => entry.compatible).length;
-  const staleRemotes = status.remotes.filter((entry) => {
-    const remote = entry.remote;
-    return !remote.lastSyncedAt || remote.lastSyncStatus !== 'synced';
-  }).length;
-  return {
-    scope: 'federation',
-    generatedAt: new Date().toISOString(),
-    healthy: status.remotes.every((entry) => entry.compatible && entry.supportsRead),
-    summary: {
-      remotes: status.remotes.length,
-      compatibleRemotes,
-      staleRemotes,
-    },
-    status,
-  };
-}
diff --git a/packages/kernel/src/projections/index.ts b/packages/kernel/src/projections/index.ts
deleted file mode 100644
index 146099b..0000000
--- a/packages/kernel/src/projections/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export * from './types.js';
-export * from './run-health.js';
-export * from './risk-dashboard.js';
-export * from './mission-progress.js';
-export * from './transport-health.js';
-export * from './federation-status.js';
-export * from './trigger-health.js';
-export * from './autonomy-health.js';
diff --git a/packages/kernel/src/projections/mission-progress.ts b/packages/kernel/src/projections/mission-progress.ts
deleted file mode 100644
index 6201fab..0000000
--- a/packages/kernel/src/projections/mission-progress.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as mission from '../mission.js';
-import * as store from '../store.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface MissionProgressProjection extends ProjectionSummary {
-  scope: 'mission';
-  summary: {
-    totalMissions: number;
-    completedMissions: number;
-    averageCompletionPercent: number;
-  };
-  missions: Array<ReturnType<typeof mission.missionProgress>>;
-}
-
-export function buildMissionProgressProjection(workspacePath: string): MissionProgressProjection {
-  const missions = store.list(workspacePath, 'mission')
-    .map((entry) => mission.missionProgress(workspacePath, entry.path));
-  const completedMissions = missions.filter((entry) => entry.percentComplete >= 100 || entry.status === 'completed').length;
-  const averageCompletionPercent = missions.length === 0
-    ? 0
-    : Math.round((missions.reduce((sum, entry) => sum + entry.percentComplete, 0) / missions.length) * 100) / 100;
-  return {
-    scope: 'mission',
-    generatedAt: new Date().toISOString(),
-    healthy: true,
-    summary: {
-      totalMissions: missions.length,
-      completedMissions,
-      averageCompletionPercent,
-    },
-    missions,
-  };
-}
diff --git a/packages/kernel/src/projections/projections.test.ts b/packages/kernel/src/projections/projections.test.ts
deleted file mode 100644
index 28af50c..0000000
--- a/packages/kernel/src/projections/projections.test.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as dispatch from '../dispatch.js';
-import * as federation from '../federation.js';
-import { saveRegistry, loadRegistry } from '../registry.js';
-import * as store from '../store.js';
-import * as thread from '../thread.js';
-import * as transport from '../transport/index.js';
-import * as projections from './index.js';
-
-let workspacePath: string;
-let remoteWorkspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-projections-'));
-  remoteWorkspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-projections-remote-'));
-  saveRegistry(workspacePath, loadRegistry(workspacePath));
-  saveRegistry(remoteWorkspacePath, loadRegistry(remoteWorkspacePath));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-  fs.rmSync(remoteWorkspacePath, { recursive: true, force: true });
-});
-
-describe('projection builders', () => {
-  it('builds stable run, risk, transport, federation, trigger, and autonomy projections', () => {
-    const blockedThread = thread.createThread(workspacePath, 'Blocked projection thread', 'blocked work', 'agent-a');
-    thread.claim(workspacePath, blockedThread.path, 'agent-a');
-    thread.block(workspacePath, blockedThread.path, 'agent-a', 'external/dependency', 'waiting');
-
-    const run = dispatch.createRun(workspacePath, {
-      actor: 'agent-a',
-      objective: 'Projection run',
-    });
-    dispatch.markRun(workspacePath, run.id, 'agent-a', 'running');
-    dispatch.markRun(workspacePath, run.id, 'agent-a', 'failed', {
-      error: 'failed run',
-    });
-
-    const envelope = transport.createTransportEnvelope({
-      direction: 'outbound',
-      channel: 'test',
-      topic: 'projection',
-      source: 'test',
-      target: 'target',
-      payload: {
-        ok: true,
-      },
-    });
-    const outbox = transport.createTransportOutboxRecord(workspacePath, {
-      envelope,
-      deliveryHandler: 'test',
-      deliveryTarget: 'target',
-    });
-    transport.markTransportOutboxFailed(workspacePath, outbox.id, {
-      message: 'delivery failed',
-    });
-
-    federation.ensureFederationConfig(remoteWorkspacePath);
-    thread.createThread(remoteWorkspacePath, 'Remote projection thread', 'remote work', 'agent-remote');
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-    });
-
-    store.create(workspacePath, 'trigger', {
-      title: 'Projection trigger',
-      status: 'active',
-      condition: { type: 'manual' },
-      action: {
-        type: 'dispatch-run',
-        objective: 'Projection trigger run',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const runHealth = projections.buildRunHealthProjection(workspacePath);
-    expect(runHealth.summary.totalRuns).toBeGreaterThan(0);
-
-    const risk = projections.buildRiskDashboardProjection(workspacePath);
-    expect(risk.summary.blockedThreads).toBeGreaterThan(0);
-
-    const transportHealth = projections.buildTransportHealthProjection(workspacePath);
-    expect(transportHealth.summary.deadLetterCount).toBe(1);
-
-    const federationStatus = projections.buildFederationStatusProjection(workspacePath);
-    expect(federationStatus.summary.remotes).toBe(1);
-
-    const triggerHealth = projections.buildTriggerHealthProjection(workspacePath);
-    expect(triggerHealth.summary.totalTriggers).toBe(1);
-
-    const autonomyHealth = projections.buildAutonomyHealthProjection(workspacePath);
-    expect(typeof autonomyHealth.summary.running).toBe('boolean');
-  });
-});
diff --git a/packages/kernel/src/projections/risk-dashboard.ts b/packages/kernel/src/projections/risk-dashboard.ts
deleted file mode 100644
index bf5d757..0000000
--- a/packages/kernel/src/projections/risk-dashboard.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import * as store from '../store.js';
-import * as threadAudit from '../thread-audit.js';
-import type { PrimitiveInstance } from '../types.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface RiskDashboardProjection extends ProjectionSummary {
-  scope: 'org';
-  summary: {
-    blockedThreads: number;
-    escalations: number;
-    policyViolations: number;
-  };
-  blockedThreads: PrimitiveInstance[];
-  escalations: PrimitiveInstance[];
-  policyViolations: ReturnType<typeof threadAudit.reconcileThreadState>['issues'];
-}
-
-export function buildRiskDashboardProjection(workspacePath: string): RiskDashboardProjection {
-  const blockedThreads = store.blockedThreads(workspacePath);
-  const escalations = store.list(workspacePath, 'incident')
-    .filter((entry) => String(entry.fields.status ?? '').toLowerCase() === 'active');
-  const audit = threadAudit.reconcileThreadState(workspacePath);
-  return {
-    scope: 'org',
-    generatedAt: new Date().toISOString(),
-    healthy: audit.issues.length === 0 && blockedThreads.length === 0,
-    summary: {
-      blockedThreads: blockedThreads.length,
-      escalations: escalations.length,
-      policyViolations: audit.issues.length,
-    },
-    blockedThreads,
-    escalations,
-    policyViolations: audit.issues,
-  };
-}
diff --git a/packages/kernel/src/projections/run-health.ts b/packages/kernel/src/projections/run-health.ts
deleted file mode 100644
index 4a6d851..0000000
--- a/packages/kernel/src/projections/run-health.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import * as dispatch from '../dispatch.js';
-import type { DispatchRun } from '../types.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface RunHealthProjection extends ProjectionSummary {
-  scope: 'run';
-  summary: {
-    totalRuns: number;
-    activeRuns: number;
-    queuedRuns: number;
-    staleRuns: number;
-    failedRuns: number;
-    failedReconciliations: number;
-  };
-  activeRuns: DispatchRun[];
-  staleRuns: DispatchRun[];
-  failedRuns: DispatchRun[];
-  failedReconciliations: DispatchRun[];
-}
-
-const DEFAULT_STALE_MINUTES = 30;
-
-export function buildRunHealthProjection(
-  workspacePath: string,
-  options: { staleMinutes?: number } = {},
-): RunHealthProjection {
-  const runs = dispatch.listRuns(workspacePath);
-  const staleCutoff = Date.now() - (Math.max(1, options.staleMinutes ?? DEFAULT_STALE_MINUTES) * 60_000);
-  const activeRuns = runs.filter((run) => run.status === 'running');
-  const queuedRuns = runs.filter((run) => run.status === 'queued');
-  const staleRuns = runs.filter((run) =>
-    (run.status === 'running' || run.status === 'queued')
-    && Date.parse(run.updatedAt) <= staleCutoff,
-  );
-  const failedRuns = runs.filter((run) => run.status === 'failed');
-  const failedReconciliations = runs.filter((run) => Boolean(run.dispatchTracking?.reconciliationError));
-  return {
-    scope: 'run',
-    generatedAt: new Date().toISOString(),
-    healthy: failedReconciliations.length === 0,
-    summary: {
-      totalRuns: runs.length,
-      activeRuns: activeRuns.length,
-      queuedRuns: queuedRuns.length,
-      staleRuns: staleRuns.length,
-      failedRuns: failedRuns.length,
-      failedReconciliations: failedReconciliations.length,
-    },
-    activeRuns,
-    staleRuns,
-    failedRuns,
-    failedReconciliations,
-  };
-}
diff --git a/packages/kernel/src/projections/transport-health.ts b/packages/kernel/src/projections/transport-health.ts
deleted file mode 100644
index 2867fb0..0000000
--- a/packages/kernel/src/projections/transport-health.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import * as transport from '../transport/index.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface TransportHealthProjection extends ProjectionSummary {
-  scope: 'transport';
-  summary: {
-    outboxDepth: number;
-    inboxDepth: number;
-    deadLetterCount: number;
-    deliverySuccessRate: number;
-  };
-  outbox: ReturnType<typeof transport.listTransportOutbox>;
-  inbox: ReturnType<typeof transport.listTransportInbox>;
-  deadLetters: ReturnType<typeof transport.listTransportDeadLetters>;
-}
-
-export function buildTransportHealthProjection(workspacePath: string): TransportHealthProjection {
-  const outbox = transport.listTransportOutbox(workspacePath);
-  const inbox = transport.listTransportInbox(workspacePath);
-  const deadLetters = transport.listTransportDeadLetters(workspacePath);
-  const deliveryAttempts = outbox.flatMap((record) => record.attempts);
-  const deliveredAttempts = deliveryAttempts.filter((entry) => entry.status === 'delivered').length;
-  const failedAttempts = deliveryAttempts.filter((entry) => entry.status === 'failed').length;
-  const denominator = deliveredAttempts + failedAttempts;
-  const deliverySuccessRate = denominator === 0 ? 100 : Math.round((deliveredAttempts / denominator) * 10_000) / 100;
-  return {
-    scope: 'transport',
-    generatedAt: new Date().toISOString(),
-    healthy: deadLetters.length === 0,
-    summary: {
-      outboxDepth: outbox.length,
-      inboxDepth: inbox.length,
-      deadLetterCount: deadLetters.length,
-      deliverySuccessRate,
-    },
-    outbox,
-    inbox,
-    deadLetters,
-  };
-}
diff --git a/packages/kernel/src/projections/trigger-health.ts b/packages/kernel/src/projections/trigger-health.ts
deleted file mode 100644
index d3ba29f..0000000
--- a/packages/kernel/src/projections/trigger-health.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import * as triggerEngine from '../trigger-engine.js';
-import type { ProjectionSummary } from './types.js';
-
-export interface TriggerHealthProjection extends ProjectionSummary {
-  scope: 'trigger';
-  summary: {
-    totalTriggers: number;
-    errorTriggers: number;
-    cooldownTriggers: number;
-  };
-  dashboard: ReturnType<typeof triggerEngine.triggerDashboard>;
-}
-
-export function buildTriggerHealthProjection(workspacePath: string): TriggerHealthProjection {
-  const dashboard = triggerEngine.triggerDashboard(workspacePath);
-  const errorTriggers = dashboard.triggers.filter((entry) => entry.currentState === 'error').length;
-  const cooldownTriggers = dashboard.triggers.filter((entry) => entry.currentState === 'cooldown').length;
-  return {
-    scope: 'trigger',
-    generatedAt: new Date().toISOString(),
-    healthy: errorTriggers === 0,
-    summary: {
-      totalTriggers: dashboard.triggers.length,
-      errorTriggers,
-      cooldownTriggers,
-    },
-    dashboard,
-  };
-}
diff --git a/packages/kernel/src/projections/types.ts b/packages/kernel/src/projections/types.ts
deleted file mode 100644
index 239bc84..0000000
--- a/packages/kernel/src/projections/types.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-export interface ProjectionTimeRange {
-  from?: string;
-  to?: string;
-}
-
-export interface ProjectionFilters {
-  status?: string[];
-  owner?: string[];
-  tags?: string[];
-  space?: string;
-}
-
-export interface ProjectionQuery {
-  scope: 'thread' | 'mission' | 'org' | 'run' | 'transport' | 'federation' | 'trigger' | 'autonomy';
-  timeRange?: ProjectionTimeRange;
-  filters?: ProjectionFilters;
-}
-
-export interface ProjectionSummary {
-  healthy: boolean;
-  generatedAt: string;
-  scope: ProjectionQuery['scope'];
-}
diff --git a/packages/kernel/src/query/engine.ts b/packages/kernel/src/query/engine.ts
deleted file mode 100644
index 7ff9b74..0000000
--- a/packages/kernel/src/query/engine.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { queryPrimitives, keywordSearch } from '../query.js';
diff --git a/packages/kernel/src/query/filters.ts b/packages/kernel/src/query/filters.ts
deleted file mode 100644
index b92eb27..0000000
--- a/packages/kernel/src/query/filters.ts
+++ /dev/null
@@ -1 +0,0 @@
-export type { PrimitiveQueryFilters } from '../types.js';
diff --git a/packages/kernel/src/reconciler-runs.test.ts b/packages/kernel/src/reconciler-runs.test.ts
deleted file mode 100644
index e36f69b..0000000
--- a/packages/kernel/src/reconciler-runs.test.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import matter from 'gray-matter';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import * as dispatch from './dispatch.js';
-import * as reconciler from './reconciler.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-
-let workspacePath: string;
-
-function mockResponse(options: { ok: boolean; status: number; text: string; statusText?: string }): Response {
-  return {
-    ok: options.ok,
-    status: options.status,
-    statusText: options.statusText ?? '',
-    text: async () => options.text,
-  } as Response;
-}
-
-describe('dispatch run reconciler', () => {
-  const fetchMock = vi.fn();
-
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-reconciler-runs-'));
-    saveRegistry(workspacePath, loadRegistry(workspacePath));
-    registerDefaultDispatchAdaptersIntoKernelRegistry();
-    vi.restoreAllMocks();
-    fetchMock.mockReset();
-    vi.stubGlobal('fetch', fetchMock);
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-  });
-
-  it('dispatches externally, survives restart, and reconciles to completion', async () => {
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 202,
-      text: JSON.stringify({
-        id: 'cursor-agent-123',
-        status: 'queued',
-      }),
-    }));
-
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-broker',
-      adapter: 'cursor-cloud',
-      objective: 'Reconcile external cursor run',
-      context: {
-        external_broker_mode: true,
-        cursor_cloud_api_base_url: 'https://cursor.example/api',
-      },
-    });
-
-    const dispatched = await dispatch.executeRun(workspacePath, created.id, {
-      actor: 'agent-broker',
-      timeoutMs: 1_000,
-    });
-
-    expect(dispatched.status).toBe('queued');
-    expect(dispatched.external?.externalRunId).toBe('cursor-agent-123');
-    expect(dispatched.dispatchTracking?.retryCount).toBe(1);
-
-    const brokerPath = path.join(workspacePath, '.workgraph', 'dispatch-broker', `${created.id}.md`);
-    expect(fs.existsSync(brokerPath)).toBe(true);
-    const brokerParsed = matter(fs.readFileSync(brokerPath, 'utf-8'));
-    expect((brokerParsed.data as Record<string, unknown>).external).toMatchObject({
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-123',
-    });
-
-    const runPrimitivePath = path.join(workspacePath, 'runs', `${created.id}.md`);
-    const runPrimitive = matter(fs.readFileSync(runPrimitivePath, 'utf-8'));
-    expect((runPrimitive.data as Record<string, unknown>).external).toMatchObject({
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-123',
-    });
-
-    const restarted = dispatch.status(workspacePath, created.id);
-    expect(restarted.external?.externalRunId).toBe('cursor-agent-123');
-    expect(restarted.status).toBe('queued');
-
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 200,
-      text: JSON.stringify({
-        status: 'succeeded',
-        output: 'external reconciliation complete',
-        updatedAt: '2026-03-11T10:00:00.000Z',
-      }),
-    }));
-
-    const reconciled = await reconciler.reconcileDispatchRuns(workspacePath, 'agent-broker', {
-      runId: created.id,
-    });
-
-    expect(reconciled.external.inspectedRuns).toBe(1);
-    expect(reconciled.external.reconciledRuns[0]?.id).toBe(created.id);
-
-    const finished = dispatch.status(workspacePath, created.id);
-    expect(finished.status).toBe('succeeded');
-    expect(finished.output).toBe('external reconciliation complete');
-    expect(finished.external?.lastKnownStatus).toBe('succeeded');
-    expect(finished.dispatchTracking?.lastReconciledAt).toBeTruthy();
-
-    const refreshedPrimitive = matter(fs.readFileSync(runPrimitivePath, 'utf-8'));
-    expect((refreshedPrimitive.data as Record<string, unknown>).status).toBe('succeeded');
-    expect((refreshedPrimitive.data as Record<string, unknown>).external).toMatchObject({
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-123',
-      lastKnownStatus: 'succeeded',
-    });
-  });
-
-  it('records cancellation requests durably and reconciles cancellation acknowledgements', async () => {
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 202,
-      text: JSON.stringify({
-        id: 'cursor-agent-cancel-1',
-        status: 'running',
-      }),
-    }));
-
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-broker',
-      adapter: 'cursor-cloud',
-      objective: 'Cancel external cursor run',
-      context: {
-        external_broker_mode: true,
-        cursor_cloud_api_base_url: 'https://cursor.example/api',
-      },
-    });
-
-    await dispatch.executeRun(workspacePath, created.id, {
-      actor: 'agent-broker',
-      timeoutMs: 1_000,
-    });
-
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 202,
-      text: JSON.stringify({
-        status: 'cancelled',
-      }),
-    }));
-
-    const requested = dispatch.stop(workspacePath, created.id, 'agent-broker');
-    expect(requested.dispatchTracking?.cancellationRequestedAt).toBeTruthy();
-
-    await vi.waitFor(() => {
-      expect(dispatch.status(workspacePath, created.id).status).toBe('cancelled');
-    });
-
-    const cancelled = dispatch.status(workspacePath, created.id);
-    expect(cancelled.dispatchTracking?.cancellationAcknowledgedAt).toBeTruthy();
-    expect(cancelled.status).toBe('cancelled');
-  });
-
-  it('matches inbound external reconciliation payloads by provider and external run id', async () => {
-    fetchMock.mockResolvedValueOnce(mockResponse({
-      ok: true,
-      status: 202,
-      text: JSON.stringify({
-        id: 'cursor-agent-match-1',
-        status: 'queued',
-      }),
-    }));
-
-    const created = dispatch.createRun(workspacePath, {
-      actor: 'agent-broker',
-      adapter: 'cursor-cloud',
-      objective: 'Match inbound external event',
-      context: {
-        external_broker_mode: true,
-        cursor_cloud_api_base_url: 'https://cursor.example/api',
-      },
-    });
-
-    await dispatch.executeRun(workspacePath, created.id, {
-      actor: 'agent-broker',
-      timeoutMs: 1_000,
-    });
-
-    const reconciled = dispatch.reconcileExternalRun(workspacePath, {
-      actor: 'agent-broker',
-      provider: 'cursor-cloud',
-      externalRunId: 'cursor-agent-match-1',
-      status: 'failed',
-      error: 'provider reported failure',
-      source: 'event',
-    });
-
-    expect(reconciled.matchedRunId).toBe(created.id);
-    expect(reconciled.currentStatus).toBe('failed');
-    expect(dispatch.status(workspacePath, created.id).error).toBe('provider reported failure');
-  });
-});
diff --git a/packages/kernel/src/reconciler.test.ts b/packages/kernel/src/reconciler.test.ts
deleted file mode 100644
index 3a43b59..0000000
--- a/packages/kernel/src/reconciler.test.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import matter from 'gray-matter';
-import * as ledger from './ledger.js';
-import * as registry from './registry.js';
-import { reconcile } from './reconciler.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-reconciler-'));
-  registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('board reconciler', () => {
-  it('returns ok=true for a compliant workspace', () => {
-    const task = thread.createThread(workspacePath, 'Compliant task', 'do compliant work', 'agent-a');
-    thread.claim(workspacePath, task.path, 'agent-a');
-    thread.done(workspacePath, task.path, 'agent-a', 'proof https://github.com/versatly/workgraph/pull/61');
-
-    const report = reconcile(workspacePath);
-    expect(report.ok).toBe(true);
-    expect(report.violations).toEqual([]);
-  });
-
-  it('detects missing T-ID violations', () => {
-    store.create(workspacePath, 'thread', {
-      title: 'Legacy thread',
-      goal: 'legacy goal',
-      status: 'open',
-      priority: 'medium',
-      deps: [],
-      context_refs: [],
-      tags: [],
-      terminalLock: true,
-    }, '# Legacy', 'agent-a', { pathOverride: 'threads/legacy-thread.md' });
-
-    const report = reconcile(workspacePath);
-    expect(report.ok).toBe(false);
-    expect(report.violations.some((entry) => entry.code === 'missing_tid')).toBe(true);
-  });
-
-  it('flags orphan thread ledger entries', () => {
-    ledger.append(workspacePath, 'agent-a', 'claim', 'threads/missing-thread.md', 'thread');
-
-    const report = reconcile(workspacePath);
-    expect(report.ok).toBe(false);
-    expect(report.violations.some((entry) => entry.code === 'orphan_ledger_entry')).toBe(true);
-  });
-
-  it('reports evidence policy violations for done threads with missing evidence', () => {
-    const task = thread.createThread(workspacePath, 'Manual done mismatch', 'manual done', 'agent-a');
-    thread.claim(workspacePath, task.path, 'agent-a');
-    ledger.append(workspacePath, 'agent-a', 'done', task.path, 'thread');
-    store.update(workspacePath, task.path, { status: 'done' }, undefined, 'agent-a');
-
-    const report = reconcile(workspacePath);
-    expect(report.violations.some((entry) => entry.code === 'evidence_policy_violation')).toBe(true);
-  });
-
-  it('reports dependency gate violations for done parents with open descendants', () => {
-    const parent = thread.createThread(workspacePath, 'Done parent with open child', 'parent goal', 'agent-a');
-    thread.decompose(workspacePath, parent.path, [{ title: 'Open child', goal: 'child goal' }], 'agent-a');
-    ledger.append(workspacePath, 'agent-a', 'done', parent.path, 'thread', {
-      evidence_policy: 'strict',
-      evidence: [{ type: 'url', value: 'https://github.com/versatly/workgraph/pull/62' }],
-    });
-    store.update(workspacePath, parent.path, { status: 'done' }, undefined, 'agent-a');
-
-    const report = reconcile(workspacePath);
-    expect(report.violations.some((entry) => entry.code === 'dependency_gate_violation')).toBe(true);
-  });
-
-  it('reports terminal lock violations when non-reopen ops follow done', () => {
-    const task = thread.createThread(workspacePath, 'Terminal lock break', 'lock break', 'agent-a');
-    thread.claim(workspacePath, task.path, 'agent-a');
-    thread.done(workspacePath, task.path, 'agent-a', 'proof https://github.com/versatly/workgraph/pull/63');
-    ledger.append(workspacePath, 'agent-a', 'block', task.path, 'thread', { blocked_by: 'external/dep' });
-
-    const report = reconcile(workspacePath);
-    expect(report.violations.some((entry) => entry.code === 'terminal_lock_violation')).toBe(true);
-  });
-
-  it('reports reopen entries missing required reason', () => {
-    const task = thread.createThread(workspacePath, 'Missing reopen reason', 'reopen reason', 'agent-a');
-    thread.claim(workspacePath, task.path, 'agent-a');
-    thread.done(workspacePath, task.path, 'agent-a', 'proof https://github.com/versatly/workgraph/pull/64');
-    ledger.append(workspacePath, 'agent-a', 'reopen', task.path, 'thread');
-
-    const report = reconcile(workspacePath);
-    expect(report.violations.some((entry) => entry.code === 'reopen_missing_reason')).toBe(true);
-  });
-
-  it('detects status mismatches without supporting ledger transitions', () => {
-    const task = thread.createThread(workspacePath, 'Manual status mutate', 'manual mutate', 'agent-a');
-    const absPath = path.join(workspacePath, task.path);
-    const parsed = matter(fs.readFileSync(absPath, 'utf-8'));
-    const frontmatter = parsed.data as Record<string, unknown>;
-    frontmatter.status = 'blocked';
-    fs.writeFileSync(absPath, matter.stringify(parsed.content, frontmatter), 'utf-8');
-
-    const report = reconcile(workspacePath);
-    expect(report.violations.some((entry) => entry.code === 'status_transition_missing_ledger')).toBe(true);
-  });
-
-  it('emits warning when tid does not match file slug', () => {
-    store.create(workspacePath, 'thread', {
-      tid: 'custom-tid',
-      title: 'Path mismatch thread',
-      goal: 'goal',
-      status: 'open',
-      priority: 'medium',
-      deps: [],
-      context_refs: [],
-      tags: [],
-      terminalLock: true,
-    }, '# Mismatch', 'agent-a', { pathOverride: 'threads/different-slug.md' });
-
-    const report = reconcile(workspacePath);
-    expect(report.warnings.some((entry) => entry.code === 'tid_path_mismatch')).toBe(true);
-  });
-});
diff --git a/packages/kernel/src/reconciler.ts b/packages/kernel/src/reconciler.ts
deleted file mode 100644
index 7ab89d0..0000000
--- a/packages/kernel/src/reconciler.ts
+++ /dev/null
@@ -1,333 +0,0 @@
-import * as dispatch from './dispatch.js';
-import * as gate from './gate.js';
-import * as ledger from './ledger.js';
-import * as store from './store.js';
-import { collectThreadEvidence, validateThreadEvidence } from './evidence.js';
-import type {
-  LedgerEntry,
-  ReconcileIssue,
-  ReconcileReport,
-  ThreadEvidenceInput,
-  ThreadEvidenceType,
-  ThreadStatus,
-} from './types.js';
-
-const THREAD_STATUSES: ThreadStatus[] = ['open', 'active', 'blocked', 'done', 'cancelled'];
-
-export interface DispatchRunReconcileReport {
-  reconciledAt: string;
-  lease: dispatch.DispatchReconcileResult;
-  external: dispatch.DispatchPollExternalRunsResult;
-}
-
-export function reconcile(workspacePath: string): ReconcileReport {
-  const violations: ReconcileIssue[] = [];
-  const warnings: ReconcileIssue[] = [];
-  const entries = ledger.readAll(workspacePath);
-  const threads = store.list(workspacePath, 'thread');
-  const threadByPath = new Map(threads.map((thread) => [thread.path, thread]));
-
-  for (const thread of threads) {
-    const history = entries.filter((entry) => entry.target === thread.path);
-    const currentStatus = normalizeStatus(thread.fields.status);
-    const terminalLock = asBoolean(thread.fields.terminalLock, true);
-
-    const tid = String(thread.fields.tid ?? '').trim();
-    if (!tid) {
-      violations.push(issue(
-        'missing_tid',
-        thread.path,
-        'Thread is missing a T-ID (`tid`) field.',
-      ));
-    } else {
-      if (!isKebabCase(tid)) {
-        violations.push(issue(
-          'invalid_tid',
-          thread.path,
-          `Thread T-ID "${tid}" must be kebab-case.`,
-        ));
-      }
-      const slug = fileSlug(thread.path);
-      if (slug && slug !== tid) {
-        warnings.push(issue(
-          'tid_path_mismatch',
-          thread.path,
-          `Thread T-ID "${tid}" does not match path slug "${slug}".`,
-        ));
-      }
-    }
-
-    if (history.length === 0) {
-      violations.push(issue(
-        'thread_without_ledger_history',
-        thread.path,
-        'Thread has no ledger history entries.',
-      ));
-    } else {
-      const derivedStatus = deriveStatusFromLedger(history);
-      if (derivedStatus && currentStatus && derivedStatus !== currentStatus) {
-        violations.push(issue(
-          'status_transition_missing_ledger',
-          thread.path,
-          `Thread status is "${currentStatus}" but ledger replay resolves to "${derivedStatus}".`,
-          {
-            currentStatus,
-            derivedStatus,
-          },
-        ));
-      }
-    }
-
-    if (currentStatus === 'done') {
-      const latestDoneEntry = [...history].reverse().find((entry) => entry.op === 'done');
-      if (!latestDoneEntry) {
-        violations.push(issue(
-          'done_without_ledger_entry',
-          thread.path,
-          'Thread is done but has no done ledger entry.',
-        ));
-      } else {
-        const policy = gate.resolveThreadEvidencePolicy(workspacePath, thread);
-        const doneEvidence = parseLedgerEvidence(latestDoneEntry.data?.evidence);
-        const validation = validateThreadEvidence(doneEvidence, policy);
-        if (!validation.ok) {
-          violations.push(issue(
-            'evidence_policy_violation',
-            thread.path,
-            `Done evidence does not satisfy policy "${policy}".`,
-            {
-              policy,
-              validEvidence: validation.validEvidence.map((entry) => ({ type: entry.type, value: entry.value })),
-              invalidEvidence: validation.invalidEvidence.map((entry) => ({
-                type: entry.type,
-                value: entry.value,
-                reason: entry.reason,
-              })),
-            },
-          ));
-        }
-      }
-
-      const descendantGate = gate.checkRequiredDescendants(workspacePath, thread.path);
-      if (!descendantGate.ok) {
-        violations.push(issue(
-          'dependency_gate_violation',
-          thread.path,
-          descendantGate.message,
-          {
-            unresolvedDescendants: descendantGate.unresolvedDescendants,
-          },
-        ));
-      }
-    }
-
-    if (terminalLock) {
-      const lockIssues = checkTerminalLockHistory(thread.path, history);
-      violations.push(...lockIssues);
-    }
-  }
-
-  for (const entry of entries) {
-    const threadTarget = normalizeThreadTarget(entry);
-    if (!threadTarget) continue;
-    if (threadByPath.has(threadTarget)) continue;
-    violations.push(issue(
-      'orphan_ledger_entry',
-      threadTarget,
-      `Ledger entry ${entry.op} references missing thread target "${threadTarget}".`,
-      {
-        ts: entry.ts,
-        actor: entry.actor,
-        op: entry.op,
-      },
-    ));
-  }
-
-  return {
-    violations,
-    warnings,
-    ok: violations.length === 0,
-  };
-}
-
-export async function reconcileDispatchRuns(
-  workspacePath: string,
-  actor: string,
-  options: { runId?: string } = {},
-): Promise<DispatchRunReconcileReport> {
-  const lease = dispatch.reconcileExpiredLeases(workspacePath, actor);
-  const external = await dispatch.pollExternalRuns(workspacePath, actor, options);
-  return {
-    reconciledAt: new Date().toISOString(),
-    lease,
-    external,
-  };
-}
-
-export function reconcileExternalRun(
-  workspacePath: string,
-  input: dispatch.DispatchExternalReconcileInput,
-): dispatch.DispatchExternalReconcileResult {
-  return dispatch.reconcileExternalRun(workspacePath, input);
-}
-
-function checkTerminalLockHistory(threadPath: string, history: LedgerEntry[]): ReconcileIssue[] {
-  const issues: ReconcileIssue[] = [];
-  let lockActive = false;
-
-  for (const entry of history) {
-    if (entry.op === 'done') {
-      lockActive = true;
-      continue;
-    }
-
-    if (!lockActive) continue;
-    if (entry.op === 'reopen') {
-      const reason = String(entry.data?.reason ?? '').trim();
-      if (!reason) {
-        issues.push(issue(
-          'reopen_missing_reason',
-          threadPath,
-          'Reopen entry is missing required reason after done terminal state.',
-          { ts: entry.ts },
-        ));
-      }
-      lockActive = false;
-      continue;
-    }
-    if (entry.op === 'rejected') {
-      continue;
-    }
-    if (entry.op === 'update' && String(entry.data?.to_status ?? '') === 'done') {
-      continue;
-    }
-
-    issues.push(issue(
-      'terminal_lock_violation',
-      threadPath,
-      `Operation "${entry.op}" occurred after done without reopen.`,
-      {
-        ts: entry.ts,
-        actor: entry.actor,
-      },
-    ));
-  }
-
-  return issues;
-}
-
-function parseLedgerEvidence(raw: unknown): ReturnType<typeof collectThreadEvidence> {
-  if (!Array.isArray(raw) || raw.length === 0) return [];
-  const inputs: ThreadEvidenceInput[] = [];
-  for (const item of raw) {
-    if (typeof item === 'string') {
-      inputs.push(item);
-      continue;
-    }
-    if (!item || typeof item !== 'object') continue;
-    const value = 'value' in item ? String((item as { value?: unknown }).value ?? '').trim() : '';
-    if (!value) continue;
-    const rawType = 'type' in item ? String((item as { type?: unknown }).type ?? '').trim() : undefined;
-    const type = normalizeEvidenceType(rawType);
-    inputs.push(type ? { type, value } : { value });
-  }
-  return collectThreadEvidence(undefined, inputs);
-}
-
-function normalizeEvidenceType(value: string | undefined): ThreadEvidenceType | undefined {
-  switch (value) {
-    case 'url':
-    case 'attachment':
-    case 'thread-ref':
-    case 'reply-ref':
-      return value;
-    default:
-      return undefined;
-  }
-}
-
-function normalizeStatus(value: unknown): ThreadStatus | null {
-  const status = String(value ?? '').trim() as ThreadStatus;
-  return THREAD_STATUSES.includes(status) ? status : null;
-}
-
-function deriveStatusFromLedger(history: LedgerEntry[]): ThreadStatus | null {
-  let status: ThreadStatus | null = null;
-  for (const entry of history) {
-    switch (entry.op) {
-      case 'create': {
-        const createdStatus = normalizeStatus(entry.data?.status);
-        status = createdStatus ?? 'open';
-        break;
-      }
-      case 'claim':
-      case 'unblock':
-        status = 'active';
-        break;
-      case 'block':
-        status = 'blocked';
-        break;
-      case 'done':
-        status = 'done';
-        break;
-      case 'cancel':
-        status = 'cancelled';
-        break;
-      case 'release':
-      case 'reopen':
-        status = 'open';
-        break;
-      case 'update': {
-        const toStatus = normalizeStatus(entry.data?.to_status);
-        if (toStatus) status = toStatus;
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  return status;
-}
-
-function normalizeThreadTarget(entry: LedgerEntry): string | null {
-  if (entry.type === 'thread') return entry.target;
-  const target = String(entry.target ?? '');
-  if (!target.startsWith('threads/')) return null;
-  if (!target.endsWith('.md')) return `${target}.md`;
-  return target;
-}
-
-function issue(
-  code: string,
-  target: string,
-  message: string,
-  details?: Record<string, unknown>,
-): ReconcileIssue {
-  return {
-    code,
-    target,
-    message,
-    ...(details ? { details } : {}),
-  };
-}
-
-function isKebabCase(value: string): boolean {
-  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
-}
-
-function fileSlug(relPath: string): string {
-  const normalized = relPath.replace(/\\/g, '/');
-  const basename = normalized.split('/').pop() ?? '';
-  return basename.endsWith('.md') ? basename.slice(0, -3) : basename;
-}
-
-function asBoolean(value: unknown, fallback: boolean): boolean {
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'number') return value !== 0;
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true' || normalized === '1' || normalized === 'yes') return true;
-    if (normalized === 'false' || normalized === '0' || normalized === 'no') return false;
-  }
-  return fallback;
-}
diff --git a/packages/kernel/src/registry.test.ts b/packages/kernel/src/registry.test.ts
index 7b9bac7..bfc430c 100644
--- a/packages/kernel/src/registry.test.ts
+++ b/packages/kernel/src/registry.test.ts
@@ -22,23 +22,16 @@ describe('registry', () => {
     expect(reg.types.thread).toBeDefined();
     expect(reg.types.space).toBeDefined();
     expect(reg.types.decision).toBeDefined();
-    expect(reg.types.lesson).toBeDefined();
+    expect(reg.types.org).toBeDefined();
     expect(reg.types.fact).toBeDefined();
     expect(reg.types.agent).toBeDefined();
     expect(reg.types.presence).toBeDefined();
-    expect(reg.types.person).toBeDefined();
-    expect(reg.types.project).toBeDefined();
-    expect(reg.types.client).toBeDefined();
-    expect(reg.types.org).toBeDefined();
-    expect(reg.types.team).toBeDefined();
-    expect(reg.types.pattern).toBeDefined();
     expect(reg.types.relationship).toBeDefined();
-    expect(reg.types.strategic_note).toBeDefined();
-    expect(reg.types.mission).toBeDefined();
     expect(reg.types.conversation).toBeDefined();
     expect(reg.types['plan-step']).toBeDefined();
-    expect(reg.types.skill).toBeDefined();
-    expect(reg.types.onboarding).toBeDefined();
+    expect(reg.types.policy).toBeDefined();
+    expect(reg.types['policy-gate']).toBeDefined();
+    expect(reg.types.checkpoint).toBeDefined();
     expect(reg.types.thread.builtIn).toBe(true);
   });
 
@@ -46,12 +39,10 @@ describe('registry', () => {
     const reg = loadRegistry(workspacePath);
     expect(reg.types.decision.fields.decided_by).toBeDefined();
     expect(reg.types.decision.fields.context_refs).toBeDefined();
-    expect(reg.types.lesson.fields.severity).toBeDefined();
-    expect(reg.types.person.fields.communication_preference).toBeDefined();
     expect(reg.types.agent.fields.permissions).toBeDefined();
-    expect(reg.types.client.fields.key_contacts).toBeDefined();
-    expect(reg.types.project.fields.priority).toBeDefined();
     expect(reg.types.policy.fields.scope_type).toBeDefined();
+    expect(reg.types.relationship.fields.strength).toBeDefined();
+    expect(reg.types.checkpoint.fields.summary).toBeDefined();
   });
 
   it('persists registry to disk', () => {
diff --git a/packages/kernel/src/registry.ts b/packages/kernel/src/registry.ts
index 0f8c632..e310dbe 100644
--- a/packages/kernel/src/registry.ts
+++ b/packages/kernel/src/registry.ts
@@ -607,6 +607,22 @@ const BUILT_IN_TYPES: PrimitiveTypeDefinition[] = [
   },
 ];
 
+const RETAINED_BUILT_IN_TYPE_NAMES = new Set([
+  'thread',
+  'space',
+  'decision',
+  'org',
+  'fact',
+  'relationship',
+  'agent',
+  'presence',
+  'conversation',
+  'plan-step',
+  'policy',
+  'policy-gate',
+  'checkpoint',
+]);
+
 // ---------------------------------------------------------------------------
 // Registry operations
 // ---------------------------------------------------------------------------
@@ -728,13 +744,20 @@ export function extendType(
 function seedRegistry(): Registry {
   const types: Record<string, PrimitiveTypeDefinition> = {};
   for (const t of BUILT_IN_TYPES) {
+    if (!RETAINED_BUILT_IN_TYPE_NAMES.has(t.name)) continue;
     types[t.name] = t;
   }
   return { version: CURRENT_VERSION, types };
 }
 
 function ensureBuiltIns(registry: Registry): Registry {
+  for (const [typeName, typeDef] of Object.entries(registry.types)) {
+    if (typeDef.builtIn && !RETAINED_BUILT_IN_TYPE_NAMES.has(typeName)) {
+      delete registry.types[typeName];
+    }
+  }
   for (const t of BUILT_IN_TYPES) {
+    if (!RETAINED_BUILT_IN_TYPE_NAMES.has(t.name)) continue;
     if (!registry.types[t.name]) {
       registry.types[t.name] = t;
       continue;
@@ -752,9 +775,5 @@ function ensureBuiltIns(registry: Registry): Registry {
       };
     }
   }
-  // Remove deprecated skill transport field to keep schema infrastructure-agnostic.
-  if (registry.types.skill?.builtIn && 'tailscale_path' in registry.types.skill.fields) {
-    delete registry.types.skill.fields.tailscale_path;
-  }
   return registry;
 }
diff --git a/packages/kernel/src/runtime-adapter-contracts.test.ts b/packages/kernel/src/runtime-adapter-contracts.test.ts
deleted file mode 100644
index f1e3de3..0000000
--- a/packages/kernel/src/runtime-adapter-contracts.test.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest';
-import type { RunStatus } from './types.js';
-import type {
-  DispatchAdapter,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterRunStatus,
-} from './runtime-adapter-contracts.js';
-
-function makeExecutionInput(overrides: Partial<DispatchAdapterExecutionInput> = {}): DispatchAdapterExecutionInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run-contracts-1',
-    actor: 'agent-contracts',
-    objective: 'Validate adapter contract',
-    context: {
-      source: 'unit-test',
-    },
-    ...overrides,
-  };
-}
-
-describe('runtime adapter contracts', () => {
-  it('keeps dispatch run status aligned with shared RunStatus type', () => {
-    expectTypeOf<DispatchAdapterRunStatus['status']>().toEqualTypeOf<RunStatus>();
-  });
-
-  it('supports fully typed adapter implementations at runtime', async () => {
-    const adapter: DispatchAdapter = {
-      name: 'contract-test',
-      async create(input) {
-        return {
-          runId: `${input.actor}-run`,
-          status: 'queued',
-        };
-      },
-      async status(runId) {
-        return { runId, status: 'running' };
-      },
-      async followup(runId) {
-        return { runId, status: 'running' };
-      },
-      async stop(runId) {
-        return { runId, status: 'cancelled' };
-      },
-      async logs() {
-        return [
-          {
-            ts: '2026-01-01T00:00:00.000Z',
-            level: 'info',
-            message: 'log entry',
-          },
-        ];
-      },
-      async execute(input): Promise<DispatchAdapterExecutionResult> {
-        return {
-          status: 'succeeded',
-          output: `${input.actor}:${input.objective}`,
-          logs: [
-            {
-              ts: '2026-01-01T00:00:01.000Z',
-              level: 'info',
-              message: `executed ${input.runId}`,
-            },
-          ],
-          metrics: {
-            adapter: 'contract-test',
-          },
-        };
-      },
-    };
-
-    const input = makeExecutionInput();
-    const created = await adapter.create({ actor: input.actor, objective: input.objective, context: input.context });
-    const followed = await adapter.followup(created.runId, input.actor, 'continue');
-    const stopped = await adapter.stop(created.runId, input.actor);
-    const logs = await adapter.logs(created.runId);
-    const result = await adapter.execute!(input);
-
-    expect(created.status).toBe('queued');
-    expect(followed.status).toBe('running');
-    expect(stopped.status).toBe('cancelled');
-    expect(logs[0]?.level).toBe('info');
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('agent-contracts:Validate adapter contract');
-    expect(result.metrics?.adapter).toBe('contract-test');
-  });
-});
diff --git a/packages/kernel/src/runtime-adapter-contracts.ts b/packages/kernel/src/runtime-adapter-contracts.ts
deleted file mode 100644
index d667372..0000000
--- a/packages/kernel/src/runtime-adapter-contracts.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import type { RunStatus } from './types.js';
-
-export interface DispatchAdapterCreateInput {
-  actor: string;
-  objective: string;
-  idempotencyKey?: string;
-  context?: Record<string, unknown>;
-}
-
-export interface DispatchAdapterRunStatus {
-  runId: string;
-  status: RunStatus;
-}
-
-export interface DispatchAdapterExternalIdentity {
-  provider: string;
-  externalRunId: string;
-  externalAgentId?: string;
-  externalThreadId?: string;
-  correlationKeys?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface DispatchAdapterLogEntry {
-  ts: string;
-  level: 'info' | 'warn' | 'error';
-  message: string;
-}
-
-export interface DispatchAdapterExecutionInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  agents?: string[];
-  maxSteps?: number;
-  stepDelayMs?: number;
-  space?: string;
-  createCheckpoint?: boolean;
-  isCancelled?: () => boolean;
-  onHeartbeat?: () => Promise<void> | void;
-  abortSignal?: AbortSignal;
-  heartbeatIntervalMs?: number;
-}
-
-export interface DispatchAdapterExecutionResult {
-  status: RunStatus;
-  output?: string;
-  error?: string;
-  logs: DispatchAdapterLogEntry[];
-  metrics?: Record<string, unknown>;
-}
-
-export interface DispatchAdapterDispatchInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  followups?: Array<{
-    ts: string;
-    actor: string;
-    input: string;
-  }>;
-  external?: DispatchAdapterExternalIdentity;
-  abortSignal?: AbortSignal;
-}
-
-export interface DispatchAdapterExternalUpdate {
-  status?: RunStatus;
-  output?: string;
-  error?: string;
-  logs?: DispatchAdapterLogEntry[];
-  metrics?: Record<string, unknown>;
-  external?: DispatchAdapterExternalIdentity;
-  acknowledged?: boolean;
-  acknowledgedAt?: string;
-  lastKnownAt?: string;
-  metadata?: Record<string, unknown>;
-  message?: string;
-}
-
-export interface DispatchAdapterPollInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  external: DispatchAdapterExternalIdentity;
-  abortSignal?: AbortSignal;
-}
-
-export interface DispatchAdapterCancelInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  external?: DispatchAdapterExternalIdentity;
-  abortSignal?: AbortSignal;
-}
-
-export interface DispatchAdapter {
-  name: string;
-  create(input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus>;
-  status(runId: string): Promise<DispatchAdapterRunStatus>;
-  followup(runId: string, actor: string, input: string): Promise<DispatchAdapterRunStatus>;
-  stop(runId: string, actor: string): Promise<DispatchAdapterRunStatus>;
-  logs(runId: string): Promise<DispatchAdapterLogEntry[]>;
-  dispatch?(input: DispatchAdapterDispatchInput): Promise<DispatchAdapterExternalUpdate>;
-  poll?(input: DispatchAdapterPollInput): Promise<DispatchAdapterExternalUpdate | null>;
-  cancel?(input: DispatchAdapterCancelInput): Promise<DispatchAdapterExternalUpdate>;
-  reconcile?(input: DispatchAdapterPollInput & { event?: Record<string, unknown> }): Promise<DispatchAdapterExternalUpdate | null>;
-  health?(): Promise<Record<string, unknown>>;
-  execute?(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
-}
diff --git a/packages/kernel/src/runtime-adapter-registry.test.ts b/packages/kernel/src/runtime-adapter-registry.test.ts
deleted file mode 100644
index 5d01ca4..0000000
--- a/packages/kernel/src/runtime-adapter-registry.test.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import type { DispatchAdapter } from './runtime-adapter-contracts.js';
-import {
-  listDispatchAdapters,
-  registerDispatchAdapter,
-  resolveDispatchAdapter,
-} from './runtime-adapter-registry.js';
-
-let customCounter = 0;
-
-function nextAdapterName(): string {
-  customCounter += 1;
-  return `test-custom-adapter-${customCounter}`;
-}
-
-function makeAdapter(name: string): DispatchAdapter {
-  return {
-    name,
-    async create() {
-      return { runId: `${name}-run`, status: 'queued' };
-    },
-    async status(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async followup(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async stop(runId: string) {
-      return { runId, status: 'cancelled' };
-    },
-    async logs() {
-      return [];
-    },
-  };
-}
-
-describe('runtime adapter registry', () => {
-  it('lists built-in adapters in sorted order', () => {
-    registerDefaultDispatchAdaptersIntoKernelRegistry();
-    const names = listDispatchAdapters();
-    expect(names).toEqual([...names].sort((a, b) => a.localeCompare(b)));
-    expect(names).toEqual(expect.arrayContaining([
-      'claude-code',
-      'cursor-cloud',
-      'http-webhook',
-      'shell-worker',
-    ]));
-  });
-
-  it('resolves built-in adapters with normalized adapter names', () => {
-    registerDefaultDispatchAdaptersIntoKernelRegistry();
-    const adapter = resolveDispatchAdapter('  CLAUDE-Code ');
-    expect(adapter.name).toBe('claude-code');
-  });
-
-  it('registers and resolves custom adapters through normalized names', () => {
-    const adapterName = nextAdapterName();
-    const factory = vi.fn(() => makeAdapter(adapterName));
-
-    registerDispatchAdapter(`  ${adapterName.toUpperCase()} `, factory);
-    const resolvedA = resolveDispatchAdapter(adapterName);
-    const resolvedB = resolveDispatchAdapter(` ${adapterName.toUpperCase()} `);
-
-    expect(factory).toHaveBeenCalledTimes(2);
-    expect(resolvedA.name).toBe(adapterName);
-    expect(resolvedB.name).toBe(adapterName);
-    expect(listDispatchAdapters()).toContain(adapterName);
-  });
-
-  it('throws a helpful error for unknown adapters', () => {
-    expect(() => resolveDispatchAdapter('adapter-that-does-not-exist')).toThrow(
-      'Unknown dispatch adapter "adapter-that-does-not-exist".',
-    );
-  });
-});
diff --git a/packages/kernel/src/runtime-adapter-registry.ts b/packages/kernel/src/runtime-adapter-registry.ts
deleted file mode 100644
index d984132..0000000
--- a/packages/kernel/src/runtime-adapter-registry.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { DispatchAdapter } from './runtime-adapter-contracts.js';
-
-type DispatchAdapterFactory = () => DispatchAdapter;
-
-const adapterFactories = new Map<string, DispatchAdapterFactory>();
-
-export function registerDispatchAdapter(name: string, factory: DispatchAdapterFactory): void {
-  const safeName = normalizeName(name);
-  adapterFactories.set(safeName, factory);
-}
-
-export function resolveDispatchAdapter(name: string): DispatchAdapter {
-  const safeName = normalizeName(name);
-  const factory = adapterFactories.get(safeName);
-  if (!factory) {
-    throw new Error(`Unknown dispatch adapter "${name}". Registered adapters: ${listDispatchAdapters().join(', ') || 'none'}.`);
-  }
-  return factory();
-}
-
-export function listDispatchAdapters(): string[] {
-  return [...adapterFactories.keys()].sort((a, b) => a.localeCompare(b));
-}
-
-function normalizeName(name: string): string {
-  return String(name || '').trim().toLowerCase();
-}
diff --git a/packages/kernel/src/safety.test.ts b/packages/kernel/src/safety.test.ts
deleted file mode 100644
index b23100b..0000000
--- a/packages/kernel/src/safety.test.ts
+++ /dev/null
@@ -1,248 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  SAFETY_CONFIG_FILE,
-  ensureSafetyConfig,
-  evaluateSafety,
-  getSafetyStatus,
-  listSafetyEvents,
-  pauseSafetyOperations,
-  recordOperationOutcome,
-  resetSafetyRails,
-  resumeSafetyOperations,
-  runWithSafetyRails,
-  updateSafetyConfig,
-  loadSafetyConfig,
-} from './safety.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-safety-'));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('safety rails', () => {
-  it('creates default .workgraph/safety.yaml when missing', () => {
-    const config = ensureSafetyConfig(workspacePath);
-    expect(fs.existsSync(path.join(workspacePath, SAFETY_CONFIG_FILE))).toBe(true);
-    expect(config.rateLimit.enabled).toBe(true);
-    expect(config.circuitBreaker.enabled).toBe(true);
-    expect(config.killSwitch.engaged).toBe(false);
-  });
-
-  it('blocks operations when rate limit is exceeded and unblocks after window reset', () => {
-    updateSafetyConfig(workspacePath, 'ops-admin', {
-      rateLimit: {
-        enabled: true,
-        maxOperations: 2,
-        windowSeconds: 60,
-      },
-      circuitBreaker: {
-        enabled: false,
-      },
-    });
-
-    const baseNow = new Date('2026-03-06T10:00:00.000Z');
-    const first = evaluateSafety(workspacePath, {
-      actor: 'auto-1',
-      operation: 'autonomy.cycle',
-      now: baseNow,
-      consume: true,
-    });
-    const second = evaluateSafety(workspacePath, {
-      actor: 'auto-1',
-      operation: 'autonomy.cycle',
-      now: baseNow,
-      consume: true,
-    });
-    const blocked = evaluateSafety(workspacePath, {
-      actor: 'auto-1',
-      operation: 'autonomy.cycle',
-      now: baseNow,
-      consume: true,
-    });
-    const afterWindow = evaluateSafety(workspacePath, {
-      actor: 'auto-1',
-      operation: 'autonomy.cycle',
-      now: new Date(baseNow.getTime() + 61_000),
-      consume: true,
-    });
-
-    expect(first.allowed).toBe(true);
-    expect(second.allowed).toBe(true);
-    expect(blocked.allowed).toBe(false);
-    expect(blocked.reasons.join(' ')).toContain('Rate limit exceeded');
-    expect(afterWindow.allowed).toBe(true);
-  });
-
-  it('opens circuit breaker after repeated failures and closes after cooldown + successful probe', () => {
-    updateSafetyConfig(workspacePath, 'ops-admin', {
-      rateLimit: {
-        enabled: false,
-      },
-      circuitBreaker: {
-        enabled: true,
-        failureThreshold: 2,
-        cooldownSeconds: 30,
-        halfOpenMaxOperations: 1,
-      },
-    });
-
-    const t0 = new Date('2026-03-06T11:00:00.000Z');
-    evaluateSafety(workspacePath, { actor: 'auto-2', operation: 'autonomy.run', now: t0, consume: true });
-    recordOperationOutcome(workspacePath, {
-      actor: 'auto-2',
-      operation: 'autonomy.run',
-      success: false,
-      error: 'first failure',
-      now: t0,
-    });
-
-    evaluateSafety(workspacePath, { actor: 'auto-2', operation: 'autonomy.run', now: t0, consume: true });
-    recordOperationOutcome(workspacePath, {
-      actor: 'auto-2',
-      operation: 'autonomy.run',
-      success: false,
-      error: 'second failure',
-      now: t0,
-    });
-
-    const blocked = evaluateSafety(workspacePath, {
-      actor: 'auto-2',
-      operation: 'autonomy.run',
-      now: new Date(t0.getTime() + 1_000),
-      consume: true,
-    });
-    expect(blocked.allowed).toBe(false);
-    expect(blocked.reasons.join(' ')).toContain('Circuit breaker open');
-
-    const probeTime = new Date(t0.getTime() + 31_000);
-    const probe = evaluateSafety(workspacePath, {
-      actor: 'auto-2',
-      operation: 'autonomy.run',
-      now: probeTime,
-      consume: true,
-    });
-    expect(probe.allowed).toBe(true);
-
-    recordOperationOutcome(workspacePath, {
-      actor: 'auto-2',
-      operation: 'autonomy.run',
-      success: true,
-      now: probeTime,
-    });
-
-    const status = getSafetyStatus(workspacePath, new Date(t0.getTime() + 32_000));
-    expect(status.config.runtime.circuitState).toBe('closed');
-  });
-
-  it('enforces kill switch pause/resume and writes ledger events', () => {
-    pauseSafetyOperations(workspacePath, 'ops-admin', 'manual incident response');
-    const pausedDecision = evaluateSafety(workspacePath, {
-      actor: 'auto-3',
-      operation: 'autonomy.run',
-      consume: false,
-    });
-    expect(pausedDecision.allowed).toBe(false);
-    expect(pausedDecision.reasons.join(' ')).toContain('Kill switch engaged');
-
-    resumeSafetyOperations(workspacePath, 'ops-admin');
-    const resumedDecision = evaluateSafety(workspacePath, {
-      actor: 'auto-3',
-      operation: 'autonomy.run',
-      consume: false,
-    });
-    expect(resumedDecision.allowed).toBe(true);
-
-    const events = listSafetyEvents(workspacePath, { count: 10 });
-    const eventNames = events.map((entry) => String(entry.data?.event ?? ''));
-    expect(eventNames).toContain('safety.kill_switch.engaged');
-    expect(eventNames).toContain('safety.kill_switch.released');
-  });
-
-  it('resets runtime counters and can clear kill switch', () => {
-    updateSafetyConfig(workspacePath, 'ops-admin', {
-      rateLimit: {
-        enabled: true,
-        maxOperations: 1,
-        windowSeconds: 600,
-      },
-      circuitBreaker: {
-        enabled: true,
-        failureThreshold: 1,
-        cooldownSeconds: 600,
-        halfOpenMaxOperations: 1,
-      },
-    });
-    pauseSafetyOperations(workspacePath, 'ops-admin', 'maintenance');
-
-    evaluateSafety(workspacePath, {
-      actor: 'auto-4',
-      operation: 'autonomy.run',
-      consume: true,
-    });
-    recordOperationOutcome(workspacePath, {
-      actor: 'auto-4',
-      operation: 'autonomy.run',
-      success: false,
-      error: 'failure before reset',
-    });
-
-    const reset = resetSafetyRails(workspacePath, {
-      actor: 'ops-admin',
-      clearKillSwitch: true,
-    });
-    expect(reset.runtime.consecutiveFailures).toBe(0);
-    expect(reset.runtime.circuitState).toBe('closed');
-    expect(reset.runtime.rateLimitOperations).toBe(0);
-    expect(reset.killSwitch.engaged).toBe(false);
-  });
-
-  it('guards operation execution via runWithSafetyRails', async () => {
-    updateSafetyConfig(workspacePath, 'ops-admin', {
-      rateLimit: {
-        enabled: false,
-      },
-      circuitBreaker: {
-        enabled: true,
-        failureThreshold: 1,
-        cooldownSeconds: 120,
-        halfOpenMaxOperations: 1,
-      },
-    });
-
-    await expect(runWithSafetyRails(
-      workspacePath,
-      {
-        actor: 'auto-5',
-        operation: 'autonomy.dispatch',
-      },
-      () => {
-        throw new Error('adapter failed');
-      },
-    )).rejects.toThrow('adapter failed');
-
-    let invoked = false;
-    await expect(runWithSafetyRails(
-      workspacePath,
-      {
-        actor: 'auto-5',
-        operation: 'autonomy.dispatch',
-      },
-      () => {
-        invoked = true;
-        return 'ok';
-      },
-    )).rejects.toThrow('Safety rails blocked');
-    expect(invoked).toBe(false);
-
-    const config = loadSafetyConfig(workspacePath);
-    expect(config.runtime.circuitState).toBe('open');
-  });
-});
diff --git a/packages/kernel/src/safety.ts b/packages/kernel/src/safety.ts
deleted file mode 100644
index 0c0dad7..0000000
--- a/packages/kernel/src/safety.ts
+++ /dev/null
@@ -1,710 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import YAML from 'yaml';
-import * as ledger from './ledger.js';
-import type { LedgerEntry } from './types.js';
-
-export const SAFETY_CONFIG_FILE = '.workgraph/safety.yaml';
-const SAFETY_LEDGER_TARGET = SAFETY_CONFIG_FILE;
-const SAFETY_LEDGER_TYPE = 'safety';
-const SAFETY_VERSION = 1;
-const DEFAULT_ACTOR = 'system:safety';
-
-export type WorkgraphSafetyCircuitState = 'closed' | 'open' | 'half-open';
-
-export interface WorkgraphSafetyRateLimitConfig {
-  enabled: boolean;
-  windowSeconds: number;
-  maxOperations: number;
-}
-
-export interface WorkgraphSafetyCircuitBreakerConfig {
-  enabled: boolean;
-  failureThreshold: number;
-  cooldownSeconds: number;
-  halfOpenMaxOperations: number;
-}
-
-export interface WorkgraphSafetyKillSwitchConfig {
-  engaged: boolean;
-  reason?: string;
-  engagedAt?: string;
-  engagedBy?: string;
-}
-
-export interface WorkgraphSafetyRuntimeState {
-  rateLimitWindowStartedAt: string;
-  rateLimitOperations: number;
-  circuitState: WorkgraphSafetyCircuitState;
-  consecutiveFailures: number;
-  openedAt?: string;
-  halfOpenOperations: number;
-  lastFailureAt?: string;
-  lastFailureReason?: string;
-}
-
-export interface WorkgraphSafetyConfig {
-  version: number;
-  updatedAt: string;
-  rateLimit: WorkgraphSafetyRateLimitConfig;
-  circuitBreaker: WorkgraphSafetyCircuitBreakerConfig;
-  killSwitch: WorkgraphSafetyKillSwitchConfig;
-  runtime: WorkgraphSafetyRuntimeState;
-}
-
-export interface WorkgraphSafetyConfigPatch {
-  rateLimit?: Partial<WorkgraphSafetyRateLimitConfig>;
-  circuitBreaker?: Partial<WorkgraphSafetyCircuitBreakerConfig>;
-}
-
-export interface WorkgraphSafetyEvaluateOptions {
-  actor: string;
-  operation: string;
-  now?: Date;
-  consume?: boolean;
-  logAllowed?: boolean;
-}
-
-export interface WorkgraphSafetyDecision {
-  allowed: boolean;
-  reasons: string[];
-  config: WorkgraphSafetyConfig;
-  cooldownRemainingSeconds: number;
-  windowRemainingSeconds: number;
-}
-
-export interface WorkgraphSafetyOutcomeOptions {
-  actor: string;
-  operation: string;
-  success: boolean;
-  error?: string;
-  now?: Date;
-}
-
-export interface WorkgraphSafetyResetOptions {
-  actor: string;
-  clearKillSwitch?: boolean;
-}
-
-export interface WorkgraphSafetyStatus {
-  blocked: boolean;
-  reasons: string[];
-  config: WorkgraphSafetyConfig;
-  cooldownRemainingSeconds: number;
-  windowRemainingSeconds: number;
-}
-
-export interface WorkgraphSafetyEventQueryOptions {
-  count?: number;
-}
-
-interface WorkgraphSafetyEvaluationSnapshot {
-  reasons: string[];
-  cooldownRemainingSeconds: number;
-  windowRemainingSeconds: number;
-}
-
-export function safetyConfigPath(workspacePath: string): string {
-  return path.join(workspacePath, SAFETY_CONFIG_FILE);
-}
-
-export function ensureSafetyConfig(workspacePath: string): WorkgraphSafetyConfig {
-  const targetPath = safetyConfigPath(workspacePath);
-  if (fs.existsSync(targetPath)) {
-    return loadSafetyConfig(workspacePath);
-  }
-  const nowIso = new Date().toISOString();
-  const created = buildDefaultSafetyConfig(nowIso);
-  writeSafetyConfig(workspacePath, created);
-  return created;
-}
-
-export function loadSafetyConfig(workspacePath: string): WorkgraphSafetyConfig {
-  const targetPath = safetyConfigPath(workspacePath);
-  if (!fs.existsSync(targetPath)) {
-    return ensureSafetyConfig(workspacePath);
-  }
-  let parsed: unknown;
-  try {
-    parsed = YAML.parse(fs.readFileSync(targetPath, 'utf-8'));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse ${SAFETY_CONFIG_FILE}: ${message}`);
-  }
-  return normalizeSafetyConfig(parsed, new Date().toISOString());
-}
-
-export function updateSafetyConfig(
-  workspacePath: string,
-  actor: string,
-  patch: WorkgraphSafetyConfigPatch,
-): WorkgraphSafetyConfig {
-  const nowIso = new Date().toISOString();
-  const current = loadSafetyConfig(workspacePath);
-  const merged = normalizeSafetyConfig({
-    ...current,
-    rateLimit: {
-      ...current.rateLimit,
-      ...patch.rateLimit,
-    },
-    circuitBreaker: {
-      ...current.circuitBreaker,
-      ...patch.circuitBreaker,
-    },
-    updatedAt: nowIso,
-  }, nowIso);
-  writeSafetyConfig(workspacePath, merged);
-  appendSafetyEvent(workspacePath, actor, 'safety.config.updated', {
-    rateLimit: merged.rateLimit,
-    circuitBreaker: merged.circuitBreaker,
-  });
-  return merged;
-}
-
-export function pauseSafetyOperations(
-  workspacePath: string,
-  actor: string,
-  reason?: string,
-): WorkgraphSafetyConfig {
-  const nowIso = new Date().toISOString();
-  const config = loadSafetyConfig(workspacePath);
-  config.killSwitch.engaged = true;
-  config.killSwitch.engagedAt = nowIso;
-  config.killSwitch.engagedBy = normalizeActor(actor);
-  config.killSwitch.reason = normalizeOptionalString(reason) ?? 'Paused manually';
-  config.updatedAt = nowIso;
-  writeSafetyConfig(workspacePath, config);
-  appendSafetyEvent(workspacePath, actor, 'safety.kill_switch.engaged', {
-    reason: config.killSwitch.reason,
-  });
-  return config;
-}
-
-export function resumeSafetyOperations(workspacePath: string, actor: string): WorkgraphSafetyConfig {
-  const nowIso = new Date().toISOString();
-  const config = loadSafetyConfig(workspacePath);
-  config.killSwitch.engaged = false;
-  config.killSwitch.reason = undefined;
-  config.killSwitch.engagedAt = undefined;
-  config.killSwitch.engagedBy = undefined;
-  config.updatedAt = nowIso;
-  writeSafetyConfig(workspacePath, config);
-  appendSafetyEvent(workspacePath, actor, 'safety.kill_switch.released');
-  return config;
-}
-
-export function resetSafetyRails(
-  workspacePath: string,
-  options: WorkgraphSafetyResetOptions,
-): WorkgraphSafetyConfig {
-  const nowIso = new Date().toISOString();
-  const config = loadSafetyConfig(workspacePath);
-  config.runtime = buildDefaultRuntimeState(nowIso);
-  if (options.clearKillSwitch) {
-    config.killSwitch = { engaged: false };
-  }
-  config.updatedAt = nowIso;
-  writeSafetyConfig(workspacePath, config);
-  appendSafetyEvent(workspacePath, options.actor, 'safety.reset', {
-    clearKillSwitch: options.clearKillSwitch === true,
-  });
-  return config;
-}
-
-export function evaluateSafety(
-  workspacePath: string,
-  options: WorkgraphSafetyEvaluateOptions,
-): WorkgraphSafetyDecision {
-  const actor = normalizeActor(options.actor);
-  const operation = normalizeOperation(options.operation);
-  const now = options.now ?? new Date();
-  const nowIso = now.toISOString();
-  const nowMs = now.getTime();
-
-  const config = loadSafetyConfig(workspacePath);
-  const transitionEvents: string[] = [];
-  let changed = applyTimeBasedTransitions(config, nowMs, nowIso, transitionEvents);
-  const snapshot = evaluateConfigSnapshot(config, nowMs);
-  if (snapshot.reasons.length === 0 && options.consume !== false) {
-    if (config.rateLimit.enabled) {
-      config.runtime.rateLimitOperations += 1;
-    }
-    if (config.circuitBreaker.enabled && config.runtime.circuitState === 'half-open') {
-      config.runtime.halfOpenOperations += 1;
-    }
-    config.updatedAt = nowIso;
-    changed = true;
-  }
-
-  if (changed) {
-    writeSafetyConfig(workspacePath, config);
-  }
-
-  for (const eventName of transitionEvents) {
-    appendSafetyEvent(workspacePath, actor, eventName, {
-      operation,
-    });
-  }
-
-  if (snapshot.reasons.length > 0) {
-    appendSafetyEvent(workspacePath, actor, 'safety.blocked', {
-      operation,
-      reasons: snapshot.reasons,
-      circuitState: config.runtime.circuitState,
-      rateLimitOperations: config.runtime.rateLimitOperations,
-    });
-  } else if (options.logAllowed === true) {
-    appendSafetyEvent(workspacePath, actor, 'safety.allowed', {
-      operation,
-    });
-  }
-
-  return {
-    allowed: snapshot.reasons.length === 0,
-    reasons: snapshot.reasons,
-    cooldownRemainingSeconds: snapshot.cooldownRemainingSeconds,
-    windowRemainingSeconds: snapshot.windowRemainingSeconds,
-    config,
-  };
-}
-
-export function recordOperationOutcome(
-  workspacePath: string,
-  options: WorkgraphSafetyOutcomeOptions,
-): WorkgraphSafetyConfig {
-  const actor = normalizeActor(options.actor);
-  const operation = normalizeOperation(options.operation);
-  const now = options.now ?? new Date();
-  const nowIso = now.toISOString();
-  const nowMs = now.getTime();
-
-  const config = loadSafetyConfig(workspacePath);
-  const transitionEvents: string[] = [];
-  let changed = applyTimeBasedTransitions(config, nowMs, nowIso, transitionEvents);
-
-  if (options.success) {
-    const hadFailures = config.runtime.consecutiveFailures > 0
-      || !!config.runtime.lastFailureAt
-      || !!config.runtime.lastFailureReason;
-    if (hadFailures) {
-      config.runtime.consecutiveFailures = 0;
-      config.runtime.lastFailureAt = undefined;
-      config.runtime.lastFailureReason = undefined;
-      changed = true;
-    }
-    if (config.runtime.circuitState !== 'closed') {
-      config.runtime.circuitState = 'closed';
-      config.runtime.openedAt = undefined;
-      config.runtime.halfOpenOperations = 0;
-      transitionEvents.push('safety.circuit.closed');
-      changed = true;
-    }
-  } else {
-    config.runtime.lastFailureAt = nowIso;
-    config.runtime.lastFailureReason = normalizeOptionalString(options.error);
-    changed = true;
-    if (config.circuitBreaker.enabled) {
-      if (config.runtime.circuitState === 'half-open') {
-        config.runtime.circuitState = 'open';
-        config.runtime.openedAt = nowIso;
-        config.runtime.halfOpenOperations = 0;
-        config.runtime.consecutiveFailures = config.circuitBreaker.failureThreshold;
-        transitionEvents.push('safety.circuit.opened');
-      } else {
-        config.runtime.consecutiveFailures += 1;
-        if (config.runtime.consecutiveFailures >= config.circuitBreaker.failureThreshold) {
-          if (config.runtime.circuitState !== 'open') {
-            transitionEvents.push('safety.circuit.opened');
-          }
-          config.runtime.circuitState = 'open';
-          config.runtime.openedAt = nowIso;
-          config.runtime.halfOpenOperations = 0;
-        }
-      }
-    } else {
-      config.runtime.circuitState = 'closed';
-      config.runtime.openedAt = undefined;
-      config.runtime.halfOpenOperations = 0;
-    }
-  }
-
-  if (changed) {
-    config.updatedAt = nowIso;
-    writeSafetyConfig(workspacePath, config);
-  }
-
-  for (const eventName of transitionEvents) {
-    appendSafetyEvent(workspacePath, actor, eventName, {
-      operation,
-      consecutiveFailures: config.runtime.consecutiveFailures,
-    });
-  }
-
-  appendSafetyEvent(
-    workspacePath,
-    actor,
-    options.success ? 'safety.operation.succeeded' : 'safety.operation.failed',
-    {
-      operation,
-      ...(options.error ? { error: options.error } : {}),
-    },
-  );
-
-  return config;
-}
-
-export async function runWithSafetyRails<T>(
-  workspacePath: string,
-  options: Omit<WorkgraphSafetyEvaluateOptions, 'consume'>,
-  operation: () => Promise<T> | T,
-): Promise<T> {
-  const decision = evaluateSafety(workspacePath, {
-    ...options,
-    consume: true,
-  });
-  if (!decision.allowed) {
-    throw new Error(`Safety rails blocked "${options.operation}": ${decision.reasons.join('; ')}`);
-  }
-  try {
-    const result = await operation();
-    recordOperationOutcome(workspacePath, {
-      actor: options.actor,
-      operation: options.operation,
-      success: true,
-    });
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    recordOperationOutcome(workspacePath, {
-      actor: options.actor,
-      operation: options.operation,
-      success: false,
-      error: message,
-    });
-    throw error;
-  }
-}
-
-export function getSafetyStatus(workspacePath: string, now: Date = new Date()): WorkgraphSafetyStatus {
-  const snapshotConfig = cloneSafetyConfig(loadSafetyConfig(workspacePath));
-  applyTimeBasedTransitions(snapshotConfig, now.getTime(), now.toISOString(), []);
-  const snapshot = evaluateConfigSnapshot(snapshotConfig, now.getTime());
-  return {
-    blocked: snapshot.reasons.length > 0,
-    reasons: snapshot.reasons,
-    cooldownRemainingSeconds: snapshot.cooldownRemainingSeconds,
-    windowRemainingSeconds: snapshot.windowRemainingSeconds,
-    config: snapshotConfig,
-  };
-}
-
-export function listSafetyEvents(
-  workspacePath: string,
-  options: WorkgraphSafetyEventQueryOptions = {},
-): LedgerEntry[] {
-  const allSafetyEntries = ledger.readAll(workspacePath).filter((entry) => isSafetyEntry(entry));
-  const count = normalizeNonNegativeInt(options.count, 20);
-  if (count === 0) return [];
-  return allSafetyEntries.slice(-count);
-}
-
-function writeSafetyConfig(workspacePath: string, config: WorkgraphSafetyConfig): void {
-  const targetPath = safetyConfigPath(workspacePath);
-  const directory = path.dirname(targetPath);
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  fs.writeFileSync(targetPath, YAML.stringify(config), 'utf-8');
-}
-
-function appendSafetyEvent(
-  workspacePath: string,
-  actor: string,
-  event: string,
-  data: Record<string, unknown> = {},
-): LedgerEntry {
-  return ledger.append(
-    workspacePath,
-    normalizeActor(actor),
-    'update',
-    SAFETY_LEDGER_TARGET,
-    SAFETY_LEDGER_TYPE,
-    {
-      event,
-      ...data,
-    },
-  );
-}
-
-function applyTimeBasedTransitions(
-  config: WorkgraphSafetyConfig,
-  nowMs: number,
-  nowIso: string,
-  eventNames: string[],
-): boolean {
-  let changed = false;
-
-  if (config.rateLimit.enabled) {
-    const windowStartMs = parseTimestamp(config.runtime.rateLimitWindowStartedAt);
-    const elapsedMs = windowStartMs === null ? Number.POSITIVE_INFINITY : nowMs - windowStartMs;
-    if (!Number.isFinite(elapsedMs) || elapsedMs < 0 || elapsedMs >= (config.rateLimit.windowSeconds * 1000)) {
-      config.runtime.rateLimitWindowStartedAt = nowIso;
-      config.runtime.rateLimitOperations = 0;
-      eventNames.push('safety.rate_limit.window_reset');
-      changed = true;
-    }
-  } else if (config.runtime.rateLimitOperations !== 0) {
-    config.runtime.rateLimitOperations = 0;
-    changed = true;
-  }
-
-  if (!config.circuitBreaker.enabled) {
-    if (
-      config.runtime.circuitState !== 'closed'
-      || config.runtime.openedAt !== undefined
-      || config.runtime.halfOpenOperations !== 0
-      || config.runtime.consecutiveFailures !== 0
-    ) {
-      config.runtime.circuitState = 'closed';
-      config.runtime.openedAt = undefined;
-      config.runtime.halfOpenOperations = 0;
-      config.runtime.consecutiveFailures = 0;
-      changed = true;
-    }
-  } else if (config.runtime.circuitState === 'open') {
-    const openedAtMs = parseTimestamp(config.runtime.openedAt);
-    const elapsedMs = openedAtMs === null ? Number.POSITIVE_INFINITY : nowMs - openedAtMs;
-    if (!Number.isFinite(elapsedMs) || elapsedMs < 0 || elapsedMs >= (config.circuitBreaker.cooldownSeconds * 1000)) {
-      config.runtime.circuitState = 'half-open';
-      config.runtime.halfOpenOperations = 0;
-      config.runtime.openedAt = undefined;
-      eventNames.push('safety.circuit.half_open');
-      changed = true;
-    }
-  }
-
-  if (changed) {
-    config.updatedAt = nowIso;
-  }
-  return changed;
-}
-
-function evaluateConfigSnapshot(
-  config: WorkgraphSafetyConfig,
-  nowMs: number,
-): WorkgraphSafetyEvaluationSnapshot {
-  const reasons: string[] = [];
-  let cooldownRemainingSeconds = 0;
-  let windowRemainingSeconds = 0;
-
-  if (config.killSwitch.engaged) {
-    const reason = config.killSwitch.reason ?? 'Kill switch engaged';
-    reasons.push(`Kill switch engaged: ${reason}`);
-  }
-
-  if (config.circuitBreaker.enabled) {
-    if (config.runtime.circuitState === 'open') {
-      const openedAtMs = parseTimestamp(config.runtime.openedAt);
-      if (openedAtMs !== null) {
-        const elapsedSeconds = Math.floor((nowMs - openedAtMs) / 1000);
-        cooldownRemainingSeconds = Math.max(0, config.circuitBreaker.cooldownSeconds - elapsedSeconds);
-      }
-      reasons.push(
-        cooldownRemainingSeconds > 0
-          ? `Circuit breaker open (${cooldownRemainingSeconds}s cooldown remaining)`
-          : 'Circuit breaker open',
-      );
-    } else if (
-      config.runtime.circuitState === 'half-open'
-      && config.runtime.halfOpenOperations >= config.circuitBreaker.halfOpenMaxOperations
-    ) {
-      reasons.push('Circuit breaker half-open probe limit reached');
-    }
-  }
-
-  if (config.rateLimit.enabled) {
-    const windowStartMs = parseTimestamp(config.runtime.rateLimitWindowStartedAt);
-    if (windowStartMs !== null) {
-      const elapsedSeconds = Math.floor((nowMs - windowStartMs) / 1000);
-      windowRemainingSeconds = Math.max(0, config.rateLimit.windowSeconds - elapsedSeconds);
-    }
-    if (config.runtime.rateLimitOperations >= config.rateLimit.maxOperations) {
-      reasons.push(
-        `Rate limit exceeded (${config.runtime.rateLimitOperations}/${config.rateLimit.maxOperations})`,
-      );
-    }
-  }
-
-  return {
-    reasons,
-    cooldownRemainingSeconds,
-    windowRemainingSeconds,
-  };
-}
-
-function buildDefaultSafetyConfig(nowIso: string): WorkgraphSafetyConfig {
-  return {
-    version: SAFETY_VERSION,
-    updatedAt: nowIso,
-    rateLimit: {
-      enabled: true,
-      windowSeconds: 60,
-      maxOperations: 120,
-    },
-    circuitBreaker: {
-      enabled: true,
-      failureThreshold: 3,
-      cooldownSeconds: 120,
-      halfOpenMaxOperations: 1,
-    },
-    killSwitch: {
-      engaged: false,
-    },
-    runtime: buildDefaultRuntimeState(nowIso),
-  };
-}
-
-function buildDefaultRuntimeState(nowIso: string): WorkgraphSafetyRuntimeState {
-  return {
-    rateLimitWindowStartedAt: nowIso,
-    rateLimitOperations: 0,
-    circuitState: 'closed',
-    consecutiveFailures: 0,
-    halfOpenOperations: 0,
-  };
-}
-
-function normalizeSafetyConfig(input: unknown, nowIso: string): WorkgraphSafetyConfig {
-  const defaults = buildDefaultSafetyConfig(nowIso);
-  const source = asRecord(input);
-  const rateLimitInput = asRecord(source.rateLimit);
-  const circuitInput = asRecord(source.circuitBreaker);
-  const killSwitchInput = asRecord(source.killSwitch);
-  const runtimeInput = asRecord(source.runtime);
-
-  const rateLimit: WorkgraphSafetyRateLimitConfig = {
-    enabled: readBoolean(rateLimitInput.enabled) ?? defaults.rateLimit.enabled,
-    windowSeconds: normalizePositiveInt(rateLimitInput.windowSeconds, defaults.rateLimit.windowSeconds),
-    maxOperations: normalizePositiveInt(rateLimitInput.maxOperations, defaults.rateLimit.maxOperations),
-  };
-
-  const circuitBreaker: WorkgraphSafetyCircuitBreakerConfig = {
-    enabled: readBoolean(circuitInput.enabled) ?? defaults.circuitBreaker.enabled,
-    failureThreshold: normalizePositiveInt(circuitInput.failureThreshold, defaults.circuitBreaker.failureThreshold),
-    cooldownSeconds: normalizePositiveInt(circuitInput.cooldownSeconds, defaults.circuitBreaker.cooldownSeconds),
-    halfOpenMaxOperations: normalizePositiveInt(
-      circuitInput.halfOpenMaxOperations,
-      defaults.circuitBreaker.halfOpenMaxOperations,
-    ),
-  };
-
-  const killSwitch: WorkgraphSafetyKillSwitchConfig = {
-    engaged: readBoolean(killSwitchInput.engaged) ?? defaults.killSwitch.engaged,
-    reason: normalizeOptionalString(killSwitchInput.reason),
-    engagedAt: normalizeOptionalString(killSwitchInput.engagedAt),
-    engagedBy: normalizeOptionalString(killSwitchInput.engagedBy),
-  };
-  if (!killSwitch.engaged) {
-    killSwitch.reason = undefined;
-    killSwitch.engagedAt = undefined;
-    killSwitch.engagedBy = undefined;
-  }
-
-  const circuitState = normalizeCircuitState(runtimeInput.circuitState) ?? defaults.runtime.circuitState;
-  const runtime: WorkgraphSafetyRuntimeState = {
-    rateLimitWindowStartedAt: normalizeOptionalString(runtimeInput.rateLimitWindowStartedAt) ?? nowIso,
-    rateLimitOperations: normalizeNonNegativeInt(runtimeInput.rateLimitOperations, 0),
-    circuitState,
-    consecutiveFailures: normalizeNonNegativeInt(runtimeInput.consecutiveFailures, 0),
-    openedAt: normalizeOptionalString(runtimeInput.openedAt),
-    halfOpenOperations: normalizeNonNegativeInt(runtimeInput.halfOpenOperations, 0),
-    lastFailureAt: normalizeOptionalString(runtimeInput.lastFailureAt),
-    lastFailureReason: normalizeOptionalString(runtimeInput.lastFailureReason),
-  };
-  if (runtime.circuitState !== 'open') runtime.openedAt = undefined;
-  if (runtime.circuitState === 'closed') runtime.halfOpenOperations = 0;
-
-  return {
-    version: normalizePositiveInt(source.version, defaults.version),
-    updatedAt: normalizeOptionalString(source.updatedAt) ?? nowIso,
-    rateLimit,
-    circuitBreaker,
-    killSwitch,
-    runtime,
-  };
-}
-
-function isSafetyEntry(entry: LedgerEntry): boolean {
-  if (entry.type === SAFETY_LEDGER_TYPE) return true;
-  if (entry.target === SAFETY_LEDGER_TARGET) return true;
-  const data = asRecord(entry.data);
-  const event = normalizeOptionalString(data.event);
-  return event?.startsWith('safety.') ?? false;
-}
-
-function parseTimestamp(value: string | undefined): number | null {
-  if (!value) return null;
-  const ms = Date.parse(value);
-  return Number.isFinite(ms) ? ms : null;
-}
-
-function normalizeCircuitState(value: unknown): WorkgraphSafetyCircuitState | undefined {
-  const normalized = normalizeOptionalString(value)?.toLowerCase();
-  if (normalized === 'closed' || normalized === 'open' || normalized === 'half-open') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function cloneSafetyConfig(config: WorkgraphSafetyConfig): WorkgraphSafetyConfig {
-  return JSON.parse(JSON.stringify(config)) as WorkgraphSafetyConfig;
-}
-
-function normalizeOperation(operation: string): string {
-  const normalized = normalizeOptionalString(operation);
-  return normalized ?? 'autonomy.operation';
-}
-
-function normalizeActor(actor: string): string {
-  const normalized = normalizeOptionalString(actor);
-  return normalized ?? DEFAULT_ACTOR;
-}
-
-function normalizeOptionalString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asRecord(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  return value as Record<string, unknown>;
-}
-
-function readBoolean(value: unknown): boolean | undefined {
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true' || normalized === '1' || normalized === 'yes') return true;
-    if (normalized === 'false' || normalized === '0' || normalized === 'no') return false;
-  }
-  return undefined;
-}
-
-function normalizePositiveInt(value: unknown, fallback: number): number {
-  if (typeof value === 'number' && Number.isInteger(value) && value > 0) return value;
-  if (typeof value === 'string') {
-    const parsed = Number.parseInt(value, 10);
-    if (Number.isInteger(parsed) && parsed > 0) return parsed;
-  }
-  return fallback;
-}
-
-function normalizeNonNegativeInt(value: unknown, fallback: number): number {
-  if (typeof value === 'number' && Number.isInteger(value) && value >= 0) return value;
-  if (typeof value === 'string') {
-    const parsed = Number.parseInt(value, 10);
-    if (Number.isInteger(parsed) && parsed >= 0) return parsed;
-  }
-  return fallback;
-}
diff --git a/packages/kernel/src/schema-drift-regression.test.ts b/packages/kernel/src/schema-drift-regression.test.ts
deleted file mode 100644
index 7a32fe1..0000000
--- a/packages/kernel/src/schema-drift-regression.test.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { ensureCliBuiltForTests } from '../../../tests/helpers/cli-build.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-schema-drift-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-beforeAll(() => {
-  ensureCliBuiltForTests();
-});
-
-describe('schema drift regression', () => {
-  it('locks CLI option signatures for critical commands', () => {
-    const snapshots = {
-      onboard: extractOptionSignatures(runCliHelp(['onboard'])),
-      onboardingUpdate: extractOptionSignatures(runCliHelp(['onboarding', 'update', 'onboarding/example.md'])),
-      mcpServe: extractOptionSignatures(runCliHelp(['mcp', 'serve'])),
-      dispatchExecute: extractOptionSignatures(runCliHelp(['dispatch', 'execute', 'run_123'])),
-      triggerFire: extractOptionSignatures(runCliHelp(['trigger', 'fire', 'triggers/example.md'])),
-      query: extractOptionSignatures(runCliHelp(['query'])),
-      lensList: extractOptionSignatures(runCliHelp(['lens', 'list'])),
-      lensShow: extractOptionSignatures(runCliHelp(['lens', 'show', 'my-work'])),
-      serverServe: extractOptionSignatures(runCliHelp(['serve'])),
-    };
-
-    expect(snapshots).toMatchSnapshot();
-  });
-
-  it('locks MCP tool metadata and input schemas', async () => {
-    const mcpModulePath = '../../mcp-server/src/index.js';
-    const mcpModule = await import(mcpModulePath);
-    const createWorkgraphMcpServer = (
-      mcpModule as {
-        createWorkgraphMcpServer: (options: { workspacePath: string; defaultActor: string }) => {
-          connect: (transport: unknown) => Promise<void>;
-          close: () => Promise<void>;
-        };
-      }
-    ).createWorkgraphMcpServer;
-    const server = createWorkgraphMcpServer({
-      workspacePath,
-      defaultActor: 'agent-schema',
-    });
-    const client = new Client({
-      name: 'workgraph-schema-drift-client',
-      version: '1.0.0',
-    });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-
-    await Promise.all([
-      server.connect(serverTransport),
-      client.connect(clientTransport),
-    ]);
-
-    try {
-      const listed = await client.listTools();
-      const tools = listed.tools
-        .map((tool) => ({
-          name: tool.name,
-          title: tool.title ?? null,
-          description: tool.description ?? null,
-          annotations: normalizeValue(tool.annotations ?? {}),
-          inputSchema: normalizeValue(tool.inputSchema ?? {}),
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-
-      expect(tools).toMatchSnapshot();
-    } finally {
-      await client.close();
-      await server.close();
-    }
-  });
-});
-
-function runCliHelp(args: string[]): string {
-  const result = spawnSync('node', [path.resolve('bin/workgraph.js'), ...args, '--help'], {
-    encoding: 'utf-8',
-  });
-  if (result.status !== 0) {
-    throw new Error(
-      `CLI help failed for args [${args.join(' ')}].\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
-    );
-  }
-  return result.stdout;
-}
-
-function extractOptionSignatures(helpText: string): string[] {
-  const lines = helpText.split('\n');
-  const optionsIndex = lines.findIndex((line) => line.trim() === 'Options:');
-  if (optionsIndex === -1) {
-    throw new Error(`Help output missing Options section.\n${helpText}`);
-  }
-
-  const signatures: string[] = [];
-  for (let index = optionsIndex + 1; index < lines.length; index += 1) {
-    const line = lines[index];
-    if (!line.startsWith('  ')) {
-      break;
-    }
-
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('-')) {
-      continue;
-    }
-    signatures.push(trimmed.split(/\s{2,}/)[0] ?? trimmed);
-  }
-  return signatures;
-}
-
-function normalizeValue(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue(item));
-  }
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-
-  const record = value as Record<string, unknown>;
-  const sortedEntries = Object.keys(record)
-    .sort((left, right) => left.localeCompare(right))
-    .map((key) => [key, normalizeValue(record[key])] as const);
-  return Object.fromEntries(sortedEntries);
-}
diff --git a/packages/kernel/src/search-qmd-adapter.test.ts b/packages/kernel/src/search-qmd-adapter.test.ts
deleted file mode 100644
index 4a6a642..0000000
--- a/packages/kernel/src/search-qmd-adapter.test.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('./query.js', () => ({
-  keywordSearch: vi.fn(),
-}));
-
-import * as query from './query.js';
-import type { PrimitiveInstance } from './types.js';
-import { search } from './search-qmd-adapter.js';
-
-describe('search-qmd-adapter', () => {
-  const keywordSearchMock = vi.mocked(query.keywordSearch);
-  const envSnapshot = process.env.WORKGRAPH_QMD_ENDPOINT;
-  const fakeResults: PrimitiveInstance[] = [
-    {
-      path: 'facts/result.md',
-      type: 'fact',
-      body: '# Result',
-      fields: {
-        title: 'Result',
-      },
-    },
-  ];
-
-  beforeEach(() => {
-    delete process.env.WORKGRAPH_QMD_ENDPOINT;
-    keywordSearchMock.mockReset();
-    keywordSearchMock.mockReturnValue(fakeResults);
-  });
-
-  afterEach(() => {
-    if (envSnapshot === undefined) {
-      delete process.env.WORKGRAPH_QMD_ENDPOINT;
-    } else {
-      process.env.WORKGRAPH_QMD_ENDPOINT = envSnapshot;
-    }
-  });
-
-  it('uses core mode when requested explicitly', () => {
-    const result = search('/workspace/demo', 'critical bug', {
-      mode: 'core',
-      type: 'thread',
-      limit: 3,
-    });
-
-    expect(result.mode).toBe('core');
-    expect(result.fallbackReason).toBeUndefined();
-    expect(result.results).toEqual(fakeResults);
-    expect(keywordSearchMock).toHaveBeenCalledWith('/workspace/demo', 'critical bug', {
-      type: 'thread',
-      limit: 3,
-    });
-  });
-
-  it('falls back to core mode when qmd mode is requested but endpoint is missing', () => {
-    const result = search('/workspace/demo', 'release check', {
-      mode: 'qmd',
-      type: 'thread',
-      limit: 5,
-    });
-
-    expect(result.mode).toBe('core');
-    expect(result.fallbackReason).toContain('WORKGRAPH_QMD_ENDPOINT is not configured');
-    expect(keywordSearchMock).toHaveBeenCalledWith('/workspace/demo', 'release check', {
-      type: 'thread',
-      limit: 5,
-    });
-  });
-
-  it('returns qmd mode contract when endpoint is configured and qmd mode is requested', () => {
-    process.env.WORKGRAPH_QMD_ENDPOINT = 'https://qmd.example/search';
-    const result = search('/workspace/demo', 'incident summary', {
-      mode: 'qmd',
-    });
-
-    expect(result.mode).toBe('qmd');
-    expect(result.fallbackReason).toContain('QMD endpoint configured');
-    expect(result.results).toEqual(fakeResults);
-  });
-
-  it('auto-selects qmd mode when endpoint is configured', () => {
-    process.env.WORKGRAPH_QMD_ENDPOINT = 'https://qmd.example/search';
-    const result = search('/workspace/demo', 'deploy plan');
-
-    expect(result.mode).toBe('qmd');
-    expect(result.fallbackReason).toContain('Auto mode selected');
-    expect(keywordSearchMock).toHaveBeenCalledWith('/workspace/demo', 'deploy plan', {
-      type: undefined,
-      limit: undefined,
-    });
-  });
-});
diff --git a/packages/kernel/src/search-qmd-adapter.ts b/packages/kernel/src/search-qmd-adapter.ts
deleted file mode 100644
index aa5570c..0000000
--- a/packages/kernel/src/search-qmd-adapter.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- * QMD-compatible search adapter.
- *
- * This package intentionally degrades gracefully to core keyword search when
- * a QMD backend is not configured.
- */
-
-import * as query from './query.js';
-import type { PrimitiveInstance } from './types.js';
-
-export interface QmdSearchOptions {
-  mode?: 'auto' | 'core' | 'qmd';
-  type?: string;
-  limit?: number;
-}
-
-export interface QmdSearchResult {
-  mode: 'core' | 'qmd';
-  query: string;
-  results: PrimitiveInstance[];
-  fallbackReason?: string;
-}
-
-export function search(
-  workspacePath: string,
-  text: string,
-  options: QmdSearchOptions = {},
-): QmdSearchResult {
-  const requestedMode = options.mode ?? 'auto';
-  const qmdEnabled = process.env.WORKGRAPH_QMD_ENDPOINT && process.env.WORKGRAPH_QMD_ENDPOINT.trim().length > 0;
-
-  if (requestedMode === 'qmd' && !qmdEnabled) {
-    const results = query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    });
-    return {
-      mode: 'core',
-      query: text,
-      results,
-      fallbackReason: 'QMD mode requested but WORKGRAPH_QMD_ENDPOINT is not configured.',
-    };
-  }
-
-  if (requestedMode === 'qmd' && qmdEnabled) {
-    // MVP: route to core search while preserving mode contract.
-    const results = query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    });
-    return {
-      mode: 'qmd',
-      query: text,
-      results,
-      fallbackReason: 'QMD endpoint configured; using core-compatible local ranking in MVP.',
-    };
-  }
-
-  if (requestedMode === 'auto' && qmdEnabled) {
-    const results = query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    });
-    return {
-      mode: 'qmd',
-      query: text,
-      results,
-      fallbackReason: 'Auto mode selected; QMD endpoint detected; using core-compatible local ranking in MVP.',
-    };
-  }
-
-  return {
-    mode: 'core',
-    query: text,
-    results: query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    }),
-  };
-}
diff --git a/packages/kernel/src/search/keyword.ts b/packages/kernel/src/search/keyword.ts
deleted file mode 100644
index 64ca75c..0000000
--- a/packages/kernel/src/search/keyword.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { keywordSearch } from '../query.js';
diff --git a/packages/kernel/src/skill.test.ts b/packages/kernel/src/skill.test.ts
deleted file mode 100644
index 3005182..0000000
--- a/packages/kernel/src/skill.test.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { loadRegistry, saveRegistry } from './registry.js';
-import { listSkills, loadSkill, promoteSkill, proposeSkill, writeSkill } from './skill.js';
-import { skillDiff, skillHistory } from './skill.js';
-import { read as readPrimitive } from './store.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-skill-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('skill primitive lifecycle', () => {
-  it('writes and loads a skill primitive', () => {
-    const created = writeSkill(
-      workspacePath,
-      'workgraph-manual',
-      '# Workgraph Manual\n\nHow to operate the workgraph.',
-      'agent-author',
-      {
-        owner: 'agent-author',
-        version: '1.0.0',
-        dependsOn: ['core-setup'],
-        tags: ['coordination'],
-      },
-    );
-
-    expect(created.type).toBe('skill');
-    expect(created.path).toBe('skills/workgraph-manual/SKILL.md');
-    expect(created.fields.status).toBe('draft');
-    expect(created.fields.depends_on).toEqual(['core-setup']);
-    expect(fs.existsSync(path.join(workspacePath, 'skills/workgraph-manual/skill-manifest.json'))).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, 'skills/workgraph-manual/scripts'))).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, 'skills/workgraph-manual/examples'))).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, 'skills/workgraph-manual/tests'))).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, 'skills/workgraph-manual/assets'))).toBe(true);
-
-    const loaded = loadSkill(workspacePath, 'workgraph-manual');
-    expect(loaded.path).toBe(created.path);
-    expect(loaded.fields.owner).toBe('agent-author');
-  });
-
-  it('proposes a skill and creates a proposal thread when needed', () => {
-    writeSkill(workspacePath, 'tailscale-shared-skill', '# skill body', 'agent-author');
-    const proposed = proposeSkill(workspacePath, 'tailscale-shared-skill', 'agent-reviewer', {
-      createThreadIfMissing: true,
-      space: 'spaces/platform.md',
-      reviewers: ['agent-reviewer', 'agent-lead'],
-    });
-
-    expect(proposed.fields.status).toBe('proposed');
-    expect(String(proposed.fields.proposal_thread)).toContain('threads/review-skill-tailscale-shared-skill.md');
-    expect(Array.isArray(proposed.fields.reviewers)).toBe(true);
-    expect(proposed.fields.reviewers).toContain('agent-lead');
-
-    const proposalThreadPath = String(proposed.fields.proposal_thread);
-    const proposalThread = readPrimitive(workspacePath, proposalThreadPath);
-    expect(proposalThread).not.toBeNull();
-    expect(proposalThread?.fields.space).toBe('spaces/platform.md');
-  });
-
-  it('promotes a skill and bumps patch version by default', () => {
-    writeSkill(workspacePath, 'routing-playbook', '# routing', 'agent-author', {
-      version: '1.2.3',
-      status: 'proposed',
-    });
-
-    const promoted = promoteSkill(workspacePath, 'routing-playbook', 'agent-lead');
-    expect(promoted.fields.status).toBe('active');
-    expect(promoted.fields.version).toBe('1.2.4');
-    expect(promoted.fields.promoted_at).toBeDefined();
-  });
-
-  it('lists skills and filters by status', () => {
-    writeSkill(workspacePath, 'skill-a', '# a', 'agent-author', { status: 'draft' });
-    writeSkill(workspacePath, 'skill-b', '# b', 'agent-author', { status: 'active' });
-
-    const all = listSkills(workspacePath);
-    const active = listSkills(workspacePath, { status: 'active' });
-
-    expect(all).toHaveLength(2);
-    expect(active).toHaveLength(1);
-    expect(active[0].fields.title).toBe('skill-b');
-  });
-
-  it('supports updated-since filtering and skill history/diff summaries', () => {
-    const first = writeSkill(workspacePath, 'history-skill', '# v1', 'agent-author', { status: 'draft' });
-    const since = new Date().toISOString();
-    const second = writeSkill(workspacePath, 'history-skill', '# v2', 'agent-author', { status: 'proposed' });
-    expect(second.path).toBe(first.path);
-
-    const recent = listSkills(workspacePath, { updatedSince: since });
-    expect(recent.map((item) => item.path)).toContain(second.path);
-
-    const history = skillHistory(workspacePath, 'history-skill');
-    expect(history.length).toBeGreaterThanOrEqual(2);
-
-    const diff = skillDiff(workspacePath, 'history-skill');
-    expect(diff.path).toBe(second.path);
-    expect(diff.latestEntryTs).toBeTruthy();
-    expect(diff.previousEntryTs).toBeTruthy();
-  });
-
-  it('detects concurrent updates via expectedUpdatedAt guard', () => {
-    const initial = writeSkill(workspacePath, 'concurrency-skill', '# v1', 'agent-author', { status: 'draft' });
-    const initialUpdatedAt = String(initial.fields.updated);
-    const next = writeSkill(workspacePath, 'concurrency-skill', '# v2', 'agent-author', {
-      status: 'proposed',
-      expectedUpdatedAt: initialUpdatedAt,
-    });
-    expect(next.fields.status).toBe('proposed');
-
-    expect(() => writeSkill(workspacePath, 'concurrency-skill', '# v3', 'agent-author', {
-      status: 'active',
-      expectedUpdatedAt: initialUpdatedAt,
-    })).toThrow('Concurrent skill update detected');
-  });
-
-  it('writes dependency metadata into skill manifest', () => {
-    writeSkill(workspacePath, 'dep-skill', '# dep', 'agent-author', {
-      dependsOn: ['base-skill', 'skills/other/SKILL.md'],
-    });
-    const manifestRaw = fs.readFileSync(path.join(workspacePath, 'skills/dep-skill/skill-manifest.json'), 'utf-8');
-    const manifest = JSON.parse(manifestRaw) as { dependsOn?: string[] };
-    expect(manifest.dependsOn).toEqual(['base-skill', 'skills/other/SKILL.md']);
-  });
-
-  it('loads legacy flat skill paths for backwards compatibility', () => {
-    const legacyPath = path.join(workspacePath, 'skills');
-    fs.mkdirSync(legacyPath, { recursive: true });
-    fs.writeFileSync(
-      path.join(legacyPath, 'legacy-skill.md'),
-      [
-        '---',
-        'title: legacy-skill',
-        'status: draft',
-        'version: 0.1.0',
-        'created: 2026-02-27T00:00:00.000Z',
-        'updated: 2026-02-27T00:00:00.000Z',
-        '---',
-        '',
-        '# Legacy Skill',
-      ].join('\n'),
-      'utf-8',
-    );
-
-    const loaded = loadSkill(workspacePath, 'legacy-skill');
-    expect(loaded.path).toBe('skills/legacy-skill.md');
-  });
-});
diff --git a/packages/kernel/src/skill.ts b/packages/kernel/src/skill.ts
deleted file mode 100644
index 375e3e1..0000000
--- a/packages/kernel/src/skill.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-/**
- * Skill primitive lifecycle.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import * as ledger from './ledger.js';
-import type { LedgerEntry, PrimitiveInstance } from './types.js';
-
-export interface WriteSkillOptions {
-  owner?: string;
-  version?: string;
-  status?: 'draft' | 'proposed' | 'active' | 'deprecated' | 'archived';
-  distribution?: string;
-  reviewers?: string[];
-  tags?: string[];
-  dependsOn?: string[];
-  expectedUpdatedAt?: string;
-  tailscalePath?: string;
-}
-
-export interface ProposeSkillOptions {
-  proposalThread?: string;
-  createThreadIfMissing?: boolean;
-  space?: string;
-  reviewers?: string[];
-}
-
-export interface PromoteSkillOptions {
-  version?: string;
-}
-
-export function writeSkill(
-  workspacePath: string,
-  title: string,
-  body: string,
-  actor: string,
-  options: WriteSkillOptions = {},
-): PrimitiveInstance {
-  const slug = skillSlug(title);
-  const bundleSkillPath = folderSkillPath(slug);
-  const legacyPath = legacySkillPath(slug);
-  const existing = store.read(workspacePath, bundleSkillPath) ?? store.read(workspacePath, legacyPath);
-  const status = options.status ?? (existing?.fields.status as string | undefined) ?? 'draft';
-
-  if (existing && options.expectedUpdatedAt) {
-    const currentUpdatedAt = String(existing.fields.updated ?? '');
-    if (currentUpdatedAt !== options.expectedUpdatedAt) {
-      throw new Error(`Concurrent skill update detected for ${existing.path}. Expected updated="${options.expectedUpdatedAt}" but found "${currentUpdatedAt}".`);
-    }
-  }
-
-  if (!existing) {
-    ensureSkillBundleScaffold(workspacePath, slug);
-    const created = store.create(workspacePath, 'skill', {
-      title,
-      owner: options.owner ?? actor,
-      version: options.version ?? '0.1.0',
-      status,
-      distribution: options.distribution ?? 'shared-vault',
-      reviewers: options.reviewers ?? [],
-      depends_on: options.dependsOn ?? [],
-      tags: options.tags ?? [],
-    }, body, actor, {
-      pathOverride: bundleSkillPath,
-    });
-    writeSkillManifest(workspacePath, slug, created, actor);
-    return created;
-  }
-
-  const updated = store.update(workspacePath, existing.path, {
-    title,
-    owner: options.owner ?? existing.fields.owner ?? actor,
-    version: options.version ?? existing.fields.version ?? '0.1.0',
-    status,
-    distribution: options.distribution ?? existing.fields.distribution ?? 'shared-vault',
-    reviewers: options.reviewers ?? existing.fields.reviewers ?? [],
-    depends_on: options.dependsOn ?? existing.fields.depends_on ?? [],
-    tags: options.tags ?? existing.fields.tags ?? [],
-  }, body, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-
-export function loadSkill(workspacePath: string, skillRef: string): PrimitiveInstance {
-  const normalizedCandidates = normalizeSkillRefCandidates(skillRef);
-  const skill = normalizedCandidates
-    .map((candidate) => store.read(workspacePath, candidate))
-    .find((entry): entry is PrimitiveInstance => entry !== null);
-  if (!skill) throw new Error(`Skill not found: ${skillRef}`);
-  if (skill.type !== 'skill') throw new Error(`Target is not a skill primitive: ${skillRef}`);
-  return skill;
-}
-
-export function listSkills(
-  workspacePath: string,
-  options: { status?: string; updatedSince?: string } = {},
-): PrimitiveInstance[] {
-  let skills = store.list(workspacePath, 'skill');
-  if (options.status) {
-    skills = skills.filter((skill) => skill.fields.status === options.status);
-  }
-  if (options.updatedSince) {
-    const threshold = Date.parse(options.updatedSince);
-    if (Number.isFinite(threshold)) {
-      skills = skills.filter((skill) => {
-        const updatedAt = Date.parse(String(skill.fields.updated ?? ''));
-        return Number.isFinite(updatedAt) && updatedAt >= threshold;
-      });
-    }
-  }
-  return skills;
-}
-
-export function proposeSkill(
-  workspacePath: string,
-  skillRef: string,
-  actor: string,
-  options: ProposeSkillOptions = {},
-): PrimitiveInstance {
-  const skill = loadSkill(workspacePath, skillRef);
-  const slug = skillSlug(String(skill.fields.title ?? skillRef));
-
-  let proposalThread = options.proposalThread;
-  if (!proposalThread && options.createThreadIfMissing !== false) {
-    const createdThread = thread.createThread(
-      workspacePath,
-      `Review skill: ${String(skill.fields.title)}`,
-      `Review and approve skill ${skill.path} for activation.`,
-      actor,
-      {
-        priority: 'medium',
-        space: options.space,
-        context_refs: [skill.path],
-      },
-    );
-    proposalThread = createdThread.path;
-  }
-
-  const updated = store.update(workspacePath, skill.path, {
-    status: 'proposed',
-    proposal_thread: proposalThread ?? skill.fields.proposal_thread,
-    proposed_at: new Date().toISOString(),
-    reviewers: options.reviewers ?? skill.fields.reviewers ?? [],
-  }, undefined, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-
-export function skillHistory(
-  workspacePath: string,
-  skillRef: string,
-  options: { limit?: number } = {},
-): LedgerEntry[] {
-  const skill = loadSkill(workspacePath, skillRef);
-  const entries = ledger.historyOf(workspacePath, skill.path);
-  if (options.limit && options.limit > 0) {
-    return entries.slice(-options.limit);
-  }
-  return entries;
-}
-
-export function skillDiff(
-  workspacePath: string,
-  skillRef: string,
-): {
-  path: string;
-  latestEntryTs: string | null;
-  previousEntryTs: string | null;
-  changedFields: string[];
-} {
-  const skill = loadSkill(workspacePath, skillRef);
-  const entries = ledger.historyOf(workspacePath, skill.path).filter((entry) => entry.op === 'create' || entry.op === 'update');
-  const latest = entries.length > 0 ? entries[entries.length - 1] : null;
-  const previous = entries.length > 1 ? entries[entries.length - 2] : null;
-  const changedFields = Array.isArray(latest?.data?.changed)
-    ? latest!.data!.changed.map((value) => String(value))
-    : latest?.op === 'create'
-      ? Object.keys(skill.fields)
-      : [];
-  return {
-    path: skill.path,
-    latestEntryTs: latest?.ts ?? null,
-    previousEntryTs: previous?.ts ?? null,
-    changedFields,
-  };
-}
-
-export function promoteSkill(
-  workspacePath: string,
-  skillRef: string,
-  actor: string,
-  options: PromoteSkillOptions = {},
-): PrimitiveInstance {
-  const skill = loadSkill(workspacePath, skillRef);
-  const slug = skillSlug(String(skill.fields.title ?? skillRef));
-  const currentVersion = String(skill.fields.version ?? '0.1.0');
-  const nextVersion = options.version ?? bumpPatchVersion(currentVersion);
-
-  const updated = store.update(workspacePath, skill.path, {
-    status: 'active',
-    version: nextVersion,
-    promoted_at: new Date().toISOString(),
-  }, undefined, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-
-function skillSlug(title: string): string {
-  return title
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '')
-    .slice(0, 80);
-}
-
-function normalizeSkillRefCandidates(skillRef: string): string[] {
-  const raw = skillRef.trim();
-  if (!raw) return [];
-  if (raw.includes('/')) {
-    const normalized = raw.endsWith('.md') ? raw : `${raw}.md`;
-    if (normalized.endsWith('/SKILL.md')) return [normalized];
-    if (normalized.endsWith('/SKILL')) return [`${normalized}.md`];
-    if (normalized.endsWith('.md')) {
-      const noExt = normalized.slice(0, -3);
-      return [normalized, `${noExt}/SKILL.md`];
-    }
-    return [normalized, `${normalized}/SKILL.md`];
-  }
-  const slug = skillSlug(raw);
-  return [folderSkillPath(slug), legacySkillPath(slug)];
-}
-
-function bumpPatchVersion(version: string): string {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return '0.1.0';
-  const major = Number.parseInt(match[1], 10);
-  const minor = Number.parseInt(match[2], 10);
-  const patch = Number.parseInt(match[3], 10) + 1;
-  return `${major}.${minor}.${patch}`;
-}
-
-function folderSkillPath(slug: string): string {
-  return `skills/${slug}/SKILL.md`;
-}
-
-function legacySkillPath(slug: string): string {
-  return `skills/${slug}.md`;
-}
-
-function ensureSkillBundleScaffold(workspacePath: string, slug: string): void {
-  const skillRoot = path.join(workspacePath, 'skills', slug);
-  fs.mkdirSync(skillRoot, { recursive: true });
-  for (const subdir of ['scripts', 'examples', 'tests', 'assets']) {
-    fs.mkdirSync(path.join(skillRoot, subdir), { recursive: true });
-  }
-}
-
-function writeSkillManifest(
-  workspacePath: string,
-  slug: string,
-  skill: PrimitiveInstance,
-  actor: string,
-): void {
-  const manifestPath = path.join(workspacePath, 'skills', slug, 'skill-manifest.json');
-  const dir = path.dirname(manifestPath);
-  fs.mkdirSync(dir, { recursive: true });
-  const manifest = {
-    version: 1,
-    slug,
-    title: String(skill.fields.title ?? slug),
-    primitivePath: skill.path,
-    owner: String(skill.fields.owner ?? actor),
-    skillVersion: String(skill.fields.version ?? '0.1.0'),
-    status: String(skill.fields.status ?? 'draft'),
-    dependsOn: Array.isArray(skill.fields.depends_on)
-      ? skill.fields.depends_on.map((value) => String(value))
-      : [],
-    components: {
-      skillDoc: 'SKILL.md',
-      scriptsDir: 'scripts/',
-      examplesDir: 'examples/',
-      testsDir: 'tests/',
-      assetsDir: 'assets/',
-    },
-    updatedAt: new Date().toISOString(),
-  };
-  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
-}
diff --git a/packages/kernel/src/storage-adapter.test.ts b/packages/kernel/src/storage-adapter.test.ts
deleted file mode 100644
index 0021ef9..0000000
--- a/packages/kernel/src/storage-adapter.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { LocalStorageAdapter } from './storage-adapter.js';
-
-let tempRoot: string;
-
-beforeEach(() => {
-  tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-storage-adapter-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-
-describe('LocalStorageAdapter', () => {
-  it('resolves relative paths against an optional rootPath', () => {
-    const adapter = new LocalStorageAdapter({ rootPath: tempRoot });
-    const resolved = adapter.resolve('nested/file.txt');
-
-    expect(resolved).toBe(path.join(tempRoot, 'nested/file.txt'));
-  });
-
-  it('supports mkdir/write/read/stat/exists operations', () => {
-    const adapter = new LocalStorageAdapter({ rootPath: tempRoot });
-    adapter.mkdir('docs', { recursive: true });
-    adapter.writeFile('docs/readme.md', '# Storage Adapter\n');
-
-    expect(adapter.exists('docs/readme.md')).toBe(true);
-    expect(adapter.readFile('docs/readme.md')).toContain('Storage Adapter');
-    expect(adapter.stat('docs').isDirectory()).toBe(true);
-    expect(adapter.stat('docs/readme.md').isFile()).toBe(true);
-    expect(adapter.readdir('docs')).toContain('readme.md');
-  });
-
-  it('supports cp and rm operations', () => {
-    const adapter = new LocalStorageAdapter({ rootPath: tempRoot });
-    adapter.mkdir('source', { recursive: true });
-    adapter.writeFile('source/file.md', 'content\n');
-    adapter.cp('source', 'target', { recursive: true });
-
-    expect(adapter.exists('target/file.md')).toBe(true);
-    adapter.rm('target', { recursive: true, force: true });
-    expect(adapter.exists('target')).toBe(false);
-  });
-});
diff --git a/packages/kernel/src/storage-adapter.ts b/packages/kernel/src/storage-adapter.ts
deleted file mode 100644
index a02a659..0000000
--- a/packages/kernel/src/storage-adapter.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-export type StorageAdapterKind = 'local' | 'cloud';
-
-export interface StorageAdapter {
-  readonly kind: StorageAdapterKind;
-  resolve(targetPath: string): string;
-  exists(targetPath: string): boolean;
-  readFile(targetPath: string, encoding?: BufferEncoding): string;
-  writeFile(targetPath: string, data: string | Uint8Array): void;
-  mkdir(targetPath: string, options?: { recursive?: boolean }): void;
-  readdir(targetPath: string): string[];
-  rm(targetPath: string, options?: { recursive?: boolean; force?: boolean }): void;
-  cp(
-    sourcePath: string,
-    destinationPath: string,
-    options?: { recursive?: boolean; force?: boolean; errorOnExist?: boolean },
-  ): void;
-  stat(targetPath: string): fs.Stats;
-}
-
-export interface LocalStorageAdapterOptions {
-  rootPath?: string;
-}
-
-export class LocalStorageAdapter implements StorageAdapter {
-  readonly kind = 'local' as const;
-  private readonly rootPath?: string;
-
-  constructor(options: LocalStorageAdapterOptions = {}) {
-    this.rootPath = options.rootPath ? path.resolve(options.rootPath) : undefined;
-  }
-
-  resolve(targetPath: string): string {
-    if (path.isAbsolute(targetPath)) return targetPath;
-    if (!this.rootPath) return path.resolve(targetPath);
-    return path.resolve(this.rootPath, targetPath);
-  }
-
-  exists(targetPath: string): boolean {
-    return fs.existsSync(this.resolve(targetPath));
-  }
-
-  readFile(targetPath: string, encoding: BufferEncoding = 'utf-8'): string {
-    return fs.readFileSync(this.resolve(targetPath), encoding);
-  }
-
-  writeFile(targetPath: string, data: string | Uint8Array): void {
-    fs.writeFileSync(this.resolve(targetPath), data);
-  }
-
-  mkdir(targetPath: string, options: { recursive?: boolean } = {}): void {
-    fs.mkdirSync(this.resolve(targetPath), { recursive: options.recursive === true });
-  }
-
-  readdir(targetPath: string): string[] {
-    return fs.readdirSync(this.resolve(targetPath));
-  }
-
-  rm(targetPath: string, options: { recursive?: boolean; force?: boolean } = {}): void {
-    fs.rmSync(this.resolve(targetPath), {
-      recursive: options.recursive === true,
-      force: options.force === true,
-    });
-  }
-
-  cp(
-    sourcePath: string,
-    destinationPath: string,
-    options: { recursive?: boolean; force?: boolean; errorOnExist?: boolean } = {},
-  ): void {
-    fs.cpSync(this.resolve(sourcePath), this.resolve(destinationPath), {
-      recursive: options.recursive === true,
-      force: options.force ?? true,
-      errorOnExist: options.errorOnExist === true,
-    });
-  }
-
-  stat(targetPath: string): fs.Stats {
-    return fs.statSync(this.resolve(targetPath));
-  }
-}
-
-// Stub contract for future cloud-backed implementations.
-export interface CloudStorageAdapter extends StorageAdapter {
-  readonly kind: 'cloud';
-  readonly provider: string;
-  readonly bucketOrNamespace: string;
-  toObjectUri(targetPath: string): string;
-}
diff --git a/packages/kernel/src/swarm.test.ts b/packages/kernel/src/swarm.test.ts
deleted file mode 100644
index 3bcf0b0..0000000
--- a/packages/kernel/src/swarm.test.ts
+++ /dev/null
@@ -1,180 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { initWorkspace } from './workspace.js';
-import {
-  createPlanTemplate,
-  validatePlan,
-  deployPlan,
-  getSwarmStatus,
-  workerClaim,
-  workerComplete,
-  workerLoop,
-  synthesize,
-  type SwarmPlan,
-  type SwarmTask,
-} from './swarm.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-swarm-'));
-  initWorkspace(workspacePath);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-function makePlan(taskCount: number): SwarmPlan {
-  const tasks: SwarmTask[] = [];
-  for (let i = 0; i < taskCount; i++) {
-    tasks.push({
-      title: `Task ${i + 1}`,
-      description: `Do task ${i + 1}`,
-      priority: i < 3 ? 'high' : 'medium',
-      dependsOn: i > 0 && i % 5 === 0 ? [`Task ${i}`] : undefined,
-      tags: ['test'],
-    });
-  }
-  const plan = createPlanTemplate({
-    title: 'Test Swarm',
-    description: 'A test swarm with many tasks',
-    maxTasks: 500,
-  });
-  plan.tasks = tasks;
-  plan.phases = [
-    { name: 'Phase 1', description: 'First batch', taskIndices: tasks.map((_, i) => i), parallel: true },
-  ];
-  return plan;
-}
-
-describe('swarm', () => {
-  it('validates plans correctly', () => {
-    const plan = makePlan(5);
-    const result = validatePlan(plan);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('detects empty plans', () => {
-    const plan = createPlanTemplate({ title: 'Empty', description: '' });
-    const result = validatePlan(plan);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('no tasks'))).toBe(true);
-  });
-
-  it('detects circular dependencies', () => {
-    const plan = makePlan(3);
-    plan.tasks[0].dependsOn = ['Task 3'];
-    plan.tasks[2].dependsOn = ['Task 1'];
-    const result = validatePlan(plan);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('Circular'))).toBe(true);
-  });
-
-  it('deploys a plan and creates threads', () => {
-    const plan = makePlan(10);
-    const deployment = deployPlan(workspacePath, plan, 'test-agent');
-    expect(deployment.threadPaths).toHaveLength(10);
-    expect(deployment.status).toBe('deployed');
-
-    const status = getSwarmStatus(workspacePath, deployment.spaceSlug);
-    expect(status.total).toBe(10);
-    expect(status.open).toBe(10);
-    expect(status.done).toBe(0);
-    expect(status.percentComplete).toBe(0);
-  });
-
-  it('workers can claim and complete tasks', () => {
-    const plan = makePlan(5);
-    const deployment = deployPlan(workspacePath, plan, 'test-agent');
-
-    // Worker claims
-    const claimed = workerClaim(workspacePath, deployment.spaceSlug, 'worker-1');
-    expect(claimed).not.toBeNull();
-    expect(claimed!.fields.status).toBe('active');
-
-    // Worker completes
-    const completed = workerComplete(
-      workspacePath,
-      claimed!.path,
-      'worker-1',
-      'This is the result of my work.',
-    );
-    expect(completed.fields.status).toBe('done');
-
-    // Status updates
-    const status = getSwarmStatus(workspacePath, deployment.spaceSlug);
-    expect(status.done).toBe(1);
-    expect(status.percentComplete).toBe(20);
-  });
-
-  it('worker loop processes multiple tasks', async () => {
-    const plan = makePlan(5);
-    const deployment = deployPlan(workspacePath, plan, 'test-agent');
-
-    const result = await workerLoop(
-      workspacePath,
-      deployment.spaceSlug,
-      'worker-1',
-      async (thread) => `Result for: ${thread.fields.title}`,
-      { delayMs: 0, maxTasks: plan.tasks.length },
-    );
-
-    expect(result.completed).toBe(5);
-    expect(result.errors).toBe(0);
-
-    const status = getSwarmStatus(workspacePath, deployment.spaceSlug);
-    expect(status.done).toBe(5);
-    expect(status.percentComplete).toBe(100);
-  });
-
-  it('synthesizes results into a document', async () => {
-    const plan = makePlan(3);
-    const deployment = deployPlan(workspacePath, plan, 'test-agent');
-
-    await workerLoop(
-      workspacePath,
-      deployment.spaceSlug,
-      'worker-1',
-      async (thread) => `Content for ${thread.fields.title}: Lorem ipsum dolor sit amet.`,
-      { delayMs: 0, maxTasks: plan.tasks.length },
-    );
-
-    const synthesis = synthesize(workspacePath, deployment.spaceSlug);
-    expect(synthesis.completedCount).toBe(3);
-    expect(synthesis.totalCount).toBe(3);
-    expect(synthesis.markdown).toContain('Test Swarm');
-    expect(synthesis.markdown).toContain('Lorem ipsum');
-    expect(synthesis.markdown).toContain('3/3 tasks completed');
-  });
-
-  it('handles larger swarms (30 tasks)', async () => {
-    const plan = makePlan(30);
-    const deployment = deployPlan(workspacePath, plan, 'test-agent');
-
-    const status = getSwarmStatus(workspacePath, deployment.spaceSlug);
-    expect(status.total).toBe(30);
-    expect(status.open).toBe(30);
-
-    // Simulate 3 workers running in parallel
-    const results = await Promise.all([
-      workerLoop(workspacePath, deployment.spaceSlug, 'worker-1',
-        async (t) => `W1: ${t.fields.title}`, { delayMs: 0, maxTasks: plan.tasks.length }),
-      workerLoop(workspacePath, deployment.spaceSlug, 'worker-2',
-        async (t) => `W2: ${t.fields.title}`, { delayMs: 0, maxTasks: plan.tasks.length }),
-      workerLoop(workspacePath, deployment.spaceSlug, 'worker-3',
-        async (t) => `W3: ${t.fields.title}`, { delayMs: 0, maxTasks: plan.tasks.length }),
-    ]);
-
-    const totalCompleted = results.reduce((sum, r) => sum + r.completed, 0);
-    const totalErrors = results.reduce((sum, r) => sum + r.errors, 0);
-    // Concurrent workers may race on claims; expect robust completion progress.
-    expect(totalCompleted + totalErrors).toBeGreaterThanOrEqual(20);
-
-    const finalStatus = getSwarmStatus(workspacePath, deployment.spaceSlug);
-    expect(finalStatus.done).toBeGreaterThanOrEqual(20);
-  });
-});
diff --git a/packages/kernel/src/swarm.ts b/packages/kernel/src/swarm.ts
deleted file mode 100644
index 27685eb..0000000
--- a/packages/kernel/src/swarm.ts
+++ /dev/null
@@ -1,522 +0,0 @@
-/**
- * WorkGraph Swarm — Decompose goals into hundreds of tasks,
- * spawn agent containers to claim and complete them, merge results.
- *
- * Architecture:
- *   1. Planner: Takes a goal → decomposes into N threads with dependencies
- *   2. Orchestrator: Spawns containers, each runs a worker that claims threads
- *   3. Worker: Claims a thread, does work, writes result, marks done
- *   4. Synthesizer: Watches for completion, merges results
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as thread from './thread.js';
-import * as store from './store.js';
-import * as ledger from './ledger.js';
-import type { PrimitiveInstance } from './types.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface SwarmGoal {
-  title: string;
-  description: string;
-  outputFormat?: 'markdown' | 'json' | 'code';
-  maxTasks?: number;
-  maxConcurrent?: number;
-  tags?: string[];
-}
-
-export interface SwarmTask {
-  title: string;
-  description: string;
-  priority: 'critical' | 'high' | 'medium' | 'low';
-  dependsOn?: string[];
-  estimatedMinutes?: number;
-  outputType?: string;
-  tags?: string[];
-}
-
-export interface SwarmPlan {
-  goal: SwarmGoal;
-  tasks: SwarmTask[];
-  phases: SwarmPhase[];
-  createdAt: string;
-  estimatedTotalMinutes: number;
-}
-
-export interface SwarmPhase {
-  name: string;
-  description: string;
-  taskIndices: number[];
-  parallel: boolean;
-}
-
-export interface SwarmDeployment {
-  planPath: string;
-  workspacePath: string;
-  threadPaths: string[];
-  spaceSlug: string;
-  createdAt: string;
-  status: 'deployed' | 'running' | 'completing' | 'done' | 'failed';
-}
-
-export interface SwarmStatus {
-  deployment: SwarmDeployment;
-  total: number;
-  claimed: number;
-  done: number;
-  blocked: number;
-  open: number;
-  readyToClaim: number;
-  percentComplete: number;
-  threads: Array<{
-    path: string;
-    title: string;
-    status: string;
-    owner?: string;
-    priority: string;
-  }>;
-}
-
-// ---------------------------------------------------------------------------
-// Plan Generation (produces structured plan from goal)
-// ---------------------------------------------------------------------------
-
-/**
- * Generate a swarm plan from a goal description.
- * This creates the plan structure — call deployPlan() to create actual threads.
- *
- * In production, pipe goal through an LLM for decomposition.
- * This function provides the structured output format the LLM should produce.
- */
-export function createPlanTemplate(goal: SwarmGoal): SwarmPlan {
-  return {
-    goal,
-    tasks: [],
-    phases: [],
-    createdAt: new Date().toISOString(),
-    estimatedTotalMinutes: 0,
-  };
-}
-
-/**
- * Validate a swarm plan for internal consistency.
- */
-export function validatePlan(plan: SwarmPlan): { valid: boolean; errors: string[] } {
-  const errors: string[] = [];
-
-  if (!plan.goal.title) errors.push('Goal title is required');
-  if (plan.tasks.length === 0) errors.push('Plan has no tasks');
-  if (plan.tasks.length > (plan.goal.maxTasks ?? 1000)) {
-    errors.push(`Plan has ${plan.tasks.length} tasks, exceeds max ${plan.goal.maxTasks ?? 1000}`);
-  }
-
-  // Check dependency references
-  const taskTitles = new Set(plan.tasks.map(t => t.title));
-  for (const task of plan.tasks) {
-    for (const dep of task.dependsOn ?? []) {
-      if (!taskTitles.has(dep)) {
-        errors.push(`Task "${task.title}" depends on unknown task "${dep}"`);
-      }
-    }
-  }
-
-  // Check for circular dependencies
-  const visited = new Set<string>();
-  const stack = new Set<string>();
-  const depMap = new Map<string, string[]>();
-  for (const task of plan.tasks) {
-    depMap.set(task.title, task.dependsOn ?? []);
-  }
-
-  function hasCycle(node: string): boolean {
-    if (stack.has(node)) return true;
-    if (visited.has(node)) return false;
-    visited.add(node);
-    stack.add(node);
-    for (const dep of depMap.get(node) ?? []) {
-      if (hasCycle(dep)) return true;
-    }
-    stack.delete(node);
-    return false;
-  }
-
-  for (const task of plan.tasks) {
-    visited.clear();
-    stack.clear();
-    if (hasCycle(task.title)) {
-      errors.push(`Circular dependency detected involving "${task.title}"`);
-      break;
-    }
-  }
-
-  // Check phases reference valid task indices
-  for (const phase of plan.phases) {
-    for (const idx of phase.taskIndices) {
-      if (idx < 0 || idx >= plan.tasks.length) {
-        errors.push(`Phase "${phase.name}" references invalid task index ${idx}`);
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-// ---------------------------------------------------------------------------
-// Plan Deployment (creates threads in a workspace)
-// ---------------------------------------------------------------------------
-
-/**
- * Deploy a swarm plan into a WorkGraph workspace.
- * Creates a space for the swarm and threads for each task.
- * Dependencies are encoded as wiki-links in thread bodies.
- */
-export function deployPlan(
-  workspacePath: string,
-  plan: SwarmPlan,
-  actor: string,
-): SwarmDeployment {
-  const validation = validatePlan(plan);
-  if (!validation.valid) {
-    throw new Error(`Invalid plan: ${validation.errors.join('; ')}`);
-  }
-
-  // Create swarm space
-  const spaceSlug = slugify(`swarm-${plan.goal.title}`);
-  const spacePath = path.join('spaces', `${spaceSlug}.md`);
-  const spaceFullPath = path.join(workspacePath, spacePath);
-  if (!fs.existsSync(spaceFullPath)) {
-    const spaceDir = path.join(workspacePath, 'spaces');
-    fs.mkdirSync(spaceDir, { recursive: true });
-    const spaceFrontmatter = [
-      '---',
-      `title: "Swarm: ${plan.goal.title}"`,
-      `status: active`,
-      `created: '${new Date().toISOString()}'`,
-      `updated: '${new Date().toISOString()}'`,
-      '---',
-      '',
-      `# Swarm Space: ${plan.goal.title}`,
-      '',
-      plan.goal.description,
-      '',
-      `Total tasks: ${plan.tasks.length}`,
-    ].join('\n');
-    fs.writeFileSync(spaceFullPath, spaceFrontmatter);
-  }
-
-  // Create threads for each task
-  const threadPaths: string[] = [];
-  const slugMap = new Map<string, string>(); // task title -> thread slug
-
-  for (const task of plan.tasks) {
-    const taskSlug = slugify(task.title);
-    slugMap.set(task.title, taskSlug);
-  }
-
-  for (const task of plan.tasks) {
-    const taskSlug = slugMap.get(task.title)!;
-    // Build body with dependency links
-    let body = `# ${task.title}\n\n${task.description}\n`;
-
-    if (task.dependsOn && task.dependsOn.length > 0) {
-      body += `\n## Dependencies\n`;
-      for (const dep of task.dependsOn) {
-        const depSlug = slugMap.get(dep);
-        if (depSlug) {
-          body += `- [[${depSlug}]]\n`;
-        }
-      }
-    }
-
-    body += `\n## Output\n\n_Agent writes result here._\n`;
-
-    if (task.tags && task.tags.length > 0) {
-      body += `\nTags: ${task.tags.join(', ')}\n`;
-    }
-
-    const created = thread.createThread(workspacePath, task.title, body, actor, {
-      priority: task.priority,
-      space: `spaces/${spaceSlug}`,
-    });
-
-    threadPaths.push(created.path);
-  }
-
-  // Save deployment manifest  
-  const deployment: SwarmDeployment = {
-    planPath: path.join('.workgraph', `swarm-${spaceSlug}.json`),
-    workspacePath,
-    threadPaths,
-    spaceSlug,
-    createdAt: new Date().toISOString(),
-    status: 'deployed',
-  };
-
-  const manifestPath = path.join(workspacePath, deployment.planPath);
-  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-  fs.writeFileSync(manifestPath, JSON.stringify({ plan, deployment }, null, 2));
-
-  ledger.append(workspacePath, actor, 'create', deployment.planPath, 'swarm');
-
-  return deployment;
-}
-
-// ---------------------------------------------------------------------------
-// Swarm Status
-// ---------------------------------------------------------------------------
-
-/**
- * Get the current status of a swarm deployment.
- */
-export function getSwarmStatus(
-  workspacePath: string,
-  spaceSlug: string,
-): SwarmStatus {
-  // Load deployment manifest
-  const manifestPath = path.join(workspacePath, '.workgraph', `swarm-${spaceSlug}.json`);
-  if (!fs.existsSync(manifestPath)) {
-    throw new Error(`No swarm deployment found for space "${spaceSlug}"`);
-  }
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-  const deployment: SwarmDeployment = manifest.deployment;
-
-  // Check thread statuses
-  const threads: SwarmStatus['threads'] = [];
-  let claimed = 0;
-  let done = 0;
-  let blocked = 0;
-  let open = 0;
-
-  for (const threadPath of deployment.threadPaths) {
-    const t = store.read(workspacePath, threadPath);
-    if (!t) continue;
-    const status = String(t.fields.status ?? 'open');
-    const threadInfo = {
-      path: threadPath,
-      title: String(t.fields.title ?? ''),
-      status,
-      owner: t.fields.owner ? String(t.fields.owner) : undefined,
-      priority: String(t.fields.priority ?? 'medium'),
-    };
-    threads.push(threadInfo);
-
-    if (status === 'done') done++;
-    else if (status === 'active') claimed++;
-    else if (status === 'blocked') blocked++;
-    else open++;
-  }
-
-  const total = deployment.threadPaths.length;
-  const readyToClaim = open; // simplified — could check dependencies
-  const percentComplete = total > 0 ? Math.round((done / total) * 100) : 0;
-
-  // Update deployment status based on progress
-  if (done === total) deployment.status = 'done';
-  else if (claimed > 0 || done > 0) deployment.status = 'running';
-
-  return {
-    deployment,
-    total,
-    claimed,
-    done,
-    blocked,
-    open,
-    readyToClaim,
-    percentComplete,
-    threads,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Worker Protocol
-// ---------------------------------------------------------------------------
-
-/**
- * Worker claims the next available task in a swarm.
- * Returns the thread to work on, or null if nothing available.
- */
-export function workerClaim(
-  workspacePath: string,
-  spaceSlug: string,
-  agent: string,
-): PrimitiveInstance | null {
-  // Find ready threads in this space
-  const ready = thread.listReadyThreadsInSpace(workspacePath, `spaces/${spaceSlug}`);
-  if (ready.length === 0) return null;
-
-  // Sort by priority
-  const priorityOrder: Record<string, number> = {
-    critical: 0,
-    high: 1,
-    medium: 2,
-    low: 3,
-  };
-  ready.sort((a, b) => {
-    const aPri = priorityOrder[String(a.fields.priority)] ?? 2;
-    const bPri = priorityOrder[String(b.fields.priority)] ?? 2;
-    return aPri - bPri;
-  });
-
-  // Claim the highest priority ready thread
-  const target = ready[0];
-  return thread.claim(workspacePath, target.path, agent);
-}
-
-/**
- * Worker completes a task, writing result to the thread body.
- */
-export function workerComplete(
-  workspacePath: string,
-  threadPath: string,
-  agent: string,
-  result: string,
-): PrimitiveInstance {
-  // Read current thread
-  const t = store.read(workspacePath, threadPath);
-  if (!t) throw new Error(`Thread not found: ${threadPath}`);
-
-  // Append result to body
-  const currentBody = t.body ?? '';
-  const updatedBody = currentBody.replace(
-    '_Agent writes result here._',
-    result,
-  );
-
-  return thread.done(workspacePath, threadPath, agent, updatedBody, {
-    evidence: [{ type: 'thread-ref', value: threadPath }],
-  });
-}
-
-/**
- * Worker loop: claim → work → complete → repeat until no tasks left.
- * The workFn receives the thread and returns the result string.
- */
-export async function workerLoop(
-  workspacePath: string,
-  spaceSlug: string,
-  agent: string,
-  workFn: (thread: PrimitiveInstance) => Promise<string>,
-  options?: { maxTasks?: number; delayMs?: number },
-): Promise<{ completed: number; errors: number }> {
-  let completed = 0;
-  let errors = 0;
-  // Safety cap: default to the deployment task count so a malformed scheduler
-  // cannot spin forever in long-lived worker loops.
-  const inferredTaskCap = inferSwarmTaskCap(workspacePath, spaceSlug);
-  const maxTasks = options?.maxTasks ?? inferredTaskCap ?? Infinity;
-  const delayMs = options?.delayMs ?? 1000;
-
-  while (completed + errors < maxTasks) {
-    let claimed: PrimitiveInstance | null = null;
-    try {
-      claimed = workerClaim(workspacePath, spaceSlug, agent);
-    } catch {
-      // Claim contention can happen under parallel workers; treat as retryable.
-      errors++;
-      if (delayMs > 0) {
-        await new Promise(resolve => setTimeout(resolve, delayMs));
-      }
-      continue;
-    }
-    if (!claimed) break; // No more work
-
-    try {
-      const result = await workFn(claimed);
-      workerComplete(workspacePath, claimed.path, agent, result);
-      completed++;
-    } catch (err) {
-      errors++;
-      // Log error but continue
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      try {
-        store.update(workspacePath, claimed.path, {
-          status: 'blocked',
-        }, `Error: ${errorMsg}`, agent);
-      } catch {
-        // Best effort
-      }
-    }
-
-    if (delayMs > 0) {
-      await new Promise(resolve => setTimeout(resolve, delayMs));
-    }
-  }
-
-  return { completed, errors };
-}
-
-function inferSwarmTaskCap(workspacePath: string, spaceSlug: string): number | null {
-  try {
-    return getSwarmStatus(workspacePath, spaceSlug).total;
-  } catch {
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Synthesizer
-// ---------------------------------------------------------------------------
-
-/**
- * Collect all completed task results from a swarm into a single document.
- */
-export function synthesize(
-  workspacePath: string,
-  spaceSlug: string,
-): { markdown: string; completedCount: number; totalCount: number } {
-  const status = getSwarmStatus(workspacePath, spaceSlug);
-  const sections: string[] = [];
-
-  // Load the manifest for phase ordering
-  const manifestPath = path.join(workspacePath, '.workgraph', `swarm-${spaceSlug}.json`);
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-  const plan: SwarmPlan = manifest.plan;
-
-  sections.push(`# ${plan.goal.title}\n`);
-  sections.push(`${plan.goal.description}\n`);
-  sections.push(`---\n`);
-
-  // Collect results in thread order
-  for (const threadInfo of status.threads) {
-    const t = store.read(workspacePath, threadInfo.path);
-    if (!t) continue;
-    if (threadInfo.status !== 'done') {
-      sections.push(`## [PENDING] ${threadInfo.title}\n\n_Not yet completed._\n`);
-      continue;
-    }
-    // Use the full body as the result (agent replaces the placeholder)
-    const body = t.body ?? '';
-    const result = body.replace(/^#\s+.*\n/, '').trim(); // strip the title heading
-
-    if (result && result !== '_Agent writes result here._') {
-      sections.push(`## ${threadInfo.title}\n\n${result}\n`);
-    } else {
-      sections.push(`## ${threadInfo.title}\n\n_Completed but no output found._\n`);
-    }
-  }
-
-  sections.push(`\n---\n`);
-  sections.push(`*Generated from swarm "${plan.goal.title}" — ${status.done}/${status.total} tasks completed.*\n`);
-
-  return {
-    markdown: sections.join('\n'),
-    completedCount: status.done,
-    totalCount: status.total,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function slugify(text: string): string {
-  return text
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .substring(0, 80);
-}
diff --git a/packages/kernel/src/thread.ts b/packages/kernel/src/thread.ts
index 7e14216..a49c953 100644
--- a/packages/kernel/src/thread.ts
+++ b/packages/kernel/src/thread.ts
@@ -9,7 +9,6 @@ import * as ledger from './ledger.js';
 import * as store from './store.js';
 import * as auth from './auth.js';
 import * as claimLease from './claim-lease.js';
-import * as triggerEngine from './trigger-engine.js';
 import * as gate from './gate.js';
 import { collectThreadEvidence, validateThreadEvidence } from './evidence.js';
 import type {
@@ -621,13 +620,6 @@ export function done(
   });
   claimLease.removeClaimLease(workspacePath, threadPath);
 
-  // Cascade trigger failures should not roll back a successful thread completion.
-  try {
-    triggerEngine.evaluateThreadCompleteCascadeTriggers(workspacePath, threadPath, actor);
-  } catch {
-    // No-op: trigger engine state captures per-trigger errors during cascade evaluation.
-  }
-
   return completed;
 }
 
diff --git a/packages/kernel/src/transport/_shared.ts b/packages/kernel/src/transport/_shared.ts
deleted file mode 100644
index f9e5108..0000000
--- a/packages/kernel/src/transport/_shared.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import matter from 'gray-matter';
-
-export const TRANSPORT_ROOT = '.workgraph/transport';
-
-export interface TransportAttempt {
-  ts: string;
-  status: 'pending' | 'delivered' | 'failed' | 'replayed';
-  message?: string;
-  error?: string;
-}
-
-export function readTransportRecord<T>(filePath: string, hydrate: (frontmatter: Record<string, unknown>) => T): T | null {
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const parsed = matter(fs.readFileSync(filePath, 'utf-8'));
-    return hydrate(asRecord(parsed.data));
-  } catch {
-    return null;
-  }
-}
-
-export function writeTransportRecord(
-  filePath: string,
-  frontmatter: Record<string, unknown>,
-  body: string,
-): void {
-  const directory = path.dirname(filePath);
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  fs.writeFileSync(filePath, matter.stringify(body, stripUndefined(frontmatter)), 'utf-8');
-}
-
-export function listTransportRecordFiles(directory: string): string[] {
-  if (!fs.existsSync(directory)) return [];
-  return fs.readdirSync(directory)
-    .filter((entry) => entry.endsWith('.md'))
-    .map((entry) => path.join(directory, entry))
-    .sort((left, right) => {
-      const leftStat = fs.statSync(left);
-      const rightStat = fs.statSync(right);
-      return rightStat.mtimeMs - leftStat.mtimeMs;
-    });
-}
-
-export function renderJsonSection(title: string, value: unknown): string {
-  return [
-    `## ${title}`,
-    '',
-    '```json',
-    JSON.stringify(value, null, 2),
-    '```',
-    '',
-  ].join('\n');
-}
-
-export function normalizeTimestamp(value: unknown, fallback: string = new Date().toISOString()): string {
-  if (typeof value !== 'string') return fallback;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : fallback;
-}
-
-export function normalizeString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-export function normalizeStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return [...new Set(value.map((entry) => String(entry ?? '').trim()).filter(Boolean))];
-}
-
-export function normalizeAttemptArray(value: unknown): TransportAttempt[] {
-  if (!Array.isArray(value)) return [];
-  const attempts: TransportAttempt[] = [];
-  for (const entry of value) {
-    const candidate = asRecord(entry);
-    const ts = normalizeTimestamp(candidate.ts);
-    const status = normalizeAttemptStatus(candidate.status);
-    if (!status) continue;
-    attempts.push({
-      ts,
-      status,
-      ...(normalizeString(candidate.message) ? { message: normalizeString(candidate.message) } : {}),
-      ...(normalizeString(candidate.error) ? { error: normalizeString(candidate.error) } : {}),
-    });
-  }
-  return attempts;
-}
-
-export function normalizeAttemptStatus(value: unknown): TransportAttempt['status'] | undefined {
-  const normalized = normalizeString(value)?.toLowerCase();
-  if (normalized === 'pending' || normalized === 'delivered' || normalized === 'failed' || normalized === 'replayed') {
-    return normalized;
-  }
-  return undefined;
-}
-
-export function asRecord(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  return value as Record<string, unknown>;
-}
-
-export function stripUndefined<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => stripUndefined(entry))
-      .filter((entry) => entry !== undefined) as T;
-  }
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-  const cleaned: Record<string, unknown> = {};
-  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-    if (entry === undefined) continue;
-    cleaned[key] = stripUndefined(entry);
-  }
-  return cleaned as T;
-}
diff --git a/packages/kernel/src/transport/dead-letter.ts b/packages/kernel/src/transport/dead-letter.ts
deleted file mode 100644
index ef2acfa..0000000
--- a/packages/kernel/src/transport/dead-letter.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import path from 'node:path';
-import {
-  TRANSPORT_ROOT,
-  asRecord,
-  listTransportRecordFiles,
-  type TransportAttempt,
-  normalizeAttemptArray,
-  normalizeString,
-  normalizeTimestamp,
-  readTransportRecord,
-  renderJsonSection,
-  writeTransportRecord,
-} from './_shared.js';
-import { normalizeTransportEnvelope, type TransportEnvelope } from './envelope.js';
-
-const DEAD_LETTER_DIRECTORY = 'dead-letter';
-
-export interface TransportDeadLetterRecord {
-  id: string;
-  sourceRecordType: 'outbox' | 'inbox';
-  sourceRecordId: string;
-  status: 'failed' | 'replayed';
-  envelope: TransportEnvelope;
-  attempts: TransportAttempt[];
-  error: {
-    message: string;
-    ts: string;
-    context?: Record<string, unknown>;
-  };
-  replayedAt?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface RecordTransportDeadLetterInput {
-  sourceRecordType: 'outbox' | 'inbox';
-  sourceRecordId: string;
-  envelope: TransportEnvelope;
-  attempts: TransportAttempt[];
-  error: {
-    message: string;
-    ts?: string;
-    context?: Record<string, unknown>;
-  };
-}
-
-export function transportDeadLetterPath(workspacePath: string, id: string): string {
-  return path.join(workspacePath, TRANSPORT_ROOT, DEAD_LETTER_DIRECTORY, `${id}.md`);
-}
-
-export function listTransportDeadLetters(workspacePath: string): TransportDeadLetterRecord[] {
-  const directory = path.join(workspacePath, TRANSPORT_ROOT, DEAD_LETTER_DIRECTORY);
-  return listTransportRecordFiles(directory)
-    .map((filePath) => readTransportRecord(filePath, normalizeTransportDeadLetterRecord))
-    .filter((record): record is TransportDeadLetterRecord => record !== null);
-}
-
-export function readTransportDeadLetter(
-  workspacePath: string,
-  id: string,
-): TransportDeadLetterRecord | null {
-  return readTransportRecord(transportDeadLetterPath(workspacePath, id), normalizeTransportDeadLetterRecord);
-}
-
-export function recordTransportDeadLetter(
-  workspacePath: string,
-  input: RecordTransportDeadLetterInput,
-): TransportDeadLetterRecord {
-  const now = new Date().toISOString();
-  const record: TransportDeadLetterRecord = {
-    id: `dlq_${input.sourceRecordId}`,
-    sourceRecordType: input.sourceRecordType,
-    sourceRecordId: input.sourceRecordId,
-    status: 'failed',
-    envelope: normalizeTransportEnvelope(input.envelope),
-    attempts: input.attempts,
-    error: {
-      message: input.error.message,
-      ts: input.error.ts ?? now,
-      ...(input.error.context ? { context: input.error.context } : {}),
-    },
-    createdAt: now,
-    updatedAt: now,
-  };
-  writeTransportDeadLetter(workspacePath, record);
-  return record;
-}
-
-export function markTransportDeadLetterReplayed(
-  workspacePath: string,
-  id: string,
-): TransportDeadLetterRecord | null {
-  const existing = readTransportDeadLetter(workspacePath, id);
-  if (!existing) return null;
-  const updated: TransportDeadLetterRecord = {
-    ...existing,
-    status: 'replayed',
-    replayedAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-  };
-  writeTransportDeadLetter(workspacePath, updated);
-  return updated;
-}
-
-function writeTransportDeadLetter(workspacePath: string, record: TransportDeadLetterRecord): void {
-  writeTransportRecord(
-    transportDeadLetterPath(workspacePath, record.id),
-    {
-      id: record.id,
-      source_record_type: record.sourceRecordType,
-      source_record_id: record.sourceRecordId,
-      status: record.status,
-      envelope: record.envelope,
-      attempts: record.attempts,
-      error: record.error,
-      replayed_at: record.replayedAt,
-      created_at: record.createdAt,
-      updated_at: record.updatedAt,
-    },
-    [
-      renderJsonSection('Envelope', record.envelope),
-      renderJsonSection('Attempts', record.attempts),
-      renderJsonSection('Error', record.error),
-    ].join('\n'),
-  );
-}
-
-function normalizeTransportDeadLetterRecord(frontmatter: Record<string, unknown>): TransportDeadLetterRecord {
-  const error = asRecord(frontmatter.error);
-  return {
-    id: normalizeString(frontmatter.id) ?? 'unknown',
-    sourceRecordType: normalizeString(frontmatter.source_record_type) === 'inbox' ? 'inbox' : 'outbox',
-    sourceRecordId: normalizeString(frontmatter.source_record_id) ?? 'unknown',
-    status: normalizeString(frontmatter.status) === 'replayed' ? 'replayed' : 'failed',
-    envelope: normalizeTransportEnvelope(frontmatter.envelope),
-    attempts: normalizeAttemptArray(frontmatter.attempts),
-    error: {
-      message: normalizeString(error.message) ?? 'Unknown delivery error.',
-      ts: normalizeTimestamp(error.ts),
-      ...(asRecord(error.context) && Object.keys(asRecord(error.context)).length > 0
-        ? { context: asRecord(error.context) }
-        : {}),
-    },
-    replayedAt: normalizeString(frontmatter.replayed_at),
-    createdAt: normalizeTimestamp(frontmatter.created_at),
-    updatedAt: normalizeTimestamp(frontmatter.updated_at),
-  };
-}
diff --git a/packages/kernel/src/transport/envelope.ts b/packages/kernel/src/transport/envelope.ts
deleted file mode 100644
index d9c87f1..0000000
--- a/packages/kernel/src/transport/envelope.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import {
-  asRecord,
-  normalizeString,
-  normalizeStringArray,
-  normalizeTimestamp,
-} from './_shared.js';
-
-export type TransportDirection = 'outbound' | 'inbound';
-
-export interface TransportEnvelope {
-  id: string;
-  direction: TransportDirection;
-  channel: string;
-  topic: string;
-  source: string;
-  target: string;
-  provider?: string;
-  correlationId?: string;
-  causationId?: string;
-  dedupKeys: string[];
-  payloadDigest: string;
-  createdAt: string;
-  payload: Record<string, unknown>;
-}
-
-export interface CreateTransportEnvelopeInput {
-  direction: TransportDirection;
-  channel: string;
-  topic: string;
-  source: string;
-  target: string;
-  provider?: string;
-  correlationId?: string;
-  causationId?: string;
-  dedupKeys?: string[];
-  payload?: Record<string, unknown>;
-  createdAt?: string;
-}
-
-export function createTransportEnvelope(input: CreateTransportEnvelopeInput): TransportEnvelope {
-  const payload = asRecord(input.payload);
-  return {
-    id: `trn_${randomUUID()}`,
-    direction: input.direction,
-    channel: normalizeRequiredString(input.channel, 'Transport channel is required.'),
-    topic: normalizeRequiredString(input.topic, 'Transport topic is required.'),
-    source: normalizeRequiredString(input.source, 'Transport source is required.'),
-    target: normalizeRequiredString(input.target, 'Transport target is required.'),
-    ...(normalizeString(input.provider) ? { provider: normalizeString(input.provider) } : {}),
-    ...(normalizeString(input.correlationId) ? { correlationId: normalizeString(input.correlationId) } : {}),
-    ...(normalizeString(input.causationId) ? { causationId: normalizeString(input.causationId) } : {}),
-    dedupKeys: normalizeStringArray(input.dedupKeys ?? []),
-    payloadDigest: createTransportPayloadDigest(payload),
-    createdAt: normalizeTimestamp(input.createdAt),
-    payload,
-  };
-}
-
-export function normalizeTransportEnvelope(value: unknown): TransportEnvelope {
-  const record = asRecord(value);
-  const payload = asRecord(record.payload);
-  return {
-    id: normalizeRequiredString(record.id, 'Transport envelope id is required.'),
-    direction: normalizeTransportDirection(record.direction),
-    channel: normalizeRequiredString(record.channel, 'Transport envelope channel is required.'),
-    topic: normalizeRequiredString(record.topic, 'Transport envelope topic is required.'),
-    source: normalizeRequiredString(record.source, 'Transport envelope source is required.'),
-    target: normalizeRequiredString(record.target, 'Transport envelope target is required.'),
-    ...(normalizeString(record.provider) ? { provider: normalizeString(record.provider) } : {}),
-    ...(normalizeString(record.correlationId) ? { correlationId: normalizeString(record.correlationId) } : {}),
-    ...(normalizeString(record.causationId) ? { causationId: normalizeString(record.causationId) } : {}),
-    dedupKeys: normalizeStringArray(record.dedupKeys),
-    payloadDigest: normalizeRequiredString(record.payloadDigest, 'Transport envelope payload digest is required.'),
-    createdAt: normalizeTimestamp(record.createdAt),
-    payload,
-  };
-}
-
-export function createTransportPayloadDigest(payload: Record<string, unknown>): string {
-  return createHash('sha256').update(stableStringify(payload)).digest('hex');
-}
-
-function normalizeRequiredString(value: unknown, message: string): string {
-  const normalized = normalizeString(value);
-  if (!normalized) throw new Error(message);
-  return normalized;
-}
-
-function normalizeTransportDirection(value: unknown): TransportDirection {
-  const normalized = normalizeString(value)?.toLowerCase();
-  if (normalized === 'outbound' || normalized === 'inbound') return normalized;
-  throw new Error(`Invalid transport direction "${String(value)}". Expected outbound|inbound.`);
-}
-
-function stableStringify(value: unknown): string {
-  if (value === null || typeof value !== 'object') {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
-  }
-  const record = value as Record<string, unknown>;
-  const keys = Object.keys(record).sort((left, right) => left.localeCompare(right));
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(',')}}`;
-}
diff --git a/packages/kernel/src/transport/inbox.ts b/packages/kernel/src/transport/inbox.ts
deleted file mode 100644
index c9f620f..0000000
--- a/packages/kernel/src/transport/inbox.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import path from 'node:path';
-import {
-  TRANSPORT_ROOT,
-  listTransportRecordFiles,
-  normalizeAttemptArray,
-  normalizeString,
-  normalizeStringArray,
-  normalizeTimestamp,
-  readTransportRecord,
-  renderJsonSection,
-  writeTransportRecord,
-  type TransportAttempt,
-} from './_shared.js';
-import { normalizeTransportEnvelope, type TransportEnvelope } from './envelope.js';
-
-const INBOX_DIRECTORY = 'inbox';
-
-export interface TransportInboxRecord {
-  id: string;
-  envelope: TransportEnvelope;
-  status: 'pending' | 'delivered' | 'failed' | 'replayed';
-  dedupKeys: string[];
-  attempts: TransportAttempt[];
-  duplicateOf?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface RecordTransportInboxInput {
-  envelope: TransportEnvelope;
-  dedupKeys?: string[];
-  message?: string;
-}
-
-export interface RecordTransportInboxResult {
-  record: TransportInboxRecord;
-  duplicate: boolean;
-}
-
-export function transportInboxPath(workspacePath: string, id: string): string {
-  return path.join(workspacePath, TRANSPORT_ROOT, INBOX_DIRECTORY, `${id}.md`);
-}
-
-export function listTransportInbox(workspacePath: string): TransportInboxRecord[] {
-  const directory = path.join(workspacePath, TRANSPORT_ROOT, INBOX_DIRECTORY);
-  return listTransportRecordFiles(directory)
-    .map((filePath) => readTransportRecord(filePath, normalizeTransportInboxRecord))
-    .filter((record): record is TransportInboxRecord => record !== null);
-}
-
-export function readTransportInboxRecord(
-  workspacePath: string,
-  id: string,
-): TransportInboxRecord | null {
-  return readTransportRecord(transportInboxPath(workspacePath, id), normalizeTransportInboxRecord);
-}
-
-export function findTransportInboxDuplicate(
-  workspacePath: string,
-  dedupKeys: string[],
-): TransportInboxRecord | null {
-  if (dedupKeys.length === 0) return null;
-  const desired = new Set(normalizeStringArray(dedupKeys));
-  for (const record of listTransportInbox(workspacePath)) {
-    const existing = new Set(record.dedupKeys);
-    for (const key of desired) {
-      if (existing.has(key)) return record;
-    }
-  }
-  return null;
-}
-
-export function recordTransportInbox(
-  workspacePath: string,
-  input: RecordTransportInboxInput,
-): RecordTransportInboxResult {
-  const dedupKeys = normalizeStringArray(input.dedupKeys ?? input.envelope.dedupKeys);
-  const duplicate = findTransportInboxDuplicate(workspacePath, dedupKeys);
-  if (duplicate) {
-    return {
-      record: duplicate,
-      duplicate: true,
-    };
-  }
-  const now = new Date().toISOString();
-  const record: TransportInboxRecord = {
-    id: `in_${input.envelope.id}`,
-    envelope: normalizeTransportEnvelope(input.envelope),
-    status: 'delivered',
-    dedupKeys,
-    attempts: [
-      {
-        ts: now,
-        status: 'delivered',
-        ...(normalizeString(input.message) ? { message: normalizeString(input.message) } : {}),
-      },
-    ],
-    createdAt: now,
-    updatedAt: now,
-  };
-  writeTransportInboxRecord(workspacePath, record);
-  return {
-    record,
-    duplicate: false,
-  };
-}
-
-function writeTransportInboxRecord(workspacePath: string, record: TransportInboxRecord): void {
-  writeTransportRecord(
-    transportInboxPath(workspacePath, record.id),
-    {
-      id: record.id,
-      envelope: record.envelope,
-      status: record.status,
-      dedup_keys: record.dedupKeys,
-      attempts: record.attempts,
-      duplicate_of: record.duplicateOf,
-      created_at: record.createdAt,
-      updated_at: record.updatedAt,
-    },
-    [
-      renderJsonSection('Envelope', record.envelope),
-      renderJsonSection('Attempts', record.attempts),
-    ].join('\n'),
-  );
-}
-
-function normalizeTransportInboxRecord(frontmatter: Record<string, unknown>): TransportInboxRecord {
-  return {
-    id: normalizeString(frontmatter.id) ?? 'unknown',
-    envelope: normalizeTransportEnvelope(frontmatter.envelope),
-    status: normalizeString(frontmatter.status) === 'failed'
-      ? 'failed'
-      : normalizeString(frontmatter.status) === 'replayed'
-        ? 'replayed'
-        : normalizeString(frontmatter.status) === 'pending'
-          ? 'pending'
-          : 'delivered',
-    dedupKeys: normalizeStringArray(frontmatter.dedup_keys),
-    attempts: normalizeAttemptArray(frontmatter.attempts),
-    duplicateOf: normalizeString(frontmatter.duplicate_of),
-    createdAt: normalizeTimestamp(frontmatter.created_at),
-    updatedAt: normalizeTimestamp(frontmatter.updated_at),
-  };
-}
diff --git a/packages/kernel/src/transport/index.ts b/packages/kernel/src/transport/index.ts
deleted file mode 100644
index 18cb5a2..0000000
--- a/packages/kernel/src/transport/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './envelope.js';
-export * from './outbox.js';
-export * from './inbox.js';
-export * from './dead-letter.js';
diff --git a/packages/kernel/src/transport/outbox.ts b/packages/kernel/src/transport/outbox.ts
deleted file mode 100644
index d556e36..0000000
--- a/packages/kernel/src/transport/outbox.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-import path from 'node:path';
-import {
-  TRANSPORT_ROOT,
-  listTransportRecordFiles,
-  normalizeAttemptArray,
-  normalizeAttemptStatus,
-  normalizeString,
-  normalizeTimestamp,
-  readTransportRecord,
-  renderJsonSection,
-  writeTransportRecord,
-  type TransportAttempt,
-} from './_shared.js';
-import { normalizeTransportEnvelope, type TransportEnvelope } from './envelope.js';
-import { recordTransportDeadLetter } from './dead-letter.js';
-
-const OUTBOX_DIRECTORY = 'outbox';
-
-export interface TransportOutboxRecord {
-  id: string;
-  envelope: TransportEnvelope;
-  deliveryHandler: string;
-  deliveryTarget: string;
-  status: 'pending' | 'delivered' | 'failed' | 'replayed';
-  attempts: TransportAttempt[];
-  deliveredAt?: string;
-  lastError?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface CreateTransportOutboxRecordInput {
-  envelope: TransportEnvelope;
-  deliveryHandler: string;
-  deliveryTarget: string;
-  message?: string;
-}
-
-export function transportOutboxPath(workspacePath: string, id: string): string {
-  return path.join(workspacePath, TRANSPORT_ROOT, OUTBOX_DIRECTORY, `${id}.md`);
-}
-
-export function listTransportOutbox(workspacePath: string): TransportOutboxRecord[] {
-  const directory = path.join(workspacePath, TRANSPORT_ROOT, OUTBOX_DIRECTORY);
-  return listTransportRecordFiles(directory)
-    .map((filePath) => readTransportRecord(filePath, normalizeTransportOutboxRecord))
-    .filter((record): record is TransportOutboxRecord => record !== null);
-}
-
-export function readTransportOutboxRecord(
-  workspacePath: string,
-  id: string,
-): TransportOutboxRecord | null {
-  return readTransportRecord(transportOutboxPath(workspacePath, id), normalizeTransportOutboxRecord);
-}
-
-export function createTransportOutboxRecord(
-  workspacePath: string,
-  input: CreateTransportOutboxRecordInput,
-): TransportOutboxRecord {
-  const now = new Date().toISOString();
-  const record: TransportOutboxRecord = {
-    id: `out_${input.envelope.id}`,
-    envelope: normalizeTransportEnvelope(input.envelope),
-    deliveryHandler: normalizeRequiredString(input.deliveryHandler, 'Transport outbox delivery handler is required.'),
-    deliveryTarget: normalizeRequiredString(input.deliveryTarget, 'Transport outbox delivery target is required.'),
-    status: 'pending',
-    attempts: [
-      {
-        ts: now,
-        status: 'pending',
-        ...(normalizeString(input.message) ? { message: normalizeString(input.message) } : {}),
-      },
-    ],
-    createdAt: now,
-    updatedAt: now,
-  };
-  writeTransportOutboxRecord(workspacePath, record);
-  return record;
-}
-
-export function markTransportOutboxDelivered(
-  workspacePath: string,
-  id: string,
-  message?: string,
-): TransportOutboxRecord | null {
-  const existing = readTransportOutboxRecord(workspacePath, id);
-  if (!existing) return null;
-  const now = new Date().toISOString();
-  const updated: TransportOutboxRecord = {
-    ...existing,
-    status: existing.status === 'replayed' ? 'replayed' : 'delivered',
-    deliveredAt: now,
-    updatedAt: now,
-    attempts: [
-      ...existing.attempts,
-      {
-        ts: now,
-        status: 'delivered',
-        ...(normalizeString(message) ? { message: normalizeString(message) } : {}),
-      },
-    ],
-    lastError: undefined,
-  };
-  writeTransportOutboxRecord(workspacePath, updated);
-  return updated;
-}
-
-export function markTransportOutboxFailed(
-  workspacePath: string,
-  id: string,
-  error: { message: string; context?: Record<string, unknown> },
-): TransportOutboxRecord | null {
-  const existing = readTransportOutboxRecord(workspacePath, id);
-  if (!existing) return null;
-  const now = new Date().toISOString();
-  const updated: TransportOutboxRecord = {
-    ...existing,
-    status: 'failed',
-    updatedAt: now,
-    attempts: [
-      ...existing.attempts,
-      {
-        ts: now,
-        status: 'failed',
-        error: error.message,
-      },
-    ],
-    lastError: error.message,
-  };
-  writeTransportOutboxRecord(workspacePath, updated);
-  recordTransportDeadLetter(workspacePath, {
-    sourceRecordType: 'outbox',
-    sourceRecordId: updated.id,
-    envelope: updated.envelope,
-    attempts: updated.attempts,
-    error: {
-      message: error.message,
-      ts: now,
-      context: error.context,
-    },
-  });
-  return updated;
-}
-
-export async function replayTransportOutboxRecord(
-  workspacePath: string,
-  id: string,
-  deliver: (record: TransportOutboxRecord) => Promise<void> | void,
-): Promise<TransportOutboxRecord | null> {
-  const existing = readTransportOutboxRecord(workspacePath, id);
-  if (!existing) return null;
-  const replayStart = new Date().toISOString();
-  const replaying: TransportOutboxRecord = {
-    ...existing,
-    status: 'replayed',
-    updatedAt: replayStart,
-    attempts: [
-      ...existing.attempts,
-      {
-        ts: replayStart,
-        status: 'replayed',
-        message: 'Replay requested.',
-      },
-    ],
-  };
-  writeTransportOutboxRecord(workspacePath, replaying);
-  try {
-    await deliver(replaying);
-    return markTransportOutboxDelivered(workspacePath, id, 'Replay delivered successfully.');
-  } catch (error) {
-    return markTransportOutboxFailed(workspacePath, id, {
-      message: error instanceof Error ? error.message : String(error),
-      context: {
-        replay: true,
-      },
-    });
-  }
-}
-
-function writeTransportOutboxRecord(workspacePath: string, record: TransportOutboxRecord): void {
-  writeTransportRecord(
-    transportOutboxPath(workspacePath, record.id),
-    {
-      id: record.id,
-      envelope: record.envelope,
-      delivery_handler: record.deliveryHandler,
-      delivery_target: record.deliveryTarget,
-      status: record.status,
-      attempts: record.attempts,
-      delivered_at: record.deliveredAt,
-      last_error: record.lastError,
-      created_at: record.createdAt,
-      updated_at: record.updatedAt,
-    },
-    [
-      renderJsonSection('Envelope', record.envelope),
-      renderJsonSection('Attempts', record.attempts),
-    ].join('\n'),
-  );
-}
-
-function normalizeTransportOutboxRecord(frontmatter: Record<string, unknown>): TransportOutboxRecord {
-  return {
-    id: normalizeString(frontmatter.id) ?? 'unknown',
-    envelope: normalizeTransportEnvelope(frontmatter.envelope),
-    deliveryHandler: normalizeString(frontmatter.delivery_handler) ?? 'unknown',
-    deliveryTarget: normalizeString(frontmatter.delivery_target) ?? 'unknown',
-    status: normalizeAttemptStatus(frontmatter.status) ?? 'pending',
-    attempts: normalizeAttemptArray(frontmatter.attempts),
-    deliveredAt: normalizeString(frontmatter.delivered_at),
-    lastError: normalizeString(frontmatter.last_error),
-    createdAt: normalizeTimestamp(frontmatter.created_at),
-    updatedAt: normalizeTimestamp(frontmatter.updated_at),
-  };
-}
-
-function normalizeRequiredString(value: unknown, message: string): string {
-  const normalized = normalizeString(value);
-  if (!normalized) throw new Error(message);
-  return normalized;
-}
diff --git a/packages/kernel/src/transport/transport.test.ts b/packages/kernel/src/transport/transport.test.ts
deleted file mode 100644
index d2086ec..0000000
--- a/packages/kernel/src/transport/transport.test.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  createTransportEnvelope,
-} from './envelope.js';
-import {
-  createTransportOutboxRecord,
-  listTransportOutbox,
-  markTransportOutboxDelivered,
-  markTransportOutboxFailed,
-  replayTransportOutboxRecord,
-} from './outbox.js';
-import {
-  listTransportDeadLetters,
-} from './dead-letter.js';
-import {
-  recordTransportInbox,
-} from './inbox.js';
-
-let workspacePath: string;
-
-describe('transport records', () => {
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-transport-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-  });
-
-  it('persists outbox delivery state and dead-letter failures', async () => {
-    const envelope = createTransportEnvelope({
-      direction: 'outbound',
-      channel: 'dashboard-webhook',
-      topic: 'thread.done',
-      source: 'control-api.server-events',
-      target: 'https://hooks.example/done',
-      dedupKeys: ['event-1'],
-      payload: {
-        id: 'event-1',
-      },
-    });
-    const outbox = createTransportOutboxRecord(workspacePath, {
-      envelope,
-      deliveryHandler: 'dashboard-webhook',
-      deliveryTarget: 'https://hooks.example/done',
-    });
-
-    const delivered = markTransportOutboxDelivered(workspacePath, outbox.id, 'Delivered successfully.');
-    expect(delivered?.status).toBe('delivered');
-    expect(listTransportOutbox(workspacePath)[0]?.status).toBe('delivered');
-
-    const failedEnvelope = createTransportEnvelope({
-      direction: 'outbound',
-      channel: 'runtime-bridge',
-      topic: 'cursor.automation.run.completed',
-      source: 'cursor-bridge',
-      target: 'https://runtime.example/runs',
-      dedupKeys: ['runtime-event-1'],
-      payload: {
-        id: 'runtime-event-1',
-      },
-    });
-    const failedOutbox = createTransportOutboxRecord(workspacePath, {
-      envelope: failedEnvelope,
-      deliveryHandler: 'runtime-bridge',
-      deliveryTarget: 'https://runtime.example/runs',
-    });
-    const failed = markTransportOutboxFailed(workspacePath, failedOutbox.id, {
-      message: 'Runtime bridge offline',
-      context: {
-        attempt: 1,
-      },
-    });
-    expect(failed?.status).toBe('failed');
-
-    const deadLetters = listTransportDeadLetters(workspacePath);
-    expect(deadLetters).toHaveLength(1);
-    expect(deadLetters[0].sourceRecordId).toBe(failedOutbox.id);
-    expect(deadLetters[0].error.message).toContain('Runtime bridge offline');
-
-    const replayed = await replayTransportOutboxRecord(workspacePath, failedOutbox.id, async () => {});
-    expect(replayed?.status).toBe('replayed');
-  });
-
-  it('persists inbound inbox records with durable deduplication', () => {
-    const envelope = createTransportEnvelope({
-      direction: 'inbound',
-      channel: 'webhook-gateway',
-      topic: 'webhook.github.pull_request',
-      source: 'webhook-gateway:github-main',
-      target: '.workgraph/webhook-gateway',
-      dedupKeys: ['github-main:delivery:123', 'github-main:payload:abc'],
-      payload: {
-        deliveryId: '123',
-      },
-    });
-
-    const first = recordTransportInbox(workspacePath, {
-      envelope,
-      dedupKeys: ['github-main:delivery:123', 'github-main:payload:abc'],
-      message: 'Accepted inbound webhook event.',
-    });
-    expect(first.duplicate).toBe(false);
-
-    const second = recordTransportInbox(workspacePath, {
-      envelope,
-      dedupKeys: ['github-main:delivery:123', 'github-main:payload:abc'],
-      message: 'Accepted inbound webhook event.',
-    });
-    expect(second.duplicate).toBe(true);
-    expect(second.record.id).toBe(first.record.id);
-  });
-});
diff --git a/packages/kernel/src/trigger-engine.test.ts b/packages/kernel/src/trigger-engine.test.ts
deleted file mode 100644
index 7785f56..0000000
--- a/packages/kernel/src/trigger-engine.test.ts
+++ /dev/null
@@ -1,680 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { spawn } from 'node:child_process';
-import * as registry from './registry.js';
-import * as ledger from './ledger.js';
-import * as safety from './safety.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import * as transport from './transport/index.js';
-import * as triggerEngine from './trigger-engine.js';
-
-let workspacePath: string;
-
-interface WebhookTestServer {
-  url: string;
-  stop: () => Promise<void>;
-}
-
-type WebhookServerProcess = ReturnType<typeof spawn>;
-
-async function startWebhookTestServer(mode: 'success' | 'failure'): Promise<WebhookTestServer> {
-  const serverScript = `
-const http = require('node:http');
-const mode = process.env.WG_WEBHOOK_TEST_MODE;
-const server = http.createServer((request, response) => {
-  if (mode === 'failure') {
-    response.statusCode = 503;
-    response.end('service unavailable');
-    return;
-  }
-
-  const chunks = [];
-  request.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-  request.on('end', () => {
-    response.statusCode = 202;
-    response.setHeader('content-type', 'application/json');
-    response.end(JSON.stringify({
-      method: request.method,
-      headers: request.headers,
-      body: Buffer.concat(chunks).toString('utf-8'),
-    }));
-  });
-});
-
-server.listen(0, '127.0.0.1', () => {
-  const address = server.address();
-  if (!address || typeof address === 'string') {
-    process.stderr.write('failed to bind webhook test server');
-    process.exit(1);
-    return;
-  }
-  process.stdout.write(String(address.port) + '\\n');
-});
-`;
-  const child = spawn(process.execPath, ['-e', serverScript], {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: {
-      ...process.env,
-      WG_WEBHOOK_TEST_MODE: mode,
-    },
-  });
-  const port = await waitForWebhookServerPort(child, mode);
-  return {
-    url: `http://127.0.0.1:${port}/agent-ingest`,
-    stop: async () => stopWebhookServer(child),
-  };
-}
-
-function waitForWebhookServerPort(
-  child: WebhookServerProcess,
-  mode: 'success' | 'failure',
-): Promise<number> {
-  return new Promise<number>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error(`Timed out waiting for ${mode} webhook test server startup.`));
-    }, 5_000);
-    let stdout = '';
-    let stderr = '';
-    const stdoutStream = child.stdout;
-    const stderrStream = child.stderr;
-    if (!stdoutStream || !stderrStream) {
-      clearTimeout(timeout);
-      reject(new Error(`Webhook test server missing stdio streams for ${mode} mode.`));
-      return;
-    }
-
-    const onData = (chunk: Buffer | string) => {
-      stdout += chunk.toString();
-      const firstLine = stdout.split('\n')[0]?.trim() ?? '';
-      const parsed = Number(firstLine);
-      if (!Number.isFinite(parsed) || parsed <= 0) return;
-      clearTimeout(timeout);
-      stdoutStream.off('data', onData);
-      stderrStream.off('data', onError);
-      resolve(parsed);
-    };
-    const onError = (chunk: Buffer | string) => {
-      stderr += chunk.toString();
-    };
-
-    child.once('exit', (code) => {
-      clearTimeout(timeout);
-      reject(new Error(`Webhook test server exited early with code ${code ?? 'unknown'}: ${stderr}`));
-    });
-    stdoutStream.on('data', onData);
-    stderrStream.on('data', onError);
-  });
-}
-
-function stopWebhookServer(child: WebhookServerProcess): Promise<void> {
-  return new Promise<void>((resolve) => {
-    if (child.exitCode !== null || child.killed) {
-      resolve();
-      return;
-    }
-    const timeout = setTimeout(() => {
-      if (child.exitCode === null && !child.killed) {
-        child.kill('SIGKILL');
-      }
-    }, 1_000);
-    child.once('exit', () => {
-      clearTimeout(timeout);
-      resolve();
-    });
-    child.kill('SIGTERM');
-  });
-}
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-trigger-engine-'));
-  registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('trigger engine', () => {
-  it.skip('executes update-primitive and shell trigger actions (flaky in CI)', () => {
-    const targetFact = store.create(workspacePath, 'fact', {
-      title: 'Target fact',
-      subject: 'system',
-      predicate: 'state',
-      object: 'initial',
-      tags: ['ops'],
-    }, '# Fact\n', 'agent-fact', { pathOverride: 'facts/target-fact.md' });
-
-    store.create(workspacePath, 'trigger', {
-      title: 'Update target fact when facts change',
-      status: 'active',
-      condition: { type: 'file-watch', glob: 'facts/**/*.md' },
-      action: {
-        type: 'update-primitive',
-        path: targetFact.path,
-        fields: { object: 'updated-by-trigger' },
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    store.create(workspacePath, 'trigger', {
-      title: 'Emit shell marker when facts change',
-      status: 'active',
-      condition: { type: 'file-watch', glob: 'facts/**/*.md' },
-      action: {
-        type: 'shell',
-        command: 'echo shell-fired > .workgraph/shell-trigger.txt',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const initCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(initCycle.fired).toBe(0);
-
-    store.create(workspacePath, 'fact', {
-      title: 'Changed fact',
-      subject: 'system',
-      predicate: 'state',
-      object: 'changed',
-      tags: ['ops'],
-    }, '# Fact\n', 'agent-fact', { pathOverride: 'facts/changed-fact.md' });
-
-    const fireCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(fireCycle.fired).toBe(2);
-    expect(store.read(workspacePath, targetFact.path)?.fields.object).toBe('updated-by-trigger');
-
-    const shellMarker = path.join(workspacePath, '.workgraph', 'shell-trigger.txt');
-    expect(fs.existsSync(shellMarker)).toBe(true);
-    expect(fs.readFileSync(shellMarker, 'utf-8')).toContain('shell-fired');
-  });
-
-  it('evaluates active triggers, respects cooldown, and persists state', () => {
-    const triggerPrimitive = store.create(workspacePath, 'trigger', {
-      title: 'Follow-up on done threads',
-      status: 'active',
-      condition: { type: 'event', event: 'thread-complete' },
-      action: {
-        type: 'create-thread',
-        title: 'Follow-up {{matched_event_latest_target}}',
-        goal: 'Investigate completed work outputs',
-        tags: ['follow-up'],
-      },
-      cooldown: 120,
-    }, '# Trigger\n', 'system');
-
-    const initCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-    });
-    expect(initCycle.fired).toBe(0);
-
-    const seededThread = thread.createThread(workspacePath, 'Implement parser', 'Ship parser MVP', 'agent-dev');
-    thread.claim(workspacePath, seededThread.path, 'agent-dev');
-    thread.done(workspacePath, seededThread.path, 'agent-dev', 'Parser complete https://github.com/versatly/workgraph/pull/11');
-
-    const fireCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-    });
-    expect(fireCycle.fired).toBe(1);
-    const createdThreads = store.list(workspacePath, 'thread');
-    expect(createdThreads.some((entry) => String(entry.fields.title).startsWith('Follow-up'))).toBe(true);
-
-    const cooldownCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-    });
-    expect(cooldownCycle.fired).toBe(0);
-    const triggerResult = cooldownCycle.triggers.find((entry) => entry.triggerPath === triggerPrimitive.path);
-    expect(triggerResult?.runtimeState).toBe('cooldown');
-
-    const statePath = triggerEngine.triggerStatePath(workspacePath);
-    expect(fs.existsSync(statePath)).toBe(true);
-    const state = triggerEngine.loadTriggerState(workspacePath);
-    expect(state.triggers[triggerPrimitive.path]?.fireCount).toBe(1);
-    expect(state.triggers[triggerPrimitive.path]?.cooldownUntil).toBeDefined();
-  });
-
-  it('records trigger action deliveries in the transport outbox', () => {
-    store.create(workspacePath, 'trigger', {
-      title: 'Transported trigger action',
-      status: 'active',
-      condition: { type: 'event', event: 'thread-complete' },
-      action: {
-        type: 'create-thread',
-        title: 'Transport follow-up {{matched_event_latest_target}}',
-        goal: 'Verify transport outbox trigger delivery',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const seededThread = thread.createThread(workspacePath, 'Transport source', 'Ship transport source', 'agent-dev');
-    thread.claim(workspacePath, seededThread.path, 'agent-dev');
-    thread.done(workspacePath, seededThread.path, 'agent-dev', 'Transport source done https://github.com/versatly/workgraph/pull/88');
-
-    const first = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(first.fired).toBe(0);
-
-    const nextThread = thread.createThread(workspacePath, 'Transport source 2', 'Ship transport source 2', 'agent-dev');
-    thread.claim(workspacePath, nextThread.path, 'agent-dev');
-    thread.done(workspacePath, nextThread.path, 'agent-dev', 'Transport source 2 done https://github.com/versatly/workgraph/pull/89');
-
-    const second = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(second.fired).toBe(1);
-
-    const outbox = transport.listTransportOutbox(workspacePath)
-      .filter((record) => record.deliveryHandler === 'trigger-action');
-    expect(outbox.length).toBeGreaterThanOrEqual(1);
-    expect(outbox[0]?.status).toBe('delivered');
-    expect(outbox[0]?.envelope.topic).toBe('create-thread');
-  });
-
-  it('matches event trigger patterns against ledger events', () => {
-    const patternTrigger = store.create(workspacePath, 'trigger', {
-      title: 'Pattern match done events',
-      type: 'event',
-      enabled: true,
-      status: 'active',
-      condition: { type: 'event', pattern: 'thread.*' },
-      action: {
-        type: 'create-thread',
-        title: 'Pattern follow-up {{matched_event_latest_target}}',
-        goal: 'Validate wildcard pattern matching',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const seed = thread.createThread(workspacePath, 'Pattern source', 'Complete source thread', 'agent-pattern');
-    thread.claim(workspacePath, seed.path, 'agent-pattern');
-    thread.done(workspacePath, seed.path, 'agent-pattern', 'Done https://github.com/versatly/workgraph/pull/33');
-
-    const first = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(first.fired).toBe(0);
-
-    const another = thread.createThread(workspacePath, 'Pattern source 2', 'Second completion', 'agent-pattern');
-    thread.claim(workspacePath, another.path, 'agent-pattern');
-    thread.done(workspacePath, another.path, 'agent-pattern', 'Done https://github.com/versatly/workgraph/pull/34');
-
-    const second = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(second.fired).toBe(1);
-    const triggerResult = second.triggers.find((entry) => entry.triggerPath === patternTrigger.path);
-    expect(triggerResult?.reason).toContain('Matched');
-    expect(store.list(workspacePath, 'thread').some((entry) =>
-      String(entry.fields.title).startsWith('Pattern follow-up'))
-    ).toBe(true);
-  });
-
-  it('does not auto-fire manual triggers during engine cycles', () => {
-    const manualTrigger = store.create(workspacePath, 'trigger', {
-      title: 'Manual only trigger',
-      type: 'manual',
-      enabled: true,
-      status: 'active',
-      condition: { type: 'manual' },
-      action: {
-        type: 'dispatch-run',
-        objective: 'Manual fire required',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const cycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(cycle.fired).toBe(0);
-    const result = cycle.triggers.find((entry) => entry.triggerPath === manualTrigger.path);
-    expect(result?.fired).toBe(false);
-    expect(result?.reason).toContain('Manual trigger condition requires explicit');
-  });
-
-  it('supports composite any/all trigger conditions', () => {
-    store.create(workspacePath, 'trigger', {
-      title: 'Any composite trigger',
-      status: 'active',
-      condition: {
-        type: 'any',
-        conditions: [
-          { type: 'manual' },
-          {
-            type: 'all',
-            conditions: [
-              { type: 'event', pattern: 'thread.*' },
-              { type: 'not', condition: { type: 'manual' } },
-            ],
-          },
-        ],
-      },
-      action: {
-        type: 'create-thread',
-        title: 'Any composite {{matched_event_latest_target}}',
-        goal: 'Created by any composite trigger',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    store.create(workspacePath, 'trigger', {
-      title: 'All composite trigger',
-      status: 'active',
-      condition: {
-        type: 'all',
-        conditions: [
-          { type: 'event', pattern: 'thread.*' },
-          { type: 'not', condition: { type: 'manual' } },
-        ],
-      },
-      action: {
-        type: 'create-thread',
-        title: 'All composite {{matched_event_latest_target}}',
-        goal: 'Created by all composite trigger',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const initCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(initCycle.fired).toBe(0);
-
-    const sourceThread = thread.createThread(workspacePath, 'Composite source', 'Drive composite conditions', 'agent-composite');
-    thread.claim(workspacePath, sourceThread.path, 'agent-composite');
-    thread.done(workspacePath, sourceThread.path, 'agent-composite', 'Composite done https://github.com/versatly/workgraph/pull/44');
-
-    const fireCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(fireCycle.fired).toBe(2);
-    expect(store.list(workspacePath, 'thread').some((entry) =>
-      String(entry.fields.title).startsWith('Any composite'))
-    ).toBe(true);
-    expect(store.list(workspacePath, 'thread').some((entry) =>
-      String(entry.fields.title).startsWith('All composite'))
-    ).toBe(true);
-  });
-
-  it('fires cascade triggers immediately when thread reaches done state', () => {
-    const cascadeTrigger = store.create(workspacePath, 'trigger', {
-      title: 'Cascade on completion',
-      status: 'active',
-      condition: { type: 'thread-complete' },
-      cascade_on: ['thread-complete'],
-      action: {
-        type: 'create-thread',
-        title: 'Cascade from {{completed_thread_path}}',
-        goal: 'Run follow-up thread generated via cascade',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const sourceThread = thread.createThread(workspacePath, 'Source thread', 'Complete source', 'agent-owner');
-    thread.claim(workspacePath, sourceThread.path, 'agent-owner');
-    thread.done(workspacePath, sourceThread.path, 'agent-owner', 'Source complete https://github.com/versatly/workgraph/pull/12');
-
-    const threads = store.list(workspacePath, 'thread');
-    expect(threads).toHaveLength(2);
-    expect(threads.some((entry) => String(entry.fields.title).startsWith('Cascade from'))).toBe(true);
-
-    const state = triggerEngine.loadTriggerState(workspacePath);
-    expect(state.triggers[cascadeTrigger.path]?.fireCount).toBe(1);
-  });
-
-  it('blocks risky trigger actions when safety rails are engaged', () => {
-    safety.pauseSafetyOperations(workspacePath, 'system', 'Pause risky trigger actions');
-    store.create(workspacePath, 'trigger', {
-      title: 'Blocked shell cascade',
-      status: 'active',
-      condition: { type: 'thread-complete' },
-      cascade_on: ['thread-complete'],
-      action: {
-        type: 'shell',
-        command: 'node -e "require(\'node:fs\').writeFileSync(\'.workgraph/shell-trigger.txt\', \'shell-fired\')"',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const sourceThread = thread.createThread(workspacePath, 'Safety source', 'Trip safety rails', 'agent-safety');
-    thread.claim(workspacePath, sourceThread.path, 'agent-safety');
-    thread.done(workspacePath, sourceThread.path, 'agent-safety', 'Safety done https://github.com/versatly/workgraph/pull/55');
-
-    const shellMarker = path.join(workspacePath, '.workgraph', 'shell-trigger.txt');
-    expect(fs.existsSync(shellMarker)).toBe(false);
-
-    const state = triggerEngine.loadTriggerState(workspacePath);
-    const blockedTriggerPath = 'triggers/blocked-shell-cascade.md';
-    expect(state.triggers[blockedTriggerPath]?.fireCount ?? 0).toBe(0);
-    expect(state.triggers[blockedTriggerPath]?.lastError).toContain('Safety rails blocked');
-  });
-
-  it('uses ledger offset cursors so same-timestamp events are not skipped', () => {
-    vi.useFakeTimers();
-    try {
-      const frozenNow = new Date('2026-01-01T00:00:00.000Z');
-      vi.setSystemTime(frozenNow);
-
-      const eventTrigger = store.create(workspacePath, 'trigger', {
-        title: 'Follow-up on every completed thread',
-        status: 'active',
-        condition: { type: 'event', event: 'thread-complete' },
-        action: {
-          type: 'create-thread',
-          title: 'Offset follow-up {{matched_event_latest_target}}',
-          goal: 'Verify event cursor offset handling',
-          tags: ['offset-cursor'],
-        },
-        cooldown: 0,
-      }, '# Trigger\n', 'system');
-
-      const firstThread = thread.createThread(workspacePath, 'Seed completion', 'Initial completion event', 'agent-seed');
-      thread.claim(workspacePath, firstThread.path, 'agent-seed');
-      thread.done(workspacePath, firstThread.path, 'agent-seed', 'Seed completed https://github.com/versatly/workgraph/pull/13');
-
-      const firstCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system', now: frozenNow });
-      expect(firstCycle.fired).toBe(0);
-      const firstState = triggerEngine.loadTriggerState(workspacePath);
-      const firstOffset = firstState.triggers[eventTrigger.path]?.lastEventCursorOffset;
-      expect(typeof firstOffset).toBe('number');
-      expect((firstOffset ?? 0) > 0).toBe(true);
-
-      const secondThread = thread.createThread(workspacePath, 'Same-ts completion', 'Second completion at identical timestamp', 'agent-seed');
-      thread.claim(workspacePath, secondThread.path, 'agent-seed');
-      thread.done(workspacePath, secondThread.path, 'agent-seed', 'Second completed https://github.com/versatly/workgraph/pull/14');
-
-      const secondCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system', now: frozenNow });
-      expect(secondCycle.fired).toBe(1);
-      expect(store.list(workspacePath, 'thread').some((entry) =>
-        String(entry.fields.title).startsWith('Offset follow-up'))
-      ).toBe(true);
-
-      const secondState = triggerEngine.loadTriggerState(workspacePath);
-      const secondOffset = secondState.triggers[eventTrigger.path]?.lastEventCursorOffset;
-      expect((secondOffset ?? 0) > (firstOffset ?? 0)).toBe(true);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('auto-synthesis trigger fires when threshold of new tagged facts is met', () => {
-    const synthesis = triggerEngine.addSynthesisTrigger(workspacePath, {
-      tagPattern: 'research-*',
-      threshold: 2,
-      actor: 'agent-synth',
-    });
-
-    const initCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(initCycle.fired).toBe(0);
-    const initialState = triggerEngine.loadTriggerState(workspacePath);
-    const cursorTs = initialState.triggers[synthesis.trigger.path]?.synthesisCursorTs;
-    expect(cursorTs).toBeDefined();
-    const cursorMs = Date.parse(String(cursorTs));
-
-    const factA = store.create(workspacePath, 'fact', {
-      title: 'Research A',
-      subject: 'db',
-      predicate: 'has',
-      object: 'finding-a',
-      tags: ['research-db'],
-    }, '# Fact A\n', 'agent-fact', { pathOverride: 'facts/research-a.md' });
-    store.update(
-      workspacePath,
-      factA.path,
-      { created: new Date(cursorMs + 1_000).toISOString() },
-      undefined,
-      'agent-fact',
-    );
-
-    const underThresholdCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-      now: new Date(cursorMs + 1_500),
-    });
-    expect(underThresholdCycle.fired).toBe(0);
-
-    const factB = store.create(workspacePath, 'fact', {
-      title: 'Research B',
-      subject: 'db',
-      predicate: 'has',
-      object: 'finding-b',
-      tags: ['research-storage'],
-    }, '# Fact B\n', 'agent-fact', { pathOverride: 'facts/research-b.md' });
-    store.update(
-      workspacePath,
-      factB.path,
-      { created: new Date(cursorMs + 2_000).toISOString() },
-      undefined,
-      'agent-fact',
-    );
-
-    const thresholdCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-      now: new Date(cursorMs + 2_500),
-    });
-    expect(thresholdCycle.fired).toBe(1);
-    expect(store.list(workspacePath, 'thread').some((entry) => String(entry.fields.title).includes('Synthesis needed'))).toBe(true);
-
-    const steadyCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-      now: new Date(cursorMs + 3_500),
-    });
-    expect(steadyCycle.fired).toBe(0);
-    const state = triggerEngine.loadTriggerState(workspacePath);
-    expect(state.triggers[synthesis.trigger.path]?.fireCount).toBe(1);
-  });
-
-  it('builds trigger dashboard with fire counts and next fire', () => {
-    const cronTrigger = store.create(workspacePath, 'trigger', {
-      title: 'Minutely dispatch',
-      status: 'active',
-      condition: { type: 'cron', expression: '* * * * *' },
-      action: { type: 'dispatch-run', objective: 'Cron dispatch objective' },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-
-    const cycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    expect(cycle.fired).toBe(1);
-
-    const dashboard = triggerEngine.triggerDashboard(workspacePath);
-    const item = dashboard.triggers.find((trigger) => trigger.path === cronTrigger.path);
-    expect(item).toBeDefined();
-    expect(item?.fireCount).toBe(1);
-    expect(item?.lastFiredAt).toBeDefined();
-    expect(item?.nextFireAt).toBeDefined();
-    expect(item?.currentState).toBe('ready');
-  });
-
-  it('fires webhook actions with templated payloads and records transport delivery', async () => {
-    const server = await startWebhookTestServer('success');
-    try {
-      const webhookTrigger = store.create(workspacePath, 'trigger', {
-        title: 'Webhook on completed threads',
-        status: 'active',
-        condition: { type: 'event', pattern: 'thread.*' },
-        action: {
-          type: 'webhook',
-          url: server.url,
-          headers: {
-            'x-workgraph-target': '{{matched_event_latest_target}}',
-          },
-          bodyTemplate: {
-            target: '{{matched_event_latest_target}}',
-            op: '{{matched_event_latest_op}}',
-            count: '{{matched_event_count}}',
-          },
-        },
-        cooldown: 0,
-      }, '# Trigger\n', 'system');
-
-      const initCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-      expect(initCycle.fired).toBe(0);
-
-      const sourceThread = thread.createThread(workspacePath, 'Webhook source', 'Drive webhook trigger', 'agent-webhook');
-      thread.claim(workspacePath, sourceThread.path, 'agent-webhook');
-      thread.done(workspacePath, sourceThread.path, 'agent-webhook', 'Webhook done https://github.com/versatly/workgraph/pull/88');
-
-      const fireCycle = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-      expect(fireCycle.fired).toBe(1);
-
-      const runtime = triggerEngine.loadTriggerState(workspacePath).triggers[webhookTrigger.path];
-      const webhookResponse = JSON.parse(String(runtime?.lastResult?.response_body ?? '{}')) as {
-        method?: string;
-        headers?: Record<string, unknown>;
-        body?: string;
-      };
-      expect(webhookResponse.method).toBe('POST');
-      expect(webhookResponse.headers?.['x-workgraph-target']).toBe(sourceThread.path);
-      const payload = JSON.parse(String(webhookResponse.body ?? '{}')) as Record<string, unknown>;
-      expect(payload.target).toBe(sourceThread.path);
-      expect(['update', 'done']).toContain(String(payload.op));
-      expect(Number(payload.count)).toBeGreaterThanOrEqual(1);
-
-      const outbox = transport.listTransportOutbox(workspacePath);
-      const webhookOutbox = outbox.filter((record) => record.deliveryHandler === 'trigger-webhook');
-      expect(webhookOutbox).toHaveLength(1);
-      expect(webhookOutbox[0]?.status).toBe('delivered');
-      expect(webhookOutbox[0]?.deliveryTarget).toBe(server.url);
-
-      const webhookEntries = ledger.readAll(workspacePath).filter((entry) =>
-        entry.target === webhookTrigger.path && entry.data?.action === 'webhook'
-      );
-      const successEntry = webhookEntries.find((entry) => entry.data?.fired === true);
-      expect(successEntry).toBeDefined();
-      expect(successEntry?.data?.status_code).toBe(202);
-    } finally {
-      await server.stop();
-    }
-  });
-
-  it('marks webhook trigger failures as errors without crashing cycle', async () => {
-    const server = await startWebhookTestServer('failure');
-    try {
-      const webhookTrigger = store.create(workspacePath, 'trigger', {
-        title: 'Webhook failing target',
-        status: 'active',
-        condition: { type: 'cron', expression: '* * * * *' },
-        action: {
-          type: 'webhook',
-          url: server.url,
-          bodyTemplate: {
-            ping: 'pong',
-          },
-        },
-        cooldown: 0,
-      }, '# Trigger\n', 'system');
-
-      const cycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-        actor: 'system',
-        now: new Date('2026-03-01T00:00:00.000Z'),
-      });
-      expect(cycle.fired).toBe(0);
-      expect(cycle.errors).toBe(1);
-
-      const triggerResult = cycle.triggers.find((entry) => entry.triggerPath === webhookTrigger.path);
-      expect(triggerResult?.runtimeState).toBe('error');
-      expect(triggerResult?.error).toContain('Webhook request failed');
-
-      const outbox = transport.listTransportOutbox(workspacePath);
-      const webhookOutbox = outbox.filter((record) => record.deliveryHandler === 'trigger-webhook');
-      expect(webhookOutbox).toHaveLength(1);
-      expect(webhookOutbox[0]?.status).toBe('failed');
-
-      const webhookEntries = ledger.readAll(workspacePath).filter((entry) =>
-        entry.target === webhookTrigger.path && entry.data?.action === 'webhook'
-      );
-      const failureEntry = webhookEntries.find((entry) => entry.data?.fired === false);
-      expect(failureEntry).toBeDefined();
-      expect(String(failureEntry?.data?.error ?? '')).toContain('Webhook request failed');
-    } finally {
-      await server.stop();
-    }
-  });
-});
diff --git a/packages/kernel/src/trigger-engine.ts b/packages/kernel/src/trigger-engine.ts
deleted file mode 100644
index 068ba40..0000000
--- a/packages/kernel/src/trigger-engine.ts
+++ /dev/null
@@ -1,2521 +0,0 @@
-/**
- * Trigger polling engine, cascade evaluator, and dashboard/status helpers.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import * as dispatch from './dispatch.js';
-import * as ledger from './ledger.js';
-import * as safety from './safety.js';
-import * as store from './store.js';
-import * as transport from './transport/index.js';
-import { matchesCronSchedule, nextCronMatch, parseCronExpression, type CronSchedule } from './cron.js';
-import type { DispatchRun, PrimitiveInstance } from './types.js';
-
-const TRIGGER_STATE_FILE = '.workgraph/trigger-state.json';
-const TRIGGER_STATE_VERSION = 1;
-const DEFAULT_ENGINE_INTERVAL_SECONDS = 60;
-const DEFAULT_SHELL_TIMEOUT_MS = 30_000;
-const DEFAULT_WEBHOOK_TIMEOUT_MS = 10_000;
-
-type TriggerRuntimeStatus = 'ready' | 'cooldown' | 'inactive' | 'error';
-
-interface TriggerRuntimeState {
-  fireCount: number;
-  lastEvaluatedAt?: string;
-  lastFiredAt?: string;
-  nextFireAt?: string;
-  cooldownUntil?: string;
-  lastError?: string;
-  state?: TriggerRuntimeStatus;
-  lastResult?: Record<string, unknown>;
-  lastEventCursorTs?: string;
-  lastEventCursorHash?: string;
-  lastEventCursorOffset?: number;
-  lastFileScanTs?: string;
-  lastCronBucket?: string;
-  synthesisCursorTs?: string;
-}
-
-interface TriggerStateData {
-  version: number;
-  updatedAt: string;
-  engine: {
-    cycleCount: number;
-    lastCycleAt?: string;
-    intervalSeconds: number;
-    lastError?: string;
-  };
-  triggers: Record<string, TriggerRuntimeState>;
-}
-
-type TriggerCondition =
-  | {
-      type: 'cron';
-      expression: string;
-      schedule: CronSchedule;
-    }
-  | {
-      type: 'event';
-      pattern: string;
-    }
-  | {
-      type: 'file-watch';
-      glob: string;
-    }
-  | {
-      type: 'thread-complete';
-      threadPath?: string;
-    }
-  | {
-      type: 'manual';
-    }
-  | {
-      type: 'all';
-      conditions: TriggerCondition[];
-    }
-  | {
-      type: 'any';
-      conditions: TriggerCondition[];
-    }
-  | {
-      type: 'not';
-      condition: TriggerCondition;
-    };
-
-type TriggerAction =
-  | {
-      type: 'create-thread';
-      title?: string;
-      goal?: string;
-      body?: string;
-      priority?: string;
-      deps?: string[];
-      parent?: string;
-      space?: string;
-      context_refs?: string[];
-      tags?: string[];
-      actor?: string;
-    }
-  | {
-      type: 'dispatch-run';
-      objective?: string;
-      adapter?: string;
-      context?: Record<string, unknown>;
-      actor?: string;
-    }
-  | {
-      type: 'update-primitive';
-      path: string;
-      fields?: Record<string, unknown>;
-      body?: string;
-      actor?: string;
-    }
-  | {
-      type: 'shell';
-      command: string;
-      timeoutMs?: number;
-      actor?: string;
-    }
-  | {
-      type: 'webhook';
-      url: string;
-      method?: string;
-      headers?: Record<string, string>;
-      bodyTemplate?: unknown;
-      timeoutMs?: number;
-      actor?: string;
-    };
-
-interface SynthesisConfig {
-  tagPattern: string;
-  threshold: number;
-  actor?: string;
-}
-
-interface NormalizedTrigger {
-  instance: PrimitiveInstance;
-  path: string;
-  title: string;
-  triggerType: 'cron' | 'webhook' | 'event' | 'manual';
-  enabled: boolean;
-  status: string;
-  cooldownSeconds: number;
-  condition: TriggerCondition | null;
-  action: TriggerAction | null;
-  cascadeOn: string[];
-  synthesis: SynthesisConfig | null;
-}
-
-interface TriggerConditionDecision {
-  matched: boolean;
-  reason: string;
-  eventKey?: string;
-  context?: Record<string, unknown>;
-}
-
-export interface TriggerEngineCycleTriggerResult {
-  triggerPath: string;
-  fired: boolean;
-  reason: string;
-  actionType?: string;
-  nextFireAt?: string;
-  runtimeState: TriggerRuntimeStatus;
-  error?: string;
-}
-
-export interface TriggerEngineCycleResult {
-  cycleAt: string;
-  evaluated: number;
-  fired: number;
-  errors: number;
-  triggers: TriggerEngineCycleTriggerResult[];
-  statePath: string;
-}
-
-export interface TriggerEngineCycleOptions {
-  actor?: string;
-  now?: Date;
-  intervalSeconds?: number;
-  triggerPaths?: string[];
-}
-
-export interface StartTriggerEngineOptions {
-  actor?: string;
-  intervalSeconds?: number;
-  maxCycles?: number;
-  logger?: (line: string) => void;
-  executeRuns?: boolean;
-  execution?: Omit<dispatch.DispatchExecuteInput, 'actor'>;
-  retryFailedRuns?: boolean;
-}
-
-export interface TriggerDashboardItem {
-  path: string;
-  title: string;
-  status: string;
-  condition: string;
-  action: string;
-  cooldownSeconds: number;
-  fireCount: number;
-  lastFiredAt?: string;
-  nextFireAt?: string;
-  currentState: TriggerRuntimeStatus;
-  lastError?: string;
-}
-
-export interface TriggerDashboard {
-  generatedAt: string;
-  statePath: string;
-  engine: TriggerStateData['engine'];
-  triggers: TriggerDashboardItem[];
-}
-
-export interface CascadeEvaluationResult {
-  completedThreadPath: string;
-  evaluated: number;
-  fired: number;
-  errors: number;
-  results: TriggerEngineCycleTriggerResult[];
-}
-
-export interface AddSynthesisTriggerOptions {
-  tagPattern: string;
-  threshold: number;
-  actor: string;
-  cooldownSeconds?: number;
-}
-
-export interface AddSynthesisTriggerResult {
-  trigger: PrimitiveInstance;
-}
-
-export interface TriggerRunExecutionResult {
-  runId: string;
-  triggerPath?: string;
-  status: DispatchRun['status'];
-  retriedFromRunId?: string;
-  error?: string;
-}
-
-export interface TriggerRunEvidenceLoopResult {
-  cycle: TriggerEngineCycleResult;
-  executedRuns: TriggerRunExecutionResult[];
-  succeeded: number;
-  failed: number;
-  cancelled: number;
-  skipped: number;
-}
-
-export interface TriggerRunEvidenceLoopOptions extends TriggerEngineCycleOptions {
-  execution?: Omit<dispatch.DispatchExecuteInput, 'actor'>;
-  retryFailedRuns?: boolean;
-}
-
-export interface TriggerActionReplayInput {
-  triggerPath: string;
-  action: Record<string, unknown>;
-  context: Record<string, unknown>;
-  actor: string;
-  eventKey?: string;
-}
-
-export function triggerStatePath(workspacePath: string): string {
-  return path.join(workspacePath, TRIGGER_STATE_FILE);
-}
-
-export function loadTriggerState(workspacePath: string): TriggerStateData {
-  const filePath = triggerStatePath(workspacePath);
-  if (!fs.existsSync(filePath)) {
-    const seeded = seedTriggerState();
-    saveTriggerState(workspacePath, seeded);
-    return seeded;
-  }
-
-  try {
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const parsed = JSON.parse(raw) as Partial<TriggerStateData>;
-    return {
-      version: parsed.version ?? TRIGGER_STATE_VERSION,
-      updatedAt: parsed.updatedAt ?? new Date(0).toISOString(),
-      engine: {
-        cycleCount: parsed.engine?.cycleCount ?? 0,
-        lastCycleAt: parsed.engine?.lastCycleAt,
-        intervalSeconds: parsed.engine?.intervalSeconds ?? DEFAULT_ENGINE_INTERVAL_SECONDS,
-        lastError: parsed.engine?.lastError,
-      },
-      triggers: parsed.triggers ?? {},
-    };
-  } catch {
-    const seeded = seedTriggerState();
-    saveTriggerState(workspacePath, seeded);
-    return seeded;
-  }
-}
-
-export function saveTriggerState(workspacePath: string, state: TriggerStateData): void {
-  const filePath = triggerStatePath(workspacePath);
-  const directory = path.dirname(filePath);
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
-}
-
-export function runTriggerEngineCycle(
-  workspacePath: string,
-  options: TriggerEngineCycleOptions = {},
-): TriggerEngineCycleResult {
-  const now = options.now ?? new Date();
-  const nowIso = now.toISOString();
-  const actor = options.actor ?? 'system';
-  const intervalSeconds = normalizeInt(options.intervalSeconds, DEFAULT_ENGINE_INTERVAL_SECONDS, 1);
-  const state = loadTriggerState(workspacePath);
-  const allTriggers = listNormalizedTriggers(workspacePath);
-  const triggerPathFilter = normalizeTriggerPathFilter(options.triggerPaths);
-  const triggers = triggerPathFilter
-    ? allTriggers.filter((trigger) => triggerPathFilter.has(trigger.path))
-    : allTriggers;
-  const requiresLedgerRead = triggers.some((trigger) =>
-    isTriggerCycleEvaluable(trigger) && conditionRequiresLedgerRead(trigger.condition)
-  );
-  const ledgerEntries = requiresLedgerRead
-    ? ledger.readAll(workspacePath)
-    : [];
-
-  let fired = 0;
-  let errors = 0;
-  const results: TriggerEngineCycleTriggerResult[] = [];
-
-  for (const trigger of triggers) {
-    const runtime = getOrCreateRuntimeState(state, trigger.path);
-    runtime.lastEvaluatedAt = nowIso;
-    runtime.state = 'ready';
-    runtime.lastError = undefined;
-    runtime.nextFireAt = computeNextFireAt(trigger, runtime, now);
-
-    if (!trigger.enabled) {
-      runtime.state = 'inactive';
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: 'Trigger is disabled.',
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-      });
-      continue;
-    }
-
-    if (!isTriggerStatusActive(trigger.status)) {
-      runtime.state = 'inactive';
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: `Trigger status is "${trigger.status}" (only "active"/"approved" is evaluated).`,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-      });
-      continue;
-    }
-
-    if (!trigger.condition) {
-      runtime.state = 'error';
-      runtime.lastError = 'Trigger condition is missing or invalid.';
-      errors += 1;
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: 'Invalid trigger condition.',
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-        error: runtime.lastError,
-      });
-      continue;
-    }
-    if (!trigger.action) {
-      runtime.state = 'error';
-      runtime.lastError = 'Trigger action is missing or invalid.';
-      errors += 1;
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: 'Invalid trigger action.',
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-        error: runtime.lastError,
-      });
-      continue;
-    }
-
-    const cooldownBlock = evaluateCooldown(runtime, now);
-    if (cooldownBlock.blocked) {
-      runtime.state = 'cooldown';
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: cooldownBlock.reason,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-      });
-      continue;
-    }
-
-    const decision = evaluateTriggerCondition({
-      workspacePath,
-      trigger,
-      runtime,
-      now,
-      ledgerEntries,
-    });
-    if (!decision.matched) {
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: decision.reason,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state ?? 'ready',
-      });
-      continue;
-    }
-
-    try {
-      const actionResult = executeTriggerAction(
-        workspacePath,
-        trigger,
-        trigger.action,
-        decision.context ?? {},
-        actor,
-        decision.eventKey,
-      );
-      fired += 1;
-      runtime.lastFiredAt = nowIso;
-      runtime.fireCount += 1;
-      runtime.lastResult = actionResult;
-      if (trigger.cooldownSeconds > 0) {
-        runtime.cooldownUntil = new Date(now.getTime() + trigger.cooldownSeconds * 1000).toISOString();
-        runtime.state = 'cooldown';
-      } else {
-        runtime.cooldownUntil = undefined;
-        runtime.state = 'ready';
-      }
-      runtime.lastError = undefined;
-      runtime.nextFireAt = computeNextFireAt(trigger, runtime, now);
-      syncTriggerScheduleFields(workspacePath, trigger, runtime, actor);
-      results.push({
-        triggerPath: trigger.path,
-        fired: true,
-        reason: decision.reason,
-        actionType: trigger.action.type,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-      });
-    } catch (error) {
-      runtime.state = 'error';
-      runtime.lastError = errorMessage(error);
-      errors += 1;
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: decision.reason,
-        actionType: trigger.action.type,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-        error: runtime.lastError,
-      });
-    }
-  }
-
-  state.updatedAt = nowIso;
-  state.engine.cycleCount += 1;
-  state.engine.lastCycleAt = nowIso;
-  state.engine.intervalSeconds = intervalSeconds;
-  saveTriggerState(workspacePath, state);
-
-  return {
-    cycleAt: nowIso,
-    evaluated: triggers.length,
-    fired,
-    errors,
-    triggers: results,
-    statePath: TRIGGER_STATE_FILE,
-  };
-}
-
-export async function runTriggerRunEvidenceLoop(
-  workspacePath: string,
-  options: TriggerRunEvidenceLoopOptions = {},
-): Promise<TriggerRunEvidenceLoopResult> {
-  const cycle = runTriggerEngineCycle(workspacePath, options);
-  const actor = options.actor ?? 'system';
-  const triggerState = loadTriggerState(workspacePath);
-  const targetRuns = new Map<string, string>();
-  for (const triggerResult of cycle.triggers) {
-    if (!triggerResult.fired || triggerResult.actionType !== 'dispatch-run') continue;
-    const runtime = triggerState.triggers[triggerResult.triggerPath];
-    const runId = typeof runtime?.lastResult?.run_id === 'string'
-      ? String(runtime.lastResult.run_id)
-      : undefined;
-    if (!runId) continue;
-    targetRuns.set(runId, triggerResult.triggerPath);
-  }
-
-  const executedRuns: TriggerRunExecutionResult[] = [];
-  for (const [runId, triggerPath] of targetRuns) {
-    try {
-      const run = dispatch.status(workspacePath, runId);
-      if ((run.status === 'failed' || run.status === 'cancelled') && options.retryFailedRuns) {
-        const retried = await dispatch.retryRun(workspacePath, run.id, {
-          actor,
-          execute: true,
-          ...(options.execution ?? {}),
-        });
-        executedRuns.push({
-          runId: retried.id,
-          triggerPath,
-          status: retried.status,
-          retriedFromRunId: run.id,
-        });
-        continue;
-      }
-      if (run.status === 'queued' || run.status === 'running') {
-        const executed = await dispatch.executeRun(workspacePath, run.id, {
-          actor,
-          ...(options.execution ?? {}),
-        });
-        executedRuns.push({
-          runId: executed.id,
-          triggerPath,
-          status: executed.status,
-        });
-        continue;
-      }
-      executedRuns.push({
-        runId: run.id,
-        triggerPath,
-        status: run.status,
-      });
-    } catch (error) {
-      executedRuns.push({
-        runId,
-        triggerPath,
-        status: 'failed',
-        error: errorMessage(error),
-      });
-    }
-  }
-
-  return {
-    cycle,
-    executedRuns,
-    succeeded: executedRuns.filter((entry) => entry.status === 'succeeded').length,
-    failed: executedRuns.filter((entry) => entry.status === 'failed').length,
-    cancelled: executedRuns.filter((entry) => entry.status === 'cancelled').length,
-    skipped: executedRuns.filter((entry) =>
-      entry.status !== 'succeeded'
-      && entry.status !== 'failed'
-      && entry.status !== 'cancelled')
-      .length,
-  };
-}
-
-export async function startTriggerEngine(
-  workspacePath: string,
-  options: StartTriggerEngineOptions = {},
-): Promise<void> {
-  const intervalSeconds = normalizeInt(options.intervalSeconds, DEFAULT_ENGINE_INTERVAL_SECONDS, 1);
-  const actor = options.actor ?? 'system';
-  const logger = options.logger ?? ((line: string) => console.log(line));
-
-  logger(`Trigger engine started (interval=${intervalSeconds}s, workspace=${workspacePath}).`);
-
-  let completedCycles = 0;
-  while (options.maxCycles === undefined || completedCycles < options.maxCycles) {
-    const cycleResult = options.executeRuns
-      ? (await runTriggerRunEvidenceLoop(workspacePath, {
-          actor,
-          intervalSeconds,
-          execution: options.execution,
-          retryFailedRuns: options.retryFailedRuns,
-        })).cycle
-      : runTriggerEngineCycle(workspacePath, {
-          actor,
-          intervalSeconds,
-        });
-    logger(
-      `[${cycleResult.cycleAt}] cycle=${completedCycles + 1} evaluated=${cycleResult.evaluated} fired=${cycleResult.fired} errors=${cycleResult.errors}`,
-    );
-    completedCycles += 1;
-    if (options.maxCycles !== undefined && completedCycles >= options.maxCycles) {
-      break;
-    }
-    await sleep(intervalSeconds * 1000);
-  }
-}
-
-export function evaluateThreadCompleteCascadeTriggers(
-  workspacePath: string,
-  completedThreadPath: string,
-  actor: string = 'system',
-  now: Date = new Date(),
-): CascadeEvaluationResult {
-  const state = loadTriggerState(workspacePath);
-  const nowIso = now.toISOString();
-  const thread = store.read(workspacePath, completedThreadPath);
-  const context = {
-    completed_thread_path: completedThreadPath,
-    completed_thread_title: String(thread?.fields.title ?? completedThreadPath),
-    completed_thread_status: String(thread?.fields.status ?? 'done'),
-  };
-
-  const candidates = listNormalizedTriggers(workspacePath)
-    .filter((trigger) => trigger.enabled)
-    .filter((trigger) => isTriggerStatusActive(trigger.status))
-    .filter((trigger) => trigger.condition?.type === 'thread-complete')
-    .filter((trigger) => trigger.cascadeOn.length === 0 || trigger.cascadeOn.includes('thread-complete'));
-
-  let fired = 0;
-  let errors = 0;
-  const results: TriggerEngineCycleTriggerResult[] = [];
-
-  for (const trigger of candidates) {
-    const runtime = getOrCreateRuntimeState(state, trigger.path);
-    runtime.lastEvaluatedAt = nowIso;
-    runtime.state = 'ready';
-    runtime.lastError = undefined;
-    runtime.nextFireAt = computeNextFireAt(trigger, runtime, now);
-
-    if (!trigger.action || !trigger.condition || trigger.condition.type !== 'thread-complete') {
-      runtime.state = 'error';
-      runtime.lastError = 'Trigger missing valid thread-complete condition/action.';
-      errors += 1;
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: 'Invalid thread-complete trigger definition.',
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-        error: runtime.lastError,
-      });
-      continue;
-    }
-
-    if (trigger.condition.threadPath) {
-      const expected = normalizeReferencePath(trigger.condition.threadPath);
-      const actual = normalizeReferencePath(completedThreadPath);
-      if (expected !== actual) {
-        results.push({
-          triggerPath: trigger.path,
-          fired: false,
-          reason: `Completed thread ${actual} does not match cascade target ${expected}.`,
-          nextFireAt: runtime.nextFireAt,
-          runtimeState: runtime.state,
-        });
-        continue;
-      }
-    }
-
-    const cooldownBlock = evaluateCooldown(runtime, now);
-    if (cooldownBlock.blocked) {
-      runtime.state = 'cooldown';
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: cooldownBlock.reason,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-      });
-      continue;
-    }
-
-    try {
-      const actionResult = executeTriggerAction(
-        workspacePath,
-        trigger,
-        trigger.action,
-        context,
-        actor,
-        `thread-complete:${completedThreadPath}:${nowIso}`,
-      );
-      fired += 1;
-      runtime.lastFiredAt = nowIso;
-      runtime.fireCount += 1;
-      runtime.lastResult = actionResult;
-      if (trigger.cooldownSeconds > 0) {
-        runtime.cooldownUntil = new Date(now.getTime() + trigger.cooldownSeconds * 1000).toISOString();
-        runtime.state = 'cooldown';
-      } else {
-        runtime.cooldownUntil = undefined;
-        runtime.state = 'ready';
-      }
-      runtime.nextFireAt = computeNextFireAt(trigger, runtime, now);
-      syncTriggerScheduleFields(workspacePath, trigger, runtime, actor);
-      results.push({
-        triggerPath: trigger.path,
-        fired: true,
-        reason: `Cascade fired for completed thread ${completedThreadPath}.`,
-        actionType: trigger.action.type,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-      });
-    } catch (error) {
-      runtime.state = 'error';
-      runtime.lastError = errorMessage(error);
-      errors += 1;
-      results.push({
-        triggerPath: trigger.path,
-        fired: false,
-        reason: `Cascade action failed for ${completedThreadPath}.`,
-        actionType: trigger.action.type,
-        nextFireAt: runtime.nextFireAt,
-        runtimeState: runtime.state,
-        error: runtime.lastError,
-      });
-    }
-  }
-
-  state.updatedAt = nowIso;
-  saveTriggerState(workspacePath, state);
-
-  return {
-    completedThreadPath,
-    evaluated: candidates.length,
-    fired,
-    errors,
-    results,
-  };
-}
-
-export function triggerDashboard(workspacePath: string, now: Date = new Date()): TriggerDashboard {
-  const state = loadTriggerState(workspacePath);
-  const triggers = listNormalizedTriggers(workspacePath);
-  const nowIso = now.toISOString();
-
-  const items: TriggerDashboardItem[] = triggers.map((trigger) => {
-    const runtime = state.triggers[trigger.path] ?? { fireCount: 0 };
-    const currentState = deriveRuntimeState(trigger, runtime, now);
-    const nextFireAt = computeNextFireAt(trigger, runtime, now);
-    return {
-      path: trigger.path,
-      title: trigger.title,
-      status: trigger.status,
-      condition: describeCondition(trigger),
-      action: describeAction(trigger),
-      cooldownSeconds: trigger.cooldownSeconds,
-      fireCount: runtime.fireCount ?? 0,
-      lastFiredAt: runtime.lastFiredAt,
-      nextFireAt,
-      currentState,
-      lastError: runtime.lastError,
-    };
-  });
-
-  return {
-    generatedAt: nowIso,
-    statePath: TRIGGER_STATE_FILE,
-    engine: state.engine,
-    triggers: items,
-  };
-}
-
-export function addSynthesisTrigger(
-  workspacePath: string,
-  options: AddSynthesisTriggerOptions,
-): AddSynthesisTriggerResult {
-  const threshold = normalizeInt(options.threshold, 1, 1);
-  const cooldownSeconds = normalizeInt(options.cooldownSeconds, 0, 0);
-  const tagPattern = String(options.tagPattern).trim();
-  if (!tagPattern) {
-    throw new Error('Synthesis trigger tag pattern is required.');
-  }
-
-  const trigger = store.create(
-    workspacePath,
-    'trigger',
-    {
-      title: `Auto synthesis (${tagPattern} @ ${threshold})`,
-      event: 'fact.created',
-      status: 'active',
-      condition: {
-        type: 'file-watch',
-        glob: 'facts/**/*.md',
-      },
-      action: {
-        type: 'create-thread',
-        title: `Synthesis needed: ${tagPattern}`,
-        goal: `Synthesize newly created facts matching "${tagPattern}" (threshold=${threshold}).`,
-        tags: ['synthesis', `tag:${tagPattern}`],
-        actor: options.actor,
-      },
-      cooldown: cooldownSeconds,
-      cascade_on: [],
-      synthesis: {
-        tag_pattern: tagPattern,
-        threshold,
-        actor: options.actor,
-      },
-      tags: ['synthesis', 'auto'],
-    },
-    [
-      '## Synthesis Trigger',
-      '',
-      `Automatically creates a synthesis thread when ${threshold} new facts`,
-      `matching tag pattern \`${tagPattern}\` appear since the last fire.`,
-      '',
-    ].join('\n'),
-    'system',
-  );
-
-  return { trigger };
-}
-
-function executeTriggerAction(
-  workspacePath: string,
-  trigger: NormalizedTrigger,
-  action: TriggerAction,
-  context: Record<string, unknown>,
-  defaultActor: string,
-  eventKey: string | undefined,
-): Record<string, unknown> {
-  const actor = action.actor ?? (trigger.synthesis?.actor ?? defaultActor);
-  const envelope = transport.createTransportEnvelope({
-    direction: 'outbound',
-    channel: 'trigger-action',
-    topic: action.type,
-    source: trigger.path,
-    target: action.type,
-    correlationId: eventKey,
-    dedupKeys: [
-      `${trigger.path}:${action.type}:${eventKey ?? 'manual'}`,
-      ...(eventKey ? [`trigger-event:${eventKey}`] : []),
-    ],
-    payload: {
-      triggerPath: trigger.path,
-      action,
-      context,
-      actor,
-      eventKey,
-    },
-  });
-  const outbox = transport.createTransportOutboxRecord(workspacePath, {
-    envelope,
-    deliveryHandler: 'trigger-action',
-    deliveryTarget: trigger.path,
-    message: `Executing trigger action ${action.type} for ${trigger.path}.`,
-  });
-  try {
-    const result = performTriggerAction(workspacePath, trigger, action, context, defaultActor, eventKey);
-    transport.markTransportOutboxDelivered(
-      workspacePath,
-      outbox.id,
-      `Trigger action ${action.type} delivered successfully.`,
-    );
-    return result;
-  } catch (error) {
-    transport.markTransportOutboxFailed(workspacePath, outbox.id, {
-      message: errorMessage(error),
-      context: {
-        triggerPath: trigger.path,
-        actionType: action.type,
-        actor,
-        eventKey,
-      },
-    });
-    throw error;
-  }
-}
-
-function performTriggerAction(
-  workspacePath: string,
-  trigger: NormalizedTrigger,
-  action: TriggerAction,
-  context: Record<string, unknown>,
-  defaultActor: string,
-  eventKey: string | undefined,
-): Record<string, unknown> {
-  const actor = action.actor ?? (trigger.synthesis?.actor ?? defaultActor);
-  switch (action.type) {
-    case 'create-thread': {
-      const thread = createThreadFromTrigger(workspacePath, trigger, action, context, actor);
-      appendTriggerFireLedger(workspacePath, actor, trigger, action.type, eventKey, {
-        thread_path: thread.path,
-      });
-      return {
-        action: action.type,
-        thread_path: thread.path,
-      };
-    }
-    case 'dispatch-run': {
-      const objectiveTemplate = action.objective
-        ?? `Trigger ${trigger.title} fired (${trigger.path})`;
-      const objective = String(materializeTemplateValue(objectiveTemplate, context));
-      const run = dispatch.createRun(workspacePath, {
-        actor,
-        adapter: action.adapter,
-        objective,
-        context: {
-          trigger_path: trigger.path,
-          event_key: eventKey,
-          ...(materializeTemplateValue(action.context ?? {}, context) as Record<string, unknown>),
-        },
-        idempotencyKey: eventKey ? buildDispatchIdempotencyKey(trigger.path, eventKey, objective) : undefined,
-      });
-      appendTriggerFireLedger(workspacePath, actor, trigger, action.type, eventKey, {
-        run_id: run.id,
-      });
-      return {
-        action: action.type,
-        run_id: run.id,
-        run_status: run.status,
-      };
-    }
-    case 'update-primitive': {
-      const updated = runTriggerActionWithSafetyRails(
-        workspacePath,
-        actor,
-        'trigger.action.update-primitive',
-        () => {
-          const targetPath = String(materializeTemplateValue(action.path, context));
-          const fields = materializeTemplateValue(action.fields ?? {}, context) as Record<string, unknown>;
-          const body = action.body === undefined
-            ? undefined
-            : String(materializeTemplateValue(action.body, context));
-          return store.update(workspacePath, targetPath, fields, body, actor);
-        },
-      );
-      appendTriggerFireLedger(workspacePath, actor, trigger, action.type, eventKey, {
-        target_path: updated.path,
-      });
-      return {
-        action: action.type,
-        target_path: updated.path,
-      };
-    }
-    case 'shell': {
-      const command = String(materializeTemplateValue(action.command, context));
-      const shellResult = runTriggerActionWithSafetyRails(
-        workspacePath,
-        actor,
-        'trigger.action.shell',
-        () => {
-          const timeoutMs = normalizeInt(action.timeoutMs, DEFAULT_SHELL_TIMEOUT_MS, 1);
-          const result = spawnSync(command, {
-            shell: true,
-            cwd: workspacePath,
-            encoding: 'utf-8',
-            timeout: timeoutMs,
-          });
-          if (result.error) {
-            throw new Error(`Shell trigger command failed: ${result.error.message}`);
-          }
-          if ((result.status ?? 1) !== 0) {
-            throw new Error(
-              `Shell trigger command exited with ${result.status}: ${command}\n${result.stderr || result.stdout || ''}`,
-            );
-          }
-          return result;
-        },
-      );
-      appendTriggerFireLedger(workspacePath, actor, trigger, action.type, eventKey, {
-        command,
-        exit_code: shellResult.status ?? 0,
-      });
-      return {
-        action: action.type,
-        command,
-        exit_code: shellResult.status ?? 0,
-        stdout: shellResult.stdout?.trim() ?? '',
-      };
-    }
-    case 'webhook': {
-      const url = normalizeWebhookUrl(String(materializeTemplateValue(action.url, context)));
-      const method = normalizeWebhookMethod(
-        String(materializeTemplateValue(action.method ?? 'POST', context) ?? 'POST'),
-      );
-      const timeoutMs = normalizeInt(action.timeoutMs, DEFAULT_WEBHOOK_TIMEOUT_MS, 1);
-      const headers = normalizeWebhookHeaders(
-        materializeTemplateValue(action.headers ?? {}, context),
-      );
-      const body = action.bodyTemplate === undefined
-        ? undefined
-        : materializeTemplateValue(action.bodyTemplate, context);
-      const requestBody = body === undefined ? undefined : JSON.stringify(body);
-      if (requestBody !== undefined && !hasHeader(headers, 'content-type')) {
-        headers['content-type'] = 'application/json';
-      }
-
-      const outboxId = createWebhookOutboxRecord(workspacePath, trigger, {
-        url,
-        method,
-        timeoutMs,
-        headers,
-        body,
-        eventKey,
-      });
-      const response = executeWebhookRequest({
-        url,
-        method,
-        headers,
-        body: requestBody,
-        timeoutMs,
-      });
-
-      if (!response.ok) {
-        const message = response.error
-          ?? `Webhook request failed (${response.status ?? 'unknown'} ${response.statusText ?? ''}).`;
-        if (outboxId) {
-          try {
-            transport.markTransportOutboxFailed(workspacePath, outboxId, {
-              message,
-              context: {
-                trigger_path: trigger.path,
-                event_key: eventKey,
-                status_code: response.status,
-                status_text: response.statusText,
-              },
-            });
-          } catch {
-            // Transport outbox recording is best-effort for trigger actions.
-          }
-        }
-        appendTriggerFailureLedger(workspacePath, actor, trigger, action.type, eventKey, {
-          url,
-          method,
-          status_code: response.status,
-          status_text: response.statusText,
-          error: message,
-          transport_outbox_id: outboxId,
-        });
-        throw new Error(message);
-      }
-
-      if (outboxId) {
-        try {
-          transport.markTransportOutboxDelivered(
-            workspacePath,
-            outboxId,
-            `Webhook delivered with HTTP ${response.status}.`,
-          );
-        } catch {
-          // Transport outbox recording is best-effort for trigger actions.
-        }
-      }
-      appendTriggerFireLedger(workspacePath, actor, trigger, action.type, eventKey, {
-        url,
-        method,
-        status_code: response.status,
-        status_text: response.statusText,
-        transport_outbox_id: outboxId,
-      });
-      return {
-        action: action.type,
-        url,
-        method,
-        status_code: response.status,
-        status_text: response.statusText,
-        response_body: truncateText(response.bodyText, 4_000),
-        transport_outbox_id: outboxId,
-      };
-    }
-    default: {
-      const exhaustive: never = action;
-      throw new Error(`Unsupported trigger action: ${(exhaustive as { type?: string }).type ?? 'unknown'}`);
-    }
-  }
-}
-
-export function replayTriggerActionDelivery(
-  workspacePath: string,
-  input: TriggerActionReplayInput,
-): Record<string, unknown> {
-  const trigger = listNormalizedTriggers(workspacePath).find((candidate) => candidate.path === input.triggerPath);
-  if (!trigger) {
-    throw new Error(`Trigger not found for replay: ${input.triggerPath}`);
-  }
-  const action = parseTriggerAction(input.action);
-  if (!action) {
-    throw new Error(`Invalid trigger action payload for replay: ${input.triggerPath}`);
-  }
-  return performTriggerAction(
-    workspacePath,
-    trigger,
-    action,
-    isRecord(input.context) ? input.context : {},
-    input.actor,
-    input.eventKey,
-  );
-}
-
-function createThreadFromTrigger(
-  workspacePath: string,
-  trigger: NormalizedTrigger,
-  action: Extract<TriggerAction, { type: 'create-thread' }>,
-  context: Record<string, unknown>,
-  actor: string,
-): PrimitiveInstance {
-  const title = String(
-    materializeTemplateValue(action.title ?? `Triggered follow-up: ${trigger.title}`, context),
-  );
-  const goal = String(
-    materializeTemplateValue(action.goal ?? `Follow-up work generated by trigger ${trigger.path}.`, context),
-  );
-  const body = String(
-    materializeTemplateValue(
-      action.body
-        ?? [
-          '## Trigger Context',
-          '',
-          'Generated by trigger execution.',
-          '',
-          '```json',
-          JSON.stringify(context, null, 2),
-          '```',
-          '',
-        ].join('\n'),
-      context,
-    ),
-  );
-
-  const fields = {
-    title,
-    goal,
-    priority: action.priority ?? 'medium',
-    deps: action.deps ?? [],
-    parent: action.parent,
-    space: action.space,
-    context_refs: action.context_refs ?? [],
-    tags: action.tags ?? [],
-  };
-  return store.create(workspacePath, 'thread', fields, body, actor);
-}
-
-function appendTriggerFireLedger(
-  workspacePath: string,
-  actor: string,
-  trigger: NormalizedTrigger,
-  actionType: string,
-  eventKey: string | undefined,
-  details: Record<string, unknown>,
-): void {
-  ledger.append(workspacePath, actor, 'update', trigger.path, 'trigger', {
-    fired: true,
-    action: actionType,
-    ...(eventKey ? { event_key: eventKey } : {}),
-    ...details,
-  });
-}
-
-function appendTriggerFailureLedger(
-  workspacePath: string,
-  actor: string,
-  trigger: NormalizedTrigger,
-  actionType: string,
-  eventKey: string | undefined,
-  details: Record<string, unknown>,
-): void {
-  ledger.append(workspacePath, actor, 'update', trigger.path, 'trigger', {
-    fired: false,
-    action: actionType,
-    ...(eventKey ? { event_key: eventKey } : {}),
-    ...details,
-  });
-}
-
-function runTriggerActionWithSafetyRails<T>(
-  workspacePath: string,
-  actor: string,
-  operation: string,
-  action: () => T,
-): T {
-  const decision = safety.evaluateSafety(workspacePath, {
-    actor,
-    operation,
-    consume: true,
-  });
-  if (!decision.allowed) {
-    throw new Error(`Safety rails blocked "${operation}": ${decision.reasons.join('; ')}`);
-  }
-  try {
-    const result = action();
-    safety.recordOperationOutcome(workspacePath, {
-      actor,
-      operation,
-      success: true,
-    });
-    return result;
-  } catch (error) {
-    safety.recordOperationOutcome(workspacePath, {
-      actor,
-      operation,
-      success: false,
-      error: errorMessage(error),
-    });
-    throw error;
-  }
-}
-
-function buildDispatchIdempotencyKey(triggerPath: string, eventKey: string, objective: string): string {
-  return createHash('sha256')
-    .update(`${triggerPath}:${eventKey}:${objective}`)
-    .digest('hex');
-}
-
-function evaluateTriggerCondition(input: {
-  workspacePath: string;
-  trigger: NormalizedTrigger;
-  runtime: TriggerRuntimeState;
-  now: Date;
-  ledgerEntries: ReturnType<typeof ledger.readAll>;
-}): TriggerConditionDecision {
-  if (input.trigger.synthesis) {
-    return evaluateSynthesisCondition(input);
-  }
-
-  const condition = input.trigger.condition;
-  if (!condition) {
-    return { matched: false, reason: 'Missing condition.' };
-  }
-
-  return evaluateConditionNode(input, condition);
-}
-
-function evaluateConditionNode(input: {
-  workspacePath: string;
-  trigger: NormalizedTrigger;
-  runtime: TriggerRuntimeState;
-  now: Date;
-  ledgerEntries: ReturnType<typeof ledger.readAll>;
-}, condition: TriggerCondition): TriggerConditionDecision {
-  if (condition.type === 'all') {
-    const workingRuntime = cloneTriggerRuntimeState(input.runtime);
-    const reasons: string[] = [];
-    let latestEventKey: string | undefined;
-    let mergedContext: Record<string, unknown> = {};
-    for (const child of condition.conditions) {
-      const decision = evaluateConditionNode({
-        ...input,
-        runtime: workingRuntime,
-      }, child);
-      reasons.push(decision.reason);
-      if (!decision.matched) {
-        Object.assign(input.runtime, workingRuntime);
-        return {
-          matched: false,
-          reason: `all(${reasons.join(' && ')})`,
-        };
-      }
-      latestEventKey = decision.eventKey ?? latestEventKey;
-      mergedContext = {
-        ...mergedContext,
-        ...(decision.context ?? {}),
-      };
-    }
-    Object.assign(input.runtime, workingRuntime);
-    return {
-      matched: true,
-      reason: `all(${reasons.join(' && ')})`,
-      eventKey: latestEventKey,
-      context: mergedContext,
-    };
-  }
-  if (condition.type === 'any') {
-    const workingRuntime = cloneTriggerRuntimeState(input.runtime);
-    const reasons: string[] = [];
-    for (const child of condition.conditions) {
-      const decision = evaluateConditionNode({
-        ...input,
-        runtime: workingRuntime,
-      }, child);
-      reasons.push(decision.reason);
-      if (decision.matched) {
-        Object.assign(input.runtime, workingRuntime);
-        return {
-          matched: true,
-          reason: `any(${decision.reason})`,
-          eventKey: decision.eventKey,
-          context: decision.context,
-        };
-      }
-    }
-    Object.assign(input.runtime, workingRuntime);
-    return {
-      matched: false,
-      reason: `any(${reasons.join(' || ')})`,
-    };
-  }
-  if (condition.type === 'not') {
-    const workingRuntime = cloneTriggerRuntimeState(input.runtime);
-    const decision = evaluateConditionNode({
-      ...input,
-      runtime: workingRuntime,
-    }, condition.condition);
-    Object.assign(input.runtime, workingRuntime);
-    return {
-      matched: !decision.matched,
-      reason: `not(${decision.reason})`,
-      ...(decision.matched ? {} : {
-        eventKey: decision.eventKey,
-        context: decision.context,
-      }),
-    };
-  }
-
-  switch (condition.type) {
-    case 'cron': {
-      const bucket = cronBucket(input.now);
-      const matches = matchesCronSchedule(condition.schedule, input.now);
-      if (!matches) {
-        return {
-          matched: false,
-          reason: `Cron ${condition.expression} did not match current time.`,
-        };
-      }
-      if (input.runtime.lastCronBucket === bucket) {
-        return {
-          matched: false,
-          reason: `Cron ${condition.expression} already fired for minute bucket ${bucket}.`,
-        };
-      }
-      input.runtime.lastCronBucket = bucket;
-      return {
-        matched: true,
-        reason: `Cron ${condition.expression} matched bucket ${bucket}.`,
-        eventKey: `cron:${bucket}`,
-      };
-    }
-    case 'event':
-      return evaluateEventCondition(input, condition.pattern);
-    case 'thread-complete':
-      return evaluateEventCondition(input, 'thread-complete');
-    case 'file-watch':
-      return evaluateFileWatchCondition(input, condition.glob);
-    case 'manual':
-      return {
-        matched: false,
-        reason: 'Manual trigger condition requires explicit `workgraph trigger fire`.',
-      };
-    default: {
-      const exhaustive: never = condition;
-      return {
-        matched: false,
-        reason: `Unsupported condition type: ${(exhaustive as { type?: string }).type ?? 'unknown'}`,
-      };
-    }
-  }
-}
-
-function evaluateSynthesisCondition(input: {
-  workspacePath: string;
-  trigger: NormalizedTrigger;
-  runtime: TriggerRuntimeState;
-  now: Date;
-}): TriggerConditionDecision {
-  const synthesis = input.trigger.synthesis;
-  if (!synthesis) {
-    return {
-      matched: false,
-      reason: 'Missing synthesis configuration.',
-    };
-  }
-
-  const nowIso = input.now.toISOString();
-  if (!input.runtime.synthesisCursorTs) {
-    input.runtime.synthesisCursorTs = nowIso;
-    return {
-      matched: false,
-      reason: 'Initialized synthesis cursor; waiting for new matching facts.',
-    };
-  }
-
-  const cursorTs = input.runtime.synthesisCursorTs;
-  const cursorDate = new Date(cursorTs);
-  const facts = store.list(input.workspacePath, 'fact');
-  const matchingFacts = facts.filter((fact) => {
-    if (!factHasTagPattern(fact, synthesis.tagPattern)) return false;
-    const createdAt = readPrimitiveTimestamp(input.workspacePath, fact, 'created');
-    return createdAt.getTime() > cursorDate.getTime();
-  });
-
-  if (matchingFacts.length < synthesis.threshold) {
-    return {
-      matched: false,
-      reason: `Synthesis threshold not met (${matchingFacts.length}/${synthesis.threshold}).`,
-    };
-  }
-
-  input.runtime.synthesisCursorTs = nowIso;
-  return {
-    matched: true,
-    reason: `Synthesis threshold met (${matchingFacts.length}/${synthesis.threshold}).`,
-    eventKey: `synthesis:${nowIso}`,
-    context: {
-      synthesis_tag_pattern: synthesis.tagPattern,
-      synthesis_threshold: synthesis.threshold,
-      synthesis_match_count: matchingFacts.length,
-      synthesis_fact_paths: matchingFacts.map((fact) => fact.path),
-    },
-  };
-}
-
-function evaluateEventCondition(input: {
-  trigger: NormalizedTrigger;
-  runtime: TriggerRuntimeState;
-  now: Date;
-  ledgerEntries: ReturnType<typeof ledger.readAll>;
-}, eventPatternRaw: string): TriggerConditionDecision {
-  const eventPattern = eventPatternRaw.toLowerCase();
-  const totalEntries = input.ledgerEntries.length;
-  const latestEntry = input.ledgerEntries[totalEntries - 1];
-
-  if (input.runtime.lastEventCursorOffset === undefined) {
-    input.runtime.lastEventCursorOffset = deriveEventCursorOffset(input.ledgerEntries, input.runtime);
-    input.runtime.lastEventCursorTs = latestEntry?.ts ?? input.now.toISOString();
-    input.runtime.lastEventCursorHash = latestEntry?.hash;
-    return {
-      matched: false,
-      reason: `Initialized event cursor for pattern "${eventPattern}" at offset ${input.runtime.lastEventCursorOffset}.`,
-    };
-  }
-
-  const cursorOffset = clampEventCursorOffset(input.runtime.lastEventCursorOffset, totalEntries);
-  const newEntries = input.ledgerEntries.slice(cursorOffset);
-  if (newEntries.length === 0) {
-    return {
-      matched: false,
-      reason: `No new events for pattern "${eventPattern}" since ledger offset ${cursorOffset}.`,
-    };
-  }
-
-  const matching = newEntries.filter((entry) => ledgerEntryMatchesEventPattern(entry, eventPattern));
-  const latestProcessed = newEntries[newEntries.length - 1]!;
-  input.runtime.lastEventCursorOffset = totalEntries;
-  input.runtime.lastEventCursorTs = latestProcessed.ts;
-  input.runtime.lastEventCursorHash = latestProcessed.hash;
-
-  if (matching.length === 0) {
-    return {
-      matched: false,
-      reason: `No events matched pattern "${eventPattern}" in ${newEntries.length} new ledger entries.`,
-    };
-  }
-
-  const latest = matching[matching.length - 1]!;
-  return {
-    matched: true,
-    reason: `Matched ${matching.length} event(s) for pattern "${eventPattern}".`,
-    eventKey: `event:${eventPattern}:${latest.ts}:${latest.target}`,
-    context: {
-      matched_event_pattern: eventPattern,
-      matched_event_count: matching.length,
-      matched_event_latest_target: latest.target,
-      matched_event_latest_op: latest.op,
-      matched_event_latest_type: latest.type,
-    },
-  };
-}
-
-function deriveEventCursorOffset(
-  entries: ReturnType<typeof ledger.readAll>,
-  runtime: TriggerRuntimeState,
-): number {
-  if (entries.length === 0) return 0;
-  if (runtime.lastEventCursorOffset !== undefined) {
-    return clampEventCursorOffset(runtime.lastEventCursorOffset, entries.length);
-  }
-
-  const cursorTs = typeof runtime.lastEventCursorTs === 'string'
-    ? runtime.lastEventCursorTs.trim()
-    : '';
-  if (!cursorTs) return entries.length;
-
-  const cursorHash = typeof runtime.lastEventCursorHash === 'string'
-    ? runtime.lastEventCursorHash.trim()
-    : '';
-  if (cursorHash) {
-    const hashIdx = findLastEntryIndex(entries, (entry) =>
-      entry.ts === cursorTs && String(entry.hash ?? '') === cursorHash
-    );
-    if (hashIdx !== -1) return hashIdx + 1;
-  }
-
-  const sameTsIdx = findLastEntryIndex(entries, (entry) => entry.ts === cursorTs);
-  if (sameTsIdx !== -1) return sameTsIdx + 1;
-
-  const firstNewerIdx = entries.findIndex((entry) => entry.ts > cursorTs);
-  if (firstNewerIdx !== -1) return firstNewerIdx;
-  return entries.length;
-}
-
-function clampEventCursorOffset(offset: number, totalEntries: number): number {
-  if (!Number.isFinite(offset)) return totalEntries;
-  return Math.min(totalEntries, Math.max(0, Math.trunc(offset)));
-}
-
-function findLastEntryIndex(
-  entries: ReturnType<typeof ledger.readAll>,
-  predicate: (entry: ReturnType<typeof ledger.readAll>[number]) => boolean,
-): number {
-  for (let idx = entries.length - 1; idx >= 0; idx -= 1) {
-    if (predicate(entries[idx]!)) return idx;
-  }
-  return -1;
-}
-
-function evaluateFileWatchCondition(input: {
-  workspacePath: string;
-  runtime: TriggerRuntimeState;
-  now: Date;
-}, glob: string): TriggerConditionDecision {
-  const nowIso = input.now.toISOString();
-  if (!input.runtime.lastFileScanTs) {
-    input.runtime.lastFileScanTs = nowIso;
-    return {
-      matched: false,
-      reason: `Initialized file-watch cursor for ${glob}.`,
-    };
-  }
-
-  const changedFiles = listFilesMatchingGlobChangedAfter(
-    input.workspacePath,
-    glob,
-    new Date(input.runtime.lastFileScanTs),
-  );
-  input.runtime.lastFileScanTs = nowIso;
-
-  if (changedFiles.length === 0) {
-    return {
-      matched: false,
-      reason: `No file changes matching ${glob}.`,
-    };
-  }
-
-  return {
-    matched: true,
-    reason: `${changedFiles.length} file(s) changed matching ${glob}.`,
-    eventKey: `file-watch:${glob}:${nowIso}`,
-    context: {
-      changed_file_count: changedFiles.length,
-      changed_files: changedFiles,
-    },
-  };
-}
-
-function ledgerEntryMatchesEventPattern(
-  entry: ReturnType<typeof ledger.readAll>[number],
-  eventPattern: string,
-): boolean {
-  const canonicalType = String(entry.type ?? '').toLowerCase();
-  const opOnly = entry.op.toLowerCase();
-  const typeOp = `${canonicalType}.${opOnly}`;
-  const pattern = eventPattern.toLowerCase();
-
-  if (pattern === 'thread-complete') {
-    return canonicalType === 'thread' && entry.op === 'done';
-  }
-
-  const dataEvent = typeof entry.data?.event_type === 'string'
-    ? String(entry.data.event_type).toLowerCase()
-    : undefined;
-  const target = String(entry.target ?? '').toLowerCase();
-  const candidates = [
-    opOnly,
-    canonicalType,
-    typeOp,
-    target,
-    `${typeOp}:${target}`,
-    dataEvent,
-  ].filter((value): value is string => typeof value === 'string' && value.length > 0);
-
-  if (!pattern.includes('*') && !pattern.includes('?')) {
-    return candidates.includes(pattern);
-  }
-  return candidates.some((candidate) => wildcardMatch(candidate, pattern));
-}
-
-function listNormalizedTriggers(workspacePath: string): NormalizedTrigger[] {
-  return store.list(workspacePath, 'trigger')
-    .map((instance) => normalizeTrigger(workspacePath, instance))
-    .sort((a, b) => a.path.localeCompare(b.path));
-}
-
-function normalizeTrigger(workspacePath: string, instance: PrimitiveInstance): NormalizedTrigger {
-  const status = String(instance.fields.status ?? 'draft').toLowerCase();
-  const title = String(instance.fields.name ?? instance.fields.title ?? instance.path);
-  const cooldownSeconds = normalizeInt(
-    asNumber(instance.fields.cooldown) ?? asNumber(instance.fields.cooldown_seconds) ?? 0,
-    0,
-    0,
-  );
-
-  const triggerType = parseTriggerPrimitiveType(instance.fields.type, instance.fields.condition);
-  const enabled = asBoolean(instance.fields.enabled) ?? isTriggerStatusActive(status);
-  const condition = safeParseCondition(instance.fields.condition ?? instance.fields.event, triggerType);
-  const action = parseTriggerAction(instance.fields.action);
-  const synthesis = parseSynthesisConfig(instance.fields.synthesis, instance.fields);
-  const cascadeOn = asStringList(instance.fields.cascade_on);
-
-  // Normalize legacy thread-complete filters in frontmatter.
-  if (condition?.type === 'thread-complete' && !condition.threadPath) {
-    const conditionThread = asString(instance.fields.thread_path);
-    if (conditionThread) {
-      condition.threadPath = normalizeReferencePath(conditionThread);
-    }
-  }
-
-  return {
-    instance,
-    path: instance.path,
-    title,
-    triggerType,
-    enabled,
-    status,
-    cooldownSeconds,
-    condition,
-    action,
-    cascadeOn,
-    synthesis,
-  };
-}
-
-function safeParseCondition(raw: unknown, triggerType: 'cron' | 'webhook' | 'event' | 'manual'): TriggerCondition | null {
-  try {
-    return parseTriggerCondition(raw, triggerType);
-  } catch {
-    return null;
-  }
-}
-
-function parseTriggerCondition(raw: unknown, triggerType: 'cron' | 'webhook' | 'event' | 'manual'): TriggerCondition | null {
-  if (raw === undefined || raw === null || (typeof raw === 'string' && raw.trim().length === 0)) {
-    if (triggerType === 'manual') return { type: 'manual' };
-    if (triggerType === 'webhook') return { type: 'event', pattern: 'webhook.*' };
-    if (triggerType === 'event') return { type: 'event', pattern: '*' };
-    return null;
-  }
-  if (typeof raw === 'string') {
-    const text = raw.trim();
-    if (!text) return null;
-    if (looksLikeCron(text)) {
-      return {
-        type: 'cron',
-        expression: text,
-        schedule: parseCronExpression(text),
-      };
-    }
-    if (text.toLowerCase() === 'thread-complete') {
-      return { type: 'thread-complete' };
-    }
-    if (text.toLowerCase() === 'manual') {
-      return { type: 'manual' };
-    }
-    return {
-      type: 'event',
-      pattern: text,
-    };
-  }
-
-  if (!raw || typeof raw !== 'object') return null;
-  const obj = raw as Record<string, unknown>;
-  const type = String(obj.type ?? '').toLowerCase();
-
-  if (type === 'all' || type === 'any') {
-    const conditions = Array.isArray(obj.conditions)
-      ? obj.conditions
-        .map((entry) => parseTriggerCondition(entry, 'event'))
-        .filter((entry): entry is TriggerCondition => !!entry)
-      : [];
-    if (conditions.length === 0) return null;
-    return {
-      type,
-      conditions,
-    };
-  }
-  if (type === 'not') {
-    const condition = parseTriggerCondition(obj.condition, 'event');
-    if (!condition) return null;
-    return {
-      type: 'not',
-      condition,
-    };
-  }
-
-  if (type === 'cron' || obj.cron !== undefined || obj.expression !== undefined) {
-    const expression = String(obj.expression ?? obj.cron ?? '').trim();
-    if (!expression) return null;
-    return {
-      type: 'cron',
-      expression,
-      schedule: parseCronExpression(expression),
-    };
-  }
-  if (type === 'event' || obj.event !== undefined || obj.event_type !== undefined) {
-    const pattern = String(obj.pattern ?? obj.event ?? obj.event_type ?? '').trim();
-    if (!pattern) return null;
-    return {
-      type: 'event',
-      pattern,
-    };
-  }
-  if (type === 'webhook') {
-    const pattern = String(obj.pattern ?? obj.event ?? 'webhook.*').trim();
-    if (!pattern) return null;
-    return {
-      type: 'event',
-      pattern,
-    };
-  }
-  if (type === 'file-watch' || obj.glob !== undefined || obj.pattern !== undefined) {
-    const glob = String(obj.glob ?? obj.pattern ?? '').trim();
-    if (!glob) return null;
-    return {
-      type: 'file-watch',
-      glob: normalizeGlob(glob),
-    };
-  }
-  if (type === 'thread-complete') {
-    const threadPath = asString(obj.thread_path ?? obj.thread);
-    return {
-      type: 'thread-complete',
-      threadPath: threadPath ? normalizeReferencePath(threadPath) : undefined,
-    };
-  }
-  if (type === 'manual') {
-    return { type: 'manual' };
-  }
-
-  return null;
-}
-
-function parseTriggerAction(raw: unknown): TriggerAction | null {
-  if (typeof raw === 'string') {
-    const text = raw.trim();
-    if (!text) return null;
-    const lowered = text.toLowerCase();
-    if (lowered === 'create-thread') {
-      return { type: 'create-thread' };
-    }
-    if (lowered === 'dispatch-run') {
-      return { type: 'dispatch-run' };
-    }
-    if (lowered === 'update-primitive') {
-      return null;
-    }
-    if (lowered.startsWith('shell:')) {
-      return {
-        type: 'shell',
-        command: text.slice('shell:'.length).trim(),
-      };
-    }
-    // Legacy behavior: treat free-form action strings as dispatch objective.
-    return {
-      type: 'dispatch-run',
-      objective: text,
-    };
-  }
-
-  if (!raw || typeof raw !== 'object') return null;
-  const obj = raw as Record<string, unknown>;
-  const type = String(obj.type ?? '').toLowerCase();
-  if (!type && (obj.objective !== undefined || obj.adapter !== undefined || obj.context !== undefined)) {
-    return {
-      type: 'dispatch-run',
-      objective: asString(obj.objective),
-      adapter: asString(obj.adapter),
-      context: isRecord(obj.context) ? obj.context : undefined,
-      actor: asString(obj.actor),
-    };
-  }
-  switch (type) {
-    case 'create-thread':
-      return {
-        type: 'create-thread',
-        title: asString(obj.title),
-        goal: asString(obj.goal),
-        body: asString(obj.body),
-        priority: asString(obj.priority),
-        deps: asStringList(obj.deps),
-        parent: asString(obj.parent),
-        space: asString(obj.space),
-        context_refs: asStringList(obj.context_refs),
-        tags: asStringList(obj.tags),
-        actor: asString(obj.actor),
-      };
-    case 'dispatch-run':
-      return {
-        type: 'dispatch-run',
-        objective: asString(obj.objective),
-        adapter: asString(obj.adapter),
-        context: isRecord(obj.context) ? obj.context : undefined,
-        actor: asString(obj.actor),
-      };
-    case 'update-primitive': {
-      const targetPath = asString(obj.path ?? obj.target_path ?? obj.target);
-      if (!targetPath) return null;
-      return {
-        type: 'update-primitive',
-        path: normalizeReferencePath(targetPath),
-        fields: isRecord(obj.fields) ? obj.fields : undefined,
-        body: asString(obj.body),
-        actor: asString(obj.actor),
-      };
-    }
-    case 'shell': {
-      const command = asString(obj.command ?? obj.shell ?? obj.script);
-      if (!command) return null;
-      return {
-        type: 'shell',
-        command,
-        timeoutMs: asNumber(obj.timeout_ms) ?? asNumber(obj.timeoutMs) ?? undefined,
-        actor: asString(obj.actor),
-      };
-    }
-    case 'webhook': {
-      const url = asString(obj.url);
-      if (!url) return null;
-      return {
-        type: 'webhook',
-        url,
-        method: asString(obj.method),
-        headers: asStringRecord(obj.headers),
-        bodyTemplate: obj.bodyTemplate ?? obj.body_template ?? obj.body,
-        timeoutMs: asNumber(obj.timeout_ms) ?? asNumber(obj.timeoutMs) ?? undefined,
-        actor: asString(obj.actor),
-      };
-    }
-    default:
-      return null;
-  }
-}
-
-function parseSynthesisConfig(raw: unknown, fields: Record<string, unknown>): SynthesisConfig | null {
-  let source: Record<string, unknown> | null = null;
-  if (isRecord(raw)) {
-    source = raw;
-  } else {
-    const legacyPattern = asString(fields.synthesis_tag_pattern);
-    const legacyThreshold = asNumber(fields.synthesis_threshold);
-    if (legacyPattern && legacyThreshold) {
-      source = {
-        tag_pattern: legacyPattern,
-        threshold: legacyThreshold,
-        actor: asString(fields.synthesis_actor),
-      };
-    }
-  }
-  if (!source) return null;
-  const tagPattern = asString(source.tag_pattern ?? source.tagPattern);
-  const threshold = asNumber(source.threshold);
-  if (!tagPattern || !threshold || threshold <= 0) return null;
-  return {
-    tagPattern,
-    threshold: normalizeInt(threshold, 1, 1),
-    actor: asString(source.actor),
-  };
-}
-
-function parseTriggerPrimitiveType(
-  rawType: unknown,
-  rawCondition: unknown,
-): 'cron' | 'webhook' | 'event' | 'manual' {
-  const normalized = typeof rawType === 'string'
-    ? rawType.trim().toLowerCase()
-    : '';
-  if (normalized === 'cron' || normalized === 'webhook' || normalized === 'event' || normalized === 'manual') {
-    return normalized;
-  }
-  if (typeof rawCondition === 'string' && looksLikeCron(rawCondition)) return 'cron';
-  if (isRecord(rawCondition) && typeof rawCondition.type === 'string') {
-    const conditionType = String(rawCondition.type).toLowerCase();
-    if (conditionType === 'cron') return 'cron';
-    if (conditionType === 'manual') return 'manual';
-  }
-  return 'event';
-}
-
-function isTriggerStatusActive(status: string): boolean {
-  return status === 'active' || status === 'approved';
-}
-
-function isTriggerCycleEvaluable(trigger: NormalizedTrigger): boolean {
-  return trigger.enabled && isTriggerStatusActive(trigger.status);
-}
-
-function normalizeTriggerPathFilter(triggerPaths: string[] | undefined): Set<string> | null {
-  if (!Array.isArray(triggerPaths) || triggerPaths.length === 0) return null;
-  const normalized = triggerPaths
-    .map((entry) => String(entry ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, ''))
-    .filter(Boolean);
-  if (normalized.length === 0) return null;
-  return new Set(normalized);
-}
-
-function syncTriggerScheduleFields(
-  workspacePath: string,
-  trigger: NormalizedTrigger,
-  runtime: TriggerRuntimeState,
-  actor: string,
-): void {
-  const current = store.read(workspacePath, trigger.path);
-  if (!current || current.type !== 'trigger') return;
-  const currentLastFired = asString(current.fields.last_fired);
-  const currentNextFire = asString(current.fields.next_fire_at);
-  const nextLastFired = runtime.lastFiredAt;
-  const nextFireAt = runtime.nextFireAt;
-
-  const shouldWriteLast = nextLastFired !== undefined && nextLastFired !== currentLastFired;
-  const shouldWriteNext = nextFireAt !== currentNextFire;
-  if (!shouldWriteLast && !shouldWriteNext) return;
-
-  const updates: Record<string, unknown> = {};
-  if (shouldWriteLast) updates.last_fired = nextLastFired;
-  if (shouldWriteNext) updates.next_fire_at = nextFireAt ?? null;
-  store.update(workspacePath, trigger.path, updates, undefined, actor);
-}
-
-function getOrCreateRuntimeState(state: TriggerStateData, triggerPath: string): TriggerRuntimeState {
-  if (!state.triggers[triggerPath]) {
-    state.triggers[triggerPath] = { fireCount: 0 };
-  }
-  return state.triggers[triggerPath]!;
-}
-
-function cloneTriggerRuntimeState(runtime: TriggerRuntimeState): TriggerRuntimeState {
-  return JSON.parse(JSON.stringify(runtime)) as TriggerRuntimeState;
-}
-
-function evaluateCooldown(
-  runtime: TriggerRuntimeState,
-  now: Date,
-): { blocked: false } | { blocked: true; reason: string } {
-  if (!runtime.cooldownUntil) {
-    return { blocked: false };
-  }
-  const until = Date.parse(runtime.cooldownUntil);
-  if (Number.isNaN(until) || now.getTime() >= until) {
-    runtime.cooldownUntil = undefined;
-    return { blocked: false };
-  }
-  const remainingMs = until - now.getTime();
-  return {
-    blocked: true,
-    reason: `Cooldown active (${Math.ceil(remainingMs / 1000)}s remaining).`,
-  };
-}
-
-function conditionRequiresLedgerRead(condition: TriggerCondition | null): boolean {
-  if (!condition) return false;
-  switch (condition.type) {
-    case 'event':
-    case 'thread-complete':
-      return true;
-    case 'all':
-    case 'any':
-      return condition.conditions.some((entry) => conditionRequiresLedgerRead(entry));
-    case 'not':
-      return conditionRequiresLedgerRead(condition.condition);
-    default:
-      return false;
-  }
-}
-
-function computeNextFireAt(
-  trigger: NormalizedTrigger,
-  runtime: TriggerRuntimeState,
-  now: Date,
-): string | undefined {
-  let candidate: Date | null = null;
-  if (trigger.condition?.type === 'cron') {
-    candidate = nextCronMatch(trigger.condition.schedule, now);
-  }
-
-  if (runtime.cooldownUntil) {
-    const cooldownDate = new Date(runtime.cooldownUntil);
-    if (!candidate || cooldownDate.getTime() > candidate.getTime()) {
-      candidate = cooldownDate;
-    }
-  }
-  return candidate?.toISOString();
-}
-
-function deriveRuntimeState(
-  trigger: NormalizedTrigger,
-  runtime: TriggerRuntimeState,
-  now: Date,
-): TriggerRuntimeStatus {
-  if (!trigger.enabled || !isTriggerStatusActive(trigger.status)) return 'inactive';
-  if (runtime.lastError) return 'error';
-  if (runtime.cooldownUntil) {
-    const until = Date.parse(runtime.cooldownUntil);
-    if (Number.isFinite(until) && now.getTime() < until) {
-      return 'cooldown';
-    }
-  }
-  return runtime.state ?? 'ready';
-}
-
-function describeCondition(trigger: NormalizedTrigger): string {
-  if (trigger.synthesis) {
-    return `synthesis(tag=${trigger.synthesis.tagPattern}, threshold=${trigger.synthesis.threshold})`;
-  }
-  if (!trigger.condition) return 'invalid';
-  switch (trigger.condition.type) {
-    case 'all':
-      return `all(${trigger.condition.conditions.map(describeConditionNode).join(', ')})`;
-    case 'any':
-      return `any(${trigger.condition.conditions.map(describeConditionNode).join(', ')})`;
-    case 'not':
-      return `not(${describeConditionNode(trigger.condition.condition)})`;
-    case 'cron':
-      return `cron(${trigger.condition.expression})`;
-    case 'event':
-      return `event(${trigger.condition.pattern})`;
-    case 'file-watch':
-      return `file-watch(${trigger.condition.glob})`;
-    case 'thread-complete':
-      return `thread-complete(${trigger.condition.threadPath ?? '*'})`;
-    case 'manual':
-      return 'manual(explicit fire only)';
-    default:
-      return 'invalid';
-  }
-}
-
-function describeConditionNode(condition: TriggerCondition): string {
-  switch (condition.type) {
-    case 'all':
-      return `all(${condition.conditions.map(describeConditionNode).join(', ')})`;
-    case 'any':
-      return `any(${condition.conditions.map(describeConditionNode).join(', ')})`;
-    case 'not':
-      return `not(${describeConditionNode(condition.condition)})`;
-    case 'cron':
-      return `cron(${condition.expression})`;
-    case 'event':
-      return `event(${condition.pattern})`;
-    case 'file-watch':
-      return `file-watch(${condition.glob})`;
-    case 'thread-complete':
-      return `thread-complete(${condition.threadPath ?? '*'})`;
-    case 'manual':
-      return 'manual(explicit fire only)';
-    default:
-      return 'invalid';
-  }
-}
-
-function describeAction(trigger: NormalizedTrigger): string {
-  const action = trigger.action;
-  if (!action) return 'invalid';
-  switch (action.type) {
-    case 'create-thread':
-      return `create-thread(${action.title ?? 'untitled'})`;
-    case 'dispatch-run':
-      return `dispatch-run(${action.objective ?? 'default objective'})`;
-    case 'update-primitive':
-      return `update-primitive(${action.path})`;
-    case 'shell':
-      return `shell(${action.command})`;
-    case 'webhook':
-      return `webhook(${(action.method ?? 'POST').toUpperCase()} ${action.url})`;
-    default:
-      return 'invalid';
-  }
-}
-
-function cronBucket(now: Date): string {
-  const copy = new Date(now.getTime());
-  copy.setSeconds(0, 0);
-  return copy.toISOString();
-}
-
-function factHasTagPattern(fact: PrimitiveInstance, pattern: string): boolean {
-  const tags = asStringList(fact.fields.tags).map((entry) => entry.toLowerCase());
-  if (tags.length === 0) return false;
-  const normalizedPattern = pattern.toLowerCase();
-  return tags.some((tag) => wildcardMatch(tag, normalizedPattern));
-}
-
-function wildcardMatch(value: string, pattern: string): boolean {
-  const escaped = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*/g, '.*')
-    .replace(/\?/g, '.');
-  const regex = new RegExp(`^${escaped}$`);
-  return regex.test(value);
-}
-
-function readPrimitiveTimestamp(workspacePath: string, instance: PrimitiveInstance, field: string): Date {
-  const value = asString(instance.fields[field]);
-  if (value) {
-    const parsed = Date.parse(value);
-    if (!Number.isNaN(parsed)) {
-      return new Date(parsed);
-    }
-  }
-  const absPath = path.join(workspacePath, instance.path);
-  const stat = fs.statSync(absPath);
-  return new Date(stat.mtimeMs);
-}
-
-function listFilesMatchingGlobChangedAfter(
-  workspacePath: string,
-  globPattern: string,
-  after: Date,
-): string[] {
-  const normalizedGlob = normalizeGlob(globPattern);
-  const matcher = globToRegExp(normalizedGlob);
-  const baseDirectory = findGlobBaseDirectory(normalizedGlob);
-  const absoluteBase = path.join(workspacePath, baseDirectory);
-  if (!fs.existsSync(absoluteBase)) return [];
-
-  const files = listFilesRecursive(absoluteBase);
-  const changed: string[] = [];
-  for (const absPath of files) {
-    const relPath = path.relative(workspacePath, absPath).replace(/\\/g, '/');
-    if (!matcher.test(relPath)) continue;
-    const stat = fs.statSync(absPath);
-    if (stat.mtimeMs > after.getTime()) {
-      changed.push(relPath);
-    }
-  }
-  return changed.sort((a, b) => a.localeCompare(b));
-}
-
-function listFilesRecursive(root: string): string[] {
-  const output: string[] = [];
-  const stack = [root];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    const entries = fs.readdirSync(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const absPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(absPath);
-      } else if (entry.isFile()) {
-        output.push(absPath);
-      }
-    }
-  }
-  return output;
-}
-
-function globToRegExp(globPattern: string): RegExp {
-  let regex = '^';
-  const pattern = normalizeGlob(globPattern);
-  for (let idx = 0; idx < pattern.length; idx += 1) {
-    const remaining = pattern.slice(idx);
-    if (remaining.startsWith('**/')) {
-      regex += '(?:.*/)?';
-      idx += 2;
-      continue;
-    }
-    const ch = pattern[idx]!;
-    if (ch === '*') {
-      if (pattern[idx + 1] === '*') {
-        regex += '.*';
-        idx += 1;
-      } else {
-        regex += '[^/]*';
-      }
-      continue;
-    }
-    if (ch === '?') {
-      regex += '[^/]';
-      continue;
-    }
-    regex += escapeRegex(ch);
-  }
-  regex += '$';
-  return new RegExp(regex);
-}
-
-function findGlobBaseDirectory(globPattern: string): string {
-  const normalized = normalizeGlob(globPattern);
-  const wildcardIndex = normalized.search(/[*?]/);
-  const prefix = wildcardIndex === -1 ? normalized : normalized.slice(0, wildcardIndex);
-  const slashIndex = prefix.lastIndexOf('/');
-  if (slashIndex === -1) return '.';
-  const base = prefix.slice(0, slashIndex);
-  return base || '.';
-}
-
-function normalizeGlob(value: string): string {
-  const normalized = String(value ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
-  return normalized.length > 0 ? normalized : '**/*';
-}
-
-function normalizeReferencePath(value: string): string {
-  const trimmed = String(value ?? '').trim();
-  const unwrapped = trimmed.startsWith('[[') && trimmed.endsWith(']]')
-    ? trimmed.slice(2, -2)
-    : trimmed;
-  return unwrapped.endsWith('.md') ? unwrapped : `${unwrapped}.md`;
-}
-
-interface WebhookRequestInput {
-  url: string;
-  method: string;
-  headers: Record<string, string>;
-  body?: string;
-  timeoutMs: number;
-}
-
-interface WebhookRequestResult {
-  ok: boolean;
-  status?: number;
-  statusText?: string;
-  bodyText: string;
-  error?: string;
-}
-
-const WEBHOOK_FETCH_RUNNER = `
-const fs = require('node:fs');
-
-async function main() {
-  const inputRaw = fs.readFileSync(0, 'utf8');
-  const input = inputRaw.trim().length > 0 ? JSON.parse(inputRaw) : {};
-  const timeoutMs = Number.isFinite(Number(input.timeoutMs))
-    ? Math.max(1, Math.trunc(Number(input.timeoutMs)))
-    : 10000;
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    const requestInit = {
-      method: String(input.method || 'POST').toUpperCase(),
-      headers: input.headers && typeof input.headers === 'object' && !Array.isArray(input.headers)
-        ? input.headers
-        : {},
-      signal: controller.signal,
-    };
-    if (Object.prototype.hasOwnProperty.call(input, 'body') && input.body !== undefined) {
-      requestInit.body = String(input.body);
-    }
-
-    const response = await fetch(String(input.url), requestInit);
-    const bodyText = await response.text();
-    return {
-      ok: response.ok,
-      status: response.status,
-      statusText: response.statusText,
-      bodyText,
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      bodyText: '',
-      error: error instanceof Error ? error.message : String(error),
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-main()
-  .then((result) => {
-    process.stdout.write(JSON.stringify(result));
-  })
-  .catch((error) => {
-    process.stderr.write(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  });
-`;
-
-function executeWebhookRequest(input: WebhookRequestInput): WebhookRequestResult {
-  const execution = spawnSync(process.execPath, ['-e', WEBHOOK_FETCH_RUNNER], {
-    encoding: 'utf-8',
-    input: JSON.stringify(input),
-    timeout: Math.max(input.timeoutMs + 2_000, 5_000),
-    maxBuffer: 5 * 1024 * 1024,
-  });
-  if (execution.error) {
-    return {
-      ok: false,
-      bodyText: '',
-      error: `Webhook request execution failed: ${execution.error.message}`,
-    };
-  }
-  const parsed = parseWebhookRequestResult(execution.stdout);
-  if (parsed) {
-    return parsed;
-  }
-  const stderr = execution.stderr?.trim();
-  return {
-    ok: false,
-    bodyText: '',
-    error: stderr
-      ? `Webhook request execution failed: ${stderr}`
-      : `Webhook request execution failed with exit code ${execution.status ?? 'unknown'}.`,
-  };
-}
-
-function parseWebhookRequestResult(raw: string): WebhookRequestResult | null {
-  const trimmed = raw.trim();
-  if (!trimmed) return null;
-  try {
-    const parsed = JSON.parse(trimmed) as Record<string, unknown>;
-    return {
-      ok: asBoolean(parsed.ok) ?? false,
-      status: asNumber(parsed.status),
-      statusText: asString(parsed.statusText),
-      bodyText: typeof parsed.bodyText === 'string' ? parsed.bodyText : '',
-      error: asString(parsed.error),
-    };
-  } catch {
-    return null;
-  }
-}
-
-function normalizeWebhookUrl(value: string): string {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error('Webhook trigger url is required.');
-  }
-  let parsed: URL;
-  try {
-    parsed = new URL(trimmed);
-  } catch {
-    throw new Error(`Webhook trigger url is invalid: ${trimmed}`);
-  }
-  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-    throw new Error(`Webhook trigger url must use http or https: ${trimmed}`);
-  }
-  return parsed.toString();
-}
-
-function normalizeWebhookMethod(value: string): string {
-  const method = value.trim().toUpperCase() || 'POST';
-  if (!/^[A-Z]+$/.test(method)) {
-    throw new Error(`Webhook trigger method is invalid: ${value}`);
-  }
-  return method;
-}
-
-function normalizeWebhookHeaders(value: unknown): Record<string, string> {
-  if (!isRecord(value)) return {};
-  const output: Record<string, string> = {};
-  for (const [rawKey, rawValue] of Object.entries(value)) {
-    const key = rawKey.trim();
-    if (!key || rawValue === undefined || rawValue === null) continue;
-    output[key] = String(rawValue);
-  }
-  return output;
-}
-
-function hasHeader(headers: Record<string, string>, expected: string): boolean {
-  const needle = expected.trim().toLowerCase();
-  if (!needle) return false;
-  return Object.keys(headers).some((key) => key.toLowerCase() === needle);
-}
-
-function createWebhookOutboxRecord(
-  workspacePath: string,
-  trigger: NormalizedTrigger,
-  input: {
-    url: string;
-    method: string;
-    timeoutMs: number;
-    headers: Record<string, string>;
-    body: unknown;
-    eventKey: string | undefined;
-  },
-): string | undefined {
-  try {
-    const envelope = transport.createTransportEnvelope({
-      direction: 'outbound',
-      channel: 'trigger-webhook',
-      topic: 'trigger.webhook',
-      source: `trigger-engine:${trigger.path}`,
-      target: input.url,
-      provider: 'webhook',
-      correlationId: input.eventKey,
-      dedupKeys: [
-        input.eventKey ? `trigger:${trigger.path}:${input.eventKey}` : '',
-        `webhook:${input.method}:${input.url}`,
-      ].filter(Boolean),
-      payload: {
-        trigger_path: trigger.path,
-        trigger_title: trigger.title,
-        event_key: input.eventKey,
-        method: input.method,
-        url: input.url,
-        timeout_ms: input.timeoutMs,
-        header_keys: Object.keys(input.headers),
-        body: input.body,
-      },
-    });
-    const outbox = transport.createTransportOutboxRecord(workspacePath, {
-      envelope,
-      deliveryHandler: 'trigger-webhook',
-      deliveryTarget: input.url,
-      message: `Trigger ${trigger.path} dispatching webhook to ${input.url}.`,
-    });
-    return outbox.id;
-  } catch {
-    return undefined;
-  }
-}
-
-function truncateText(value: string, maxLength: number): string {
-  if (value.length <= maxLength) return value;
-  return `${value.slice(0, maxLength)}...`;
-}
-
-function materializeTemplateValue(value: unknown, context: Record<string, unknown>): unknown {
-  if (typeof value === 'string') {
-    return interpolateTemplate(value, context);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => materializeTemplateValue(entry, context));
-  }
-  if (isRecord(value)) {
-    const output: Record<string, unknown> = {};
-    for (const [key, inner] of Object.entries(value)) {
-      output[key] = materializeTemplateValue(inner, context);
-    }
-    return output;
-  }
-  return value;
-}
-
-function interpolateTemplate(template: string, context: Record<string, unknown>): string {
-  return template.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_full, key: string) => {
-    const value = context[key];
-    if (value === undefined || value === null) return '';
-    if (typeof value === 'string') return value;
-    return JSON.stringify(value);
-  });
-}
-
-function seedTriggerState(): TriggerStateData {
-  return {
-    version: TRIGGER_STATE_VERSION,
-    updatedAt: new Date(0).toISOString(),
-    engine: {
-      cycleCount: 0,
-      intervalSeconds: DEFAULT_ENGINE_INTERVAL_SECONDS,
-    },
-    triggers: {},
-  };
-}
-
-function looksLikeCron(text: string): boolean {
-  const parts = text.trim().split(/\s+/);
-  if (parts.length !== 5) return false;
-  try {
-    parseCronExpression(text);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function asString(value: unknown): string | undefined {
-  if (typeof value === 'string' && value.trim().length > 0) {
-    return value.trim();
-  }
-  return undefined;
-}
-
-function asStringList(value: unknown): string[] {
-  if (Array.isArray(value)) {
-    return value.map((entry) => String(entry).trim()).filter(Boolean);
-  }
-  if (typeof value === 'string') {
-    return value.split(',').map((entry) => entry.trim()).filter(Boolean);
-  }
-  return [];
-}
-
-function asStringRecord(value: unknown): Record<string, string> | undefined {
-  if (!isRecord(value)) return undefined;
-  const output: Record<string, string> = {};
-  for (const [rawKey, rawValue] of Object.entries(value)) {
-    const key = rawKey.trim();
-    if (!key || rawValue === undefined || rawValue === null) continue;
-    output[key] = String(rawValue);
-  }
-  return Object.keys(output).length > 0 ? output : undefined;
-}
-
-function asNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function asBoolean(value: unknown): boolean | undefined {
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true') return true;
-    if (normalized === 'false') return false;
-  }
-  return undefined;
-}
-
-function normalizeInt(value: unknown, fallback: number, minimum: number): number {
-  const numeric = asNumber(value);
-  if (numeric === undefined) return fallback;
-  return Math.max(minimum, Math.trunc(numeric));
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function escapeRegex(value: string): string {
-  return value.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
-}
diff --git a/packages/kernel/src/trigger-run-evidence-loop.test.ts b/packages/kernel/src/trigger-run-evidence-loop.test.ts
deleted file mode 100644
index bec9b28..0000000
--- a/packages/kernel/src/trigger-run-evidence-loop.test.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as dispatch from './dispatch.js';
-import * as store from './store.js';
-import * as thread from './thread.js';
-import {
-  runTriggerRunEvidenceLoop,
-} from './trigger-engine.js';
-import { fireTriggerAndExecute } from './trigger.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-trigger-run-loop-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('trigger -> run -> evidence loop', () => {
-  it('executes dispatch runs for all trigger condition types', async () => {
-    const command = `"${process.execPath}" -e "console.log('loop-ok'); console.log('tests: 2 passed, 0 failed'); console.log('https://github.com/versatly/workgraph/pull/5150');"`;
-    const cronTrigger = createDispatchTrigger('Cron dispatch', {
-      type: 'cron',
-      expression: '* * * * *',
-    }, command);
-    const eventTrigger = createDispatchTrigger('Event dispatch', {
-      type: 'event',
-      event: 'thread-complete',
-    }, command);
-    const fileTrigger = createDispatchTrigger('File dispatch', {
-      type: 'file-watch',
-      glob: 'facts/**/*.md',
-    }, command);
-    const threadCompleteTrigger = createDispatchTrigger('Thread-complete dispatch', {
-      type: 'thread-complete',
-    }, command);
-
-    await runTriggerRunEvidenceLoop(workspacePath, {
-      actor: 'system',
-      now: new Date('2026-03-01T00:00:00.000Z'),
-      execution: { timeoutMs: 10_000 },
-    });
-
-    const completedThread = thread.createThread(workspacePath, 'Trigger source', 'Complete this thread', 'agent-trigger');
-    thread.claim(workspacePath, completedThread.path, 'agent-trigger');
-    thread.done(
-      workspacePath,
-      completedThread.path,
-      'agent-trigger',
-      'Completed https://github.com/versatly/workgraph/pull/500',
-    );
-    store.create(workspacePath, 'fact', {
-      title: 'Changed fact',
-      subject: 'system',
-      predicate: 'state',
-      object: 'updated',
-      tags: ['ops'],
-    }, '# Fact\n', 'agent-trigger', { pathOverride: 'facts/trigger-change.md' });
-
-    const second = await runTriggerRunEvidenceLoop(workspacePath, {
-      actor: 'system',
-      now: new Date('2026-03-01T00:01:00.000Z'),
-      execution: { timeoutMs: 10_000 },
-    });
-    expect(second.executedRuns.length).toBeGreaterThanOrEqual(3);
-    expect(second.failed).toBe(0);
-
-    const triggeredRuns = dispatch.listRuns(workspacePath)
-      .filter((run) => typeof run.context?.trigger_path === 'string');
-    const runsByTriggerPath = new Map<string, typeof triggeredRuns[number][]>();
-    for (const run of triggeredRuns) {
-      const triggerPath = String(run.context?.trigger_path);
-      const bucket = runsByTriggerPath.get(triggerPath) ?? [];
-      bucket.push(run);
-      runsByTriggerPath.set(triggerPath, bucket);
-    }
-    expect(runsByTriggerPath.get(cronTrigger.path)?.some((run) => run.status === 'succeeded')).toBe(true);
-    expect(runsByTriggerPath.get(eventTrigger.path)?.some((run) => run.status === 'succeeded')).toBe(true);
-    expect(runsByTriggerPath.get(fileTrigger.path)?.some((run) => run.status === 'succeeded')).toBe(true);
-    expect(runsByTriggerPath.get(threadCompleteTrigger.path)?.some((run) => run.status === 'succeeded')).toBe(true);
-  });
-
-  it('supports manual trigger fire -> execute flow', async () => {
-    const triggerPrimitive = createDispatchTrigger('Manual dispatch', {
-      type: 'event',
-      event: 'manual',
-    }, `"${process.execPath}" -e "console.log('manual-run');"`);
-
-    const result = await fireTriggerAndExecute(workspacePath, triggerPrimitive.path, {
-      actor: 'agent-manual',
-      eventKey: 'manual-evt-1',
-      adapter: 'shell-worker',
-      execute: true,
-      executeInput: {
-        timeoutMs: 10_000,
-      },
-    });
-
-    expect(result.executed).toBe(true);
-    expect(result.run.status).toBe('succeeded');
-    expect((result.run.evidenceChain?.count ?? 0) > 0).toBe(true);
-  });
-});
-
-function createDispatchTrigger(
-  title: string,
-  condition: Record<string, unknown>,
-  shellCommand: string,
-) {
-  return store.create(workspacePath, 'trigger', {
-    title,
-    status: 'active',
-    condition,
-    action: {
-      type: 'dispatch-run',
-      objective: `${title} objective`,
-      adapter: 'shell-worker',
-      context: {
-        shell_command: shellCommand,
-      },
-    },
-    cooldown: 0,
-  }, '# Trigger\n', 'system');
-}
diff --git a/packages/kernel/src/trigger.test.ts b/packages/kernel/src/trigger.test.ts
deleted file mode 100644
index 26ba216..0000000
--- a/packages/kernel/src/trigger.test.ts
+++ /dev/null
@@ -1,241 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import * as ledger from './ledger.js';
-import { loadRegistry, saveRegistry } from './registry.js';
-import * as store from './store.js';
-import {
-  createTrigger,
-  deleteTrigger,
-  disableTrigger,
-  enableTrigger,
-  fireTrigger,
-  listTriggers,
-  showTrigger,
-  triggerHistory,
-  updateTrigger,
-} from './trigger.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-trigger-primitives-'));
-  const registry = loadRegistry(workspacePath);
-  saveRegistry(workspacePath, registry);
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('trigger primitives', () => {
-  it('supports trigger primitive CRUD and state transitions', () => {
-    const created = createTrigger(workspacePath, {
-      actor: 'system',
-      name: 'Nightly digest',
-      type: 'cron',
-      condition: '0 2 * * *',
-      action: {
-        type: 'dispatch-run',
-        objective: 'Run nightly digest',
-      },
-      cooldown: 120,
-      tags: ['ops', 'nightly'],
-    });
-    expect(created.path).toContain('triggers/');
-    expect(String(created.fields.name)).toBe('Nightly digest');
-    expect(String(created.fields.type)).toBe('cron');
-    expect(created.fields.enabled).toBe(true);
-
-    const listed = listTriggers(workspacePath, { type: 'cron', enabled: true });
-    expect(listed.map((entry) => entry.path)).toContain(created.path);
-
-    const shown = showTrigger(workspacePath, 'nightly-digest');
-    expect(shown.path).toBe(created.path);
-
-    const updated = updateTrigger(workspacePath, created.path, {
-      actor: 'system',
-      cooldown: 300,
-      tags: ['ops', 'digest'],
-    });
-    expect(updated.fields.cooldown).toBe(300);
-    expect(updated.fields.tags).toEqual(['ops', 'digest']);
-
-    const disabled = disableTrigger(workspacePath, created.path, 'system');
-    expect(disabled.fields.enabled).toBe(false);
-    expect(disabled.fields.status).toBe('paused');
-
-    const enabled = enableTrigger(workspacePath, created.path, 'system');
-    expect(enabled.fields.enabled).toBe(true);
-    expect(enabled.fields.status).toBe('active');
-
-    const history = triggerHistory(workspacePath, created.path);
-    expect(history.length).toBeGreaterThan(0);
-
-    deleteTrigger(workspacePath, created.path, 'system');
-    expect(listTriggers(workspacePath).some((entry) => entry.path === created.path)).toBe(false);
-  });
-
-  it('throws when trigger path does not exist', () => {
-    expect(() => fireTrigger(workspacePath, 'triggers/missing-trigger.md', { actor: 'agent-x' }))
-      .toThrow('Trigger not found: triggers/missing-trigger.md');
-  });
-
-  it('throws when target primitive is not a trigger', () => {
-    const fact = store.create(
-      workspacePath,
-      'fact',
-      {
-        title: 'Fact target',
-        subject: 'system',
-        predicate: 'state',
-        object: 'ok',
-      },
-      '# Fact\n',
-      'agent-fact',
-    );
-
-    expect(() => fireTrigger(workspacePath, fact.path, { actor: 'agent-x' }))
-      .toThrow(`Target is not a trigger primitive: ${fact.path}`);
-  });
-
-  it('requires trigger status to be approved or active', () => {
-    const triggerPrimitive = store.create(
-      workspacePath,
-      'trigger',
-      {
-        title: 'Draft trigger',
-        event: 'thread.blocked',
-        action: 'dispatch.review',
-        status: 'draft',
-      },
-      '# Trigger\n',
-      'system',
-    );
-
-    expect(() => fireTrigger(workspacePath, triggerPrimitive.path, { actor: 'agent-x', eventKey: 'evt-1' }))
-      .toThrow('Trigger must be approved/active to fire. Current status: draft');
-  });
-
-  it('blocks manual fire when trigger is explicitly disabled', () => {
-    const triggerPrimitive = store.create(
-      workspacePath,
-      'trigger',
-      {
-        title: 'Disabled trigger',
-        type: 'manual',
-        enabled: false,
-        status: 'active',
-        action: {
-          type: 'dispatch-run',
-          objective: 'Should never run',
-        },
-      },
-      '# Trigger\n',
-      'system',
-    );
-
-    expect(() => fireTrigger(workspacePath, triggerPrimitive.path, { actor: 'agent-x', eventKey: 'evt-1' }))
-      .toThrow(`Trigger must be enabled to fire: ${triggerPrimitive.path}`);
-  });
-
-  it('fires using dispatch template interpolation and updates last_fired', () => {
-    const triggerPrimitive = createTrigger(workspacePath, {
-      actor: 'system',
-      name: 'Escalate incident',
-      type: 'manual',
-      condition: { type: 'manual' },
-      action: {
-        type: 'dispatch-run',
-        objective: 'Escalate {{incident_id}} to {{owner}}',
-        context: {
-          severity: '{{severity}}',
-          incident_id: '{{incident_id}}',
-        },
-      },
-    });
-
-    const fired = fireTrigger(workspacePath, triggerPrimitive.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-manual-1',
-      context: {
-        incident_id: 'inc-17',
-        owner: 'agent-ops',
-        severity: 'critical',
-      },
-    });
-    expect(fired.run.objective).toBe('Escalate inc-17 to agent-ops');
-    expect(fired.run.context?.severity).toBe('critical');
-    expect(fired.run.context?.incident_id).toBe('inc-17');
-    expect(fired.run.context?.trigger_type).toBe('manual');
-
-    const refreshed = showTrigger(workspacePath, triggerPrimitive.path);
-    expect(typeof refreshed.fields.last_fired).toBe('string');
-  });
-
-  it('fires active triggers with deterministic idempotency and writes ledger audit entries', () => {
-    const triggerPrimitive = store.create(
-      workspacePath,
-      'trigger',
-      {
-        title: 'Escalate blocked thread',
-        event: 'thread.blocked',
-        action: 'dispatch.review',
-        status: 'active',
-      },
-      '# Trigger\n',
-      'system',
-    );
-
-    const first = fireTrigger(workspacePath, triggerPrimitive.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-100',
-      context: {
-        severity: 'high',
-      },
-    });
-    const second = fireTrigger(workspacePath, triggerPrimitive.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-100',
-      context: {
-        severity: 'high',
-      },
-    });
-    const third = fireTrigger(workspacePath, triggerPrimitive.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-101',
-      context: {
-        severity: 'high',
-      },
-    });
-    const customObjective = fireTrigger(workspacePath, triggerPrimitive.path, {
-      actor: 'agent-gate',
-      eventKey: 'evt-100',
-      objective: 'Escalate to incident commander',
-      context: {
-        severity: 'critical',
-      },
-    });
-
-    expect(first.idempotencyKey).toMatch(/^[0-9a-f]{32}$/);
-    expect(second.idempotencyKey).toBe(first.idempotencyKey);
-    expect(second.run.id).toBe(first.run.id);
-    expect(third.idempotencyKey).not.toBe(first.idempotencyKey);
-    expect(third.run.id).not.toBe(first.run.id);
-    expect(customObjective.idempotencyKey).not.toBe(first.idempotencyKey);
-    expect(customObjective.run.id).not.toBe(first.run.id);
-
-    expect(first.run.context?.trigger_path).toBe(triggerPrimitive.path);
-    expect(first.run.context?.trigger_event).toBe('thread.blocked');
-    expect(first.run.context?.severity).toBe('high');
-    expect(first.run.objective).toContain('Escalate blocked thread');
-    expect(customObjective.run.objective).toBe('Escalate to incident commander');
-
-    const triggerHistory = ledger.historyOf(workspacePath, triggerPrimitive.path)
-      .filter((entry) => entry.data?.fired === true);
-    expect(triggerHistory.length).toBe(4);
-    expect(triggerHistory.at(-1)?.data?.run_id).toBe(customObjective.run.id);
-    expect(triggerHistory.at(-1)?.data?.idempotency_key).toBe(customObjective.idempotencyKey);
-  });
-});
diff --git a/packages/kernel/src/trigger.ts b/packages/kernel/src/trigger.ts
deleted file mode 100644
index d280226..0000000
--- a/packages/kernel/src/trigger.ts
+++ /dev/null
@@ -1,593 +0,0 @@
-/**
- * Trigger-to-run dispatch helpers.
- */
-
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import * as dispatch from './dispatch.js';
-import * as ledger from './ledger.js';
-import * as store from './store.js';
-import * as triggerEngine from './trigger-engine.js';
-import type { DispatchRun, LedgerEntry, PrimitiveInstance } from './types.js';
-
-export type TriggerPrimitiveType = 'cron' | 'webhook' | 'event' | 'manual';
-
-export interface TriggerCreateInput {
-  actor: string;
-  name: string;
-  type: TriggerPrimitiveType;
-  condition?: unknown;
-  action?: unknown;
-  enabled?: boolean;
-  cooldown?: number;
-  body?: string;
-  tags?: string[];
-  path?: string;
-}
-
-export interface TriggerListOptions {
-  enabled?: boolean;
-  type?: TriggerPrimitiveType;
-}
-
-export interface TriggerUpdateInput {
-  actor: string;
-  name?: string;
-  type?: TriggerPrimitiveType;
-  condition?: unknown;
-  action?: unknown;
-  enabled?: boolean;
-  cooldown?: number;
-  body?: string;
-  tags?: string[];
-  lastFired?: string | null;
-  nextFireAt?: string | null;
-}
-
-export interface TriggerEvaluateOptions {
-  actor?: string;
-  now?: Date;
-}
-
-export interface TriggerEvaluateResult {
-  triggerPath: string;
-  cycle: triggerEngine.TriggerEngineCycleResult;
-  trigger: triggerEngine.TriggerEngineCycleTriggerResult | undefined;
-}
-
-export interface FireTriggerOptions {
-  actor: string;
-  eventKey?: string;
-  objective?: string;
-  adapter?: string;
-  context?: Record<string, unknown>;
-}
-
-export interface FireTriggerResult {
-  triggerPath: string;
-  run: DispatchRun;
-  idempotencyKey: string;
-}
-
-export interface FireTriggerAndExecuteOptions extends FireTriggerOptions {
-  execute?: boolean;
-  retryFailed?: boolean;
-  executeInput?: Omit<dispatch.DispatchExecuteInput, 'actor'>;
-  retryInput?: Omit<dispatch.DispatchRetryInput, 'actor'>;
-}
-
-export interface FireTriggerAndExecuteResult extends FireTriggerResult {
-  executed: boolean;
-  retriedFromRunId?: string;
-}
-
-export function createTrigger(
-  workspacePath: string,
-  input: TriggerCreateInput,
-): PrimitiveInstance {
-  const name = normalizeNonEmpty(input.name, 'Trigger name');
-  const triggerType = normalizeTriggerType(input.type);
-  const enabled = input.enabled ?? true;
-  const fields: Record<string, unknown> = {
-    title: name,
-    name,
-    type: triggerType,
-    condition: normalizeTriggerCondition(triggerType, input.condition),
-    action: normalizeTriggerAction(input.action, name),
-    enabled,
-    status: enabled ? 'active' : 'paused',
-    cooldown: normalizeCooldown(input.cooldown),
-    tags: normalizeTags(input.tags),
-  };
-  return store.create(
-    workspacePath,
-    'trigger',
-    fields,
-    input.body ?? defaultTriggerBody(name, triggerType),
-    input.actor,
-    {
-      pathOverride: normalizeTriggerPathOverride(input.path),
-    },
-  );
-}
-
-export function listTriggers(
-  workspacePath: string,
-  options: TriggerListOptions = {},
-): PrimitiveInstance[] {
-  let triggers = store.list(workspacePath, 'trigger')
-    .sort((left, right) => left.path.localeCompare(right.path));
-  if (options.enabled !== undefined) {
-    triggers = triggers.filter((trigger) => readTriggerEnabled(trigger.fields) === options.enabled);
-  }
-  if (options.type) {
-    const expectedType = normalizeTriggerType(options.type);
-    triggers = triggers.filter((trigger) =>
-      readTriggerType(trigger.fields) === expectedType);
-  }
-  return triggers;
-}
-
-export function showTrigger(workspacePath: string, triggerRef: string): PrimitiveInstance {
-  return readTriggerByReference(workspacePath, triggerRef);
-}
-
-export function updateTrigger(
-  workspacePath: string,
-  triggerRef: string,
-  input: TriggerUpdateInput,
-): PrimitiveInstance {
-  const trigger = readTriggerByReference(workspacePath, triggerRef);
-  const nextType = input.type
-    ? normalizeTriggerType(input.type)
-    : readTriggerType(trigger.fields);
-  const updates: Record<string, unknown> = {};
-
-  if (input.name !== undefined) {
-    const name = normalizeNonEmpty(input.name, 'Trigger name');
-    updates.name = name;
-    updates.title = name;
-  }
-  if (input.type !== undefined) {
-    updates.type = nextType;
-  }
-  if (input.condition !== undefined) {
-    updates.condition = normalizeTriggerCondition(nextType, input.condition);
-  }
-  if (input.action !== undefined) {
-    const fallbackName = String(trigger.fields.name ?? trigger.fields.title ?? trigger.path);
-    updates.action = normalizeTriggerAction(input.action, fallbackName);
-  }
-  if (input.enabled !== undefined) {
-    updates.enabled = input.enabled;
-    updates.status = input.enabled ? 'active' : 'paused';
-  }
-  if (input.cooldown !== undefined) {
-    updates.cooldown = normalizeCooldown(input.cooldown);
-  }
-  if (input.tags !== undefined) {
-    updates.tags = normalizeTags(input.tags);
-  }
-  if (input.lastFired !== undefined) {
-    updates.last_fired = normalizeNullableDate(input.lastFired, 'lastFired');
-  }
-  if (input.nextFireAt !== undefined) {
-    updates.next_fire_at = normalizeNullableDate(input.nextFireAt, 'nextFireAt');
-  }
-
-  return store.update(
-    workspacePath,
-    trigger.path,
-    updates,
-    input.body,
-    input.actor,
-  );
-}
-
-export function deleteTrigger(workspacePath: string, triggerRef: string, actor: string): void {
-  const trigger = readTriggerByReference(workspacePath, triggerRef);
-  store.remove(workspacePath, trigger.path, actor);
-}
-
-export function enableTrigger(workspacePath: string, triggerRef: string, actor: string): PrimitiveInstance {
-  return updateTrigger(workspacePath, triggerRef, { actor, enabled: true });
-}
-
-export function disableTrigger(workspacePath: string, triggerRef: string, actor: string): PrimitiveInstance {
-  return updateTrigger(workspacePath, triggerRef, { actor, enabled: false });
-}
-
-export function triggerHistory(workspacePath: string, triggerRef: string): LedgerEntry[] {
-  const trigger = readTriggerByReference(workspacePath, triggerRef);
-  return ledger.historyOf(workspacePath, trigger.path);
-}
-
-export function evaluateTrigger(
-  workspacePath: string,
-  triggerRef: string,
-  options: TriggerEvaluateOptions = {},
-): TriggerEvaluateResult {
-  const trigger = readTriggerByReference(workspacePath, triggerRef);
-  const cycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-    actor: options.actor,
-    now: options.now,
-    triggerPaths: [trigger.path],
-  });
-  return {
-    triggerPath: trigger.path,
-    cycle,
-    trigger: cycle.triggers.find((entry) => entry.triggerPath === trigger.path),
-  };
-}
-
-export function fireTrigger(
-  workspacePath: string,
-  triggerRef: string,
-  options: FireTriggerOptions,
-): FireTriggerResult {
-  const trigger = readTriggerByReference(workspacePath, triggerRef);
-
-  const explicitEnabled = asBoolean(trigger.fields.enabled);
-  if (explicitEnabled === false) {
-    throw new Error(`Trigger must be enabled to fire: ${trigger.path}`);
-  }
-  const triggerStatus = String(trigger.fields.status ?? 'draft').toLowerCase();
-  if (triggerStatus === 'retired') throw new Error(`Trigger is retired and cannot be fired: ${trigger.path}`);
-  if (!['approved', 'active'].includes(triggerStatus)) {
-    throw new Error(`Trigger must be approved/active to fire. Current status: ${triggerStatus}`);
-  }
-
-  const eventSeed = options.eventKey ?? new Date().toISOString();
-  const dispatchTemplate = parseDispatchTemplate(trigger.fields.action);
-  const templateContext = {
-    trigger_path: trigger.path,
-    trigger_name: String(trigger.fields.name ?? trigger.fields.title ?? trigger.path),
-    trigger_type: readTriggerType(trigger.fields),
-    event_key: eventSeed,
-    ...(options.context ?? {}),
-  };
-  const objectiveTemplate = options.objective
-    ?? dispatchTemplate?.objective
-    ?? `Trigger ${String(trigger.fields.title ?? trigger.path)} fired`;
-  const objective = String(materializeTemplateValue(objectiveTemplate, templateContext));
-  const actionContext = isRecord(dispatchTemplate?.context)
-    ? materializeTemplateValue(dispatchTemplate.context, templateContext) as Record<string, unknown>
-    : {};
-  const idempotencyKey = buildIdempotencyKey(trigger.path, eventSeed, objective);
-
-  const run = dispatch.createRun(workspacePath, {
-    actor: options.actor,
-    adapter: options.adapter ?? dispatchTemplate?.adapter,
-    objective,
-    context: {
-      trigger_path: trigger.path,
-      trigger_event: describeTriggerEvent(trigger),
-      trigger_type: readTriggerType(trigger.fields),
-      event_key: eventSeed,
-      ...actionContext,
-      ...options.context,
-    },
-    idempotencyKey,
-  });
-
-  store.update(
-    workspacePath,
-    trigger.path,
-    {
-      last_fired: new Date().toISOString(),
-    },
-    undefined,
-    options.actor,
-  );
-
-  ledger.append(workspacePath, options.actor, 'create', trigger.path, 'trigger', {
-    fired: true,
-    event_key: eventSeed,
-    run_id: run.id,
-    idempotency_key: idempotencyKey,
-  });
-
-  return {
-    triggerPath: trigger.path,
-    run,
-    idempotencyKey,
-  };
-}
-
-export async function fireTriggerAndExecute(
-  workspacePath: string,
-  triggerPath: string,
-  options: FireTriggerAndExecuteOptions,
-): Promise<FireTriggerAndExecuteResult> {
-  const fired = fireTrigger(workspacePath, triggerPath, options);
-  if (options.execute === false) {
-    return {
-      ...fired,
-      executed: false,
-    };
-  }
-
-  if (fired.run.status === 'failed' && options.retryFailed) {
-    const retried = await dispatch.retryRun(workspacePath, fired.run.id, {
-      actor: options.actor,
-      ...(options.retryInput ?? {}),
-    });
-    return {
-      triggerPath: fired.triggerPath,
-      idempotencyKey: fired.idempotencyKey,
-      run: retried,
-      executed: true,
-      retriedFromRunId: fired.run.id,
-    };
-  }
-
-  if (fired.run.status === 'queued' || fired.run.status === 'running') {
-    const executed = await dispatch.executeRun(workspacePath, fired.run.id, {
-      actor: options.actor,
-      ...(options.executeInput ?? {}),
-    });
-    return {
-      triggerPath: fired.triggerPath,
-      idempotencyKey: fired.idempotencyKey,
-      run: executed,
-      executed: true,
-    };
-  }
-
-  return {
-    ...fired,
-    executed: false,
-  };
-}
-
-function buildIdempotencyKey(triggerPath: string, eventSeed: string, objective: string): string {
-  return createHash('sha256')
-    .update(`${triggerPath}:${eventSeed}:${objective}`)
-    .digest('hex')
-    .slice(0, 32);
-}
-
-function normalizeTriggerType(value: unknown): TriggerPrimitiveType {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (normalized === 'cron' || normalized === 'webhook' || normalized === 'event' || normalized === 'manual') {
-    return normalized;
-  }
-  throw new Error(`Invalid trigger type "${String(value)}". Expected cron|webhook|event|manual.`);
-}
-
-function readTriggerType(fields: Record<string, unknown>): TriggerPrimitiveType {
-  const raw = fields.type;
-  if (raw === undefined) return 'event';
-  return normalizeTriggerType(raw);
-}
-
-function readTriggerEnabled(fields: Record<string, unknown>): boolean {
-  const explicitEnabled = asBoolean(fields.enabled);
-  if (explicitEnabled !== undefined) return explicitEnabled;
-  const status = String(fields.status ?? '').toLowerCase();
-  return status === 'active' || status === 'approved';
-}
-
-function normalizeTriggerCondition(triggerType: TriggerPrimitiveType, condition: unknown): unknown {
-  if (condition !== undefined) return condition;
-  switch (triggerType) {
-    case 'manual':
-      return { type: 'manual' };
-    case 'webhook':
-      return { type: 'event', pattern: 'webhook.*' };
-    case 'event':
-      return { type: 'event', pattern: '*' };
-    case 'cron':
-      throw new Error('Cron triggers require a condition expression.');
-    default:
-      return condition;
-  }
-}
-
-function normalizeTriggerAction(action: unknown, triggerName: string): unknown {
-  if (action === undefined) {
-    return stripUndefinedDeep({
-      type: 'dispatch-run',
-      objective: `Trigger ${triggerName} fired`,
-    });
-  }
-  if (typeof action === 'string') {
-    return stripUndefinedDeep({
-      type: 'dispatch-run',
-      objective: action,
-    });
-  }
-  if (isRecord(action) && action.type === undefined) {
-    if (action.objective !== undefined || action.adapter !== undefined || action.context !== undefined) {
-      return stripUndefinedDeep({
-        type: 'dispatch-run',
-        ...action,
-      });
-    }
-  }
-  return stripUndefinedDeep(action);
-}
-
-function normalizeTriggerPathOverride(pathOverride?: string): string | undefined {
-  if (!pathOverride) return undefined;
-  const normalized = String(pathOverride).trim().replace(/\\/g, '/').replace(/^\.\//, '');
-  if (!normalized) return undefined;
-  const withExtension = normalized.endsWith('.md') ? normalized : `${normalized}.md`;
-  if (withExtension.startsWith('triggers/')) return withExtension;
-  return `triggers/${withExtension.replace(/^\/+/, '')}`;
-}
-
-function normalizeCooldown(cooldown: unknown): number {
-  const parsed = Number(cooldown ?? 0);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    throw new Error(`Invalid trigger cooldown "${String(cooldown)}". Expected a non-negative number.`);
-  }
-  return Math.trunc(parsed);
-}
-
-function normalizeTags(tags: string[] | undefined): string[] {
-  if (!tags) return [];
-  return tags.map((tag) => String(tag).trim()).filter(Boolean);
-}
-
-function defaultTriggerBody(name: string, triggerType: TriggerPrimitiveType): string {
-  return [
-    '## Trigger Primitive',
-    '',
-    `- Name: ${name}`,
-    `- Type: ${triggerType}`,
-    '',
-    'Dispatches runs when this trigger evaluates true.',
-    '',
-  ].join('\n');
-}
-
-function normalizeNullableDate(value: string | null, label: string): string | null {
-  if (value === null) return null;
-  const normalized = String(value ?? '').trim();
-  if (!normalized) {
-    throw new Error(`Invalid ${label} value. Expected ISO timestamp or null.`);
-  }
-  const parsed = Date.parse(normalized);
-  if (Number.isNaN(parsed)) {
-    throw new Error(`Invalid ${label} value "${normalized}". Expected ISO timestamp.`);
-  }
-  return new Date(parsed).toISOString();
-}
-
-function parseDispatchTemplate(action: unknown): {
-  objective?: string;
-  adapter?: string;
-  context?: Record<string, unknown>;
-} | null {
-  if (typeof action === 'string') return null;
-  if (!isRecord(action)) return null;
-  if (action.type && String(action.type).toLowerCase() !== 'dispatch-run') {
-    return null;
-  }
-  const objective = typeof action.objective === 'string'
-    ? action.objective
-    : undefined;
-  const adapter = typeof action.adapter === 'string'
-    ? action.adapter
-    : undefined;
-  const context = isRecord(action.context)
-    ? action.context
-    : undefined;
-  return { objective, adapter, context };
-}
-
-function readTriggerByReference(workspacePath: string, triggerRef: string): PrimitiveInstance {
-  const normalizedRef = String(triggerRef ?? '').trim();
-  if (!normalizedRef) throw new Error('Trigger reference is required.');
-
-  if (looksLikePathReference(normalizedRef)) {
-    const pathRef = normalizePathReference(normalizedRef);
-    const trigger = store.read(workspacePath, pathRef);
-    if (!trigger) throw new Error(`Trigger not found: ${pathRef}`);
-    if (trigger.type !== 'trigger') throw new Error(`Target is not a trigger primitive: ${pathRef}`);
-    return trigger;
-  }
-
-  const slug = slugify(normalizedRef);
-  const candidates = listTriggers(workspacePath).filter((trigger) =>
-    path.basename(trigger.path, '.md') === slug
-    || slugify(String(trigger.fields.name ?? trigger.fields.title ?? '')) === slug
-  );
-  if (candidates.length === 0) {
-    throw new Error(`Trigger not found: ${normalizedRef}`);
-  }
-  if (candidates.length > 1) {
-    throw new Error(`Ambiguous trigger reference "${normalizedRef}". Use an explicit trigger path.`);
-  }
-  return candidates[0]!;
-}
-
-function looksLikePathReference(value: string): boolean {
-  return value.includes('/') || value.endsWith('.md');
-}
-
-function normalizePathReference(value: string): string {
-  const normalized = value.replace(/\\/g, '/').replace(/^\.\//, '');
-  if (normalized.endsWith('.md')) return normalized;
-  if (normalized.startsWith('triggers/')) return `${normalized}.md`;
-  return `triggers/${normalized}.md`;
-}
-
-function describeTriggerEvent(trigger: PrimitiveInstance): string {
-  if (typeof trigger.fields.event === 'string' && trigger.fields.event.trim().length > 0) {
-    return trigger.fields.event.trim();
-  }
-  const condition = trigger.fields.condition;
-  if (typeof condition === 'string') return condition;
-  if (isRecord(condition)) {
-    for (const key of ['pattern', 'event', 'event_type', 'expression', 'cron']) {
-      if (typeof condition[key] === 'string' && condition[key].trim().length > 0) {
-        return condition[key].trim();
-      }
-    }
-  }
-  return readTriggerType(trigger.fields);
-}
-
-function materializeTemplateValue(value: unknown, context: Record<string, unknown>): unknown {
-  if (typeof value === 'string') {
-    return value.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key: string) => {
-      const candidate = context[key];
-      if (candidate === undefined || candidate === null) return '';
-      if (typeof candidate === 'string') return candidate;
-      return JSON.stringify(candidate);
-    });
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => materializeTemplateValue(entry, context));
-  }
-  if (isRecord(value)) {
-    const output: Record<string, unknown> = {};
-    for (const [key, inner] of Object.entries(value)) {
-      output[key] = materializeTemplateValue(inner, context);
-    }
-    return output;
-  }
-  return value;
-}
-
-function normalizeNonEmpty(value: unknown, label: string): string {
-  const normalized = String(value ?? '').trim();
-  if (!normalized) throw new Error(`${label} is required.`);
-  return normalized;
-}
-
-function asBoolean(value: unknown): boolean | undefined {
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true') return true;
-    if (normalized === 'false') return false;
-  }
-  return undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function slugify(value: string): string {
-  return String(value ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
-function stripUndefinedDeep(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map((entry) => stripUndefinedDeep(entry));
-  }
-  if (!isRecord(value)) return value;
-  const output: Record<string, unknown> = {};
-  for (const [key, inner] of Object.entries(value)) {
-    if (inner === undefined) continue;
-    output[key] = stripUndefinedDeep(inner);
-  }
-  return output;
-}
diff --git a/packages/kernel/src/validation/schema.ts b/packages/kernel/src/validation/schema.ts
deleted file mode 100644
index 730fd1f..0000000
--- a/packages/kernel/src/validation/schema.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { create, update } from '../store.js';
diff --git a/packages/kernel/src/workspace-structure.test.ts b/packages/kernel/src/workspace-structure.test.ts
deleted file mode 100644
index 8876799..0000000
--- a/packages/kernel/src/workspace-structure.test.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-
-const REPO_ROOT = process.cwd();
-const PACKAGES_ROOT = path.join(REPO_ROOT, 'packages');
-const PACKAGE_NAME_PREFIX = '@versatly/workgraph-';
-
-describe('workspace structure integrity', () => {
-  it('ensures every packages/* directory is a valid workspace package', () => {
-    const packageDirs = fs.readdirSync(PACKAGES_ROOT, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort((a, b) => a.localeCompare(b));
-
-    expect(packageDirs.length).toBeGreaterThan(0);
-
-    for (const dirName of packageDirs) {
-      const packageRoot = path.join(PACKAGES_ROOT, dirName);
-      const packageJsonPath = path.join(packageRoot, 'package.json');
-      const tsconfigPath = path.join(packageRoot, 'tsconfig.json');
-
-      expect(
-        fs.existsSync(packageJsonPath),
-        `Missing package.json in packages/${dirName}`,
-      ).toBe(true);
-      expect(
-        fs.existsSync(tsconfigPath),
-        `Missing tsconfig.json in packages/${dirName}`,
-      ).toBe(true);
-
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as {
-        name?: string;
-        scripts?: Record<string, string>;
-      };
-      const packageName = String(packageJson.name ?? '');
-      expect(
-        packageName.startsWith(PACKAGE_NAME_PREFIX),
-        `Unexpected package name for packages/${dirName}: ${packageName}`,
-      ).toBe(true);
-      expect(
-        packageJson.scripts?.typecheck,
-        `Missing typecheck script in packages/${dirName}`,
-      ).toBeDefined();
-      expect(
-        packageJson.scripts?.typecheck?.includes('tsc --noEmit'),
-        `Typecheck script must run tsc --noEmit in packages/${dirName}`,
-      ).toBe(true);
-    }
-  });
-});
diff --git a/packages/kernel/src/workspace.test.ts b/packages/kernel/src/workspace.test.ts
index 3e598f8..d8f1907 100644
--- a/packages/kernel/src/workspace.test.ts
+++ b/packages/kernel/src/workspace.test.ts
@@ -26,8 +26,6 @@ describe('workspace init', () => {
     expect(fs.existsSync(path.join(workspacePath, 'threads'))).toBe(true);
     expect(fs.existsSync(path.join(workspacePath, 'spaces'))).toBe(true);
     expect(fs.existsSync(path.join(workspacePath, 'agents'))).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, 'skills'))).toBe(true);
-    expect(fs.existsSync(path.join(workspacePath, 'onboarding'))).toBe(true);
     expect(fs.existsSync(path.join(workspacePath, 'README.md'))).toBe(true);
     expect(fs.existsSync(path.join(workspacePath, 'QUICKSTART.md'))).toBe(true);
     expect(fs.existsSync(path.join(workspacePath, '.workgraph/server.json'))).toBe(true);
diff --git a/packages/kernel/src/workspace.ts b/packages/kernel/src/workspace.ts
index e54908e..82716c8 100644
--- a/packages/kernel/src/workspace.ts
+++ b/packages/kernel/src/workspace.ts
@@ -211,7 +211,7 @@ workgraph agent request agent-1 -w "${input.workspacePath}" --role roles/admin.m
 workgraph agent review agent-1 -w "${input.workspacePath}" --decision approved --actor admin-approver
 \`\`\`
 
-Bootstrap fallback (legacy/hybrid migration mode):
+Bootstrap trust-token flow:
 
 \`\`\`bash
 workgraph agent register agent-1 -w "${input.workspacePath}" --token ${input.bootstrapTrustToken}
diff --git a/packages/kernel/tsconfig.json b/packages/kernel/tsconfig.json
index be0cbf8..7504297 100644
--- a/packages/kernel/tsconfig.json
+++ b/packages/kernel/tsconfig.json
@@ -5,11 +5,24 @@
     "noEmit": true
   },
   "include": [
-    "src/**/*",
-    "../adapter-claude-code/src/**/*",
-    "../adapter-cursor-cloud/src/**/*",
-    "../adapter-http-webhook/src/**/*",
-    "../adapter-shell-worker/src/**/*",
-    "../../tests/helpers/cli-build.ts"
+    "src/**/*"
+  ],
+  "exclude": [
+    "src/adapter-*.ts",
+    "src/*dispatch*.ts",
+    "src/dispatch/**/*.ts",
+    "src/*trigger*.ts",
+    "src/*autonomy*.ts",
+    "src/*mission*.ts",
+    "src/*federation*.ts",
+    "src/*swarm*.ts",
+    "src/*cursor-bridge*.ts",
+    "src/*integration*.ts",
+    "src/*skill*.ts",
+    "src/*onboard*.ts",
+    "src/*clawdapus*.ts",
+    "src/search-qmd-adapter*.ts",
+    "src/transport/**/*",
+    "src/projections/**/*"
   ]
 }
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index b5b88d2..750408d 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -9,7 +9,7 @@
   "main": "src/index.ts",
   "types": "src/index.ts",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.4",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "@versatly/workgraph-kernel": "workspace:*",
     "zod": "^4.3.6"
   }
diff --git a/packages/mcp-server/src/federation-tools.test.ts b/packages/mcp-server/src/federation-tools.test.ts
deleted file mode 100644
index d88d2ab..0000000
--- a/packages/mcp-server/src/federation-tools.test.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import {
-  federation as federationModule,
-  registry as registryModule,
-  thread as threadModule,
-} from '@versatly/workgraph-kernel';
-import { createWorkgraphMcpServer } from './mcp-server.js';
-
-const federation = federationModule;
-const registry = registryModule;
-const thread = threadModule;
-
-let workspacePath: string;
-let remoteWorkspacePath: string;
-
-describe('federation MCP tools', () => {
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-federation-'));
-    remoteWorkspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-federation-remote-'));
-    registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
-    registry.saveRegistry(remoteWorkspacePath, registry.loadRegistry(remoteWorkspacePath));
-  });
-
-  afterEach(() => {
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-    fs.rmSync(remoteWorkspacePath, { recursive: true, force: true });
-  });
-
-  it('reports federation status, resolves refs, and searches remote workspaces', async () => {
-    const localThread = thread.createThread(workspacePath, 'Local thread', 'Coordinate remote work', 'agent-local');
-    const remoteThread = thread.createThread(remoteWorkspacePath, 'Remote auth thread', 'Build auth dashboard', 'agent-remote');
-    federation.ensureFederationConfig(remoteWorkspacePath);
-    federation.addRemoteWorkspace(workspacePath, {
-      id: 'remote-main',
-      path: remoteWorkspacePath,
-      name: 'Remote Main',
-    });
-    const linked = federation.linkThreadToRemoteWorkspace(
-      workspacePath,
-      localThread.path,
-      'remote-main',
-      remoteThread.path,
-      'agent-local',
-    );
-
-    const server = createWorkgraphMcpServer({
-      workspacePath,
-      defaultActor: 'agent-mcp',
-    });
-    const client = new Client({
-      name: 'workgraph-mcp-federation-client',
-      version: '1.0.0',
-    });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    await Promise.all([
-      server.connect(serverTransport),
-      client.connect(clientTransport),
-    ]);
-
-    try {
-      const tools = await client.listTools();
-      const toolNames = tools.tools.map((entry) => entry.name);
-      expect(toolNames).toContain('wg_federation_status');
-      expect(toolNames).toContain('wg_federation_resolve_ref');
-      expect(toolNames).toContain('wg_federation_search');
-
-      const statusResult = await client.callTool({
-        name: 'wg_federation_status',
-        arguments: {},
-      });
-      expect(isToolError(statusResult)).toBe(false);
-      const statusPayload = getStructured<{ workspace: { workspaceId: string }; remotes: Array<{ remote: { id: string } }> }>(statusResult);
-      expect(statusPayload.workspace.workspaceId).toMatch(/^[0-9a-f-]{36}$/);
-      expect(statusPayload.remotes[0]?.remote.id).toBe('remote-main');
-
-      const resolveResult = await client.callTool({
-        name: 'wg_federation_resolve_ref',
-        arguments: {
-          ref: linked.ref,
-        },
-      });
-      expect(isToolError(resolveResult)).toBe(false);
-      const resolvePayload = getStructured<{ source: string; authority: string; instance: { path: string } }>(resolveResult);
-      expect(resolvePayload.source).toBe('remote');
-      expect(resolvePayload.authority).toBe('remote');
-      expect(resolvePayload.instance.path).toBe(remoteThread.path);
-
-      const searchResult = await client.callTool({
-        name: 'wg_federation_search',
-        arguments: {
-          query: 'auth',
-          type: 'thread',
-          includeLocal: true,
-        },
-      });
-      expect(isToolError(searchResult)).toBe(false);
-      const searchPayload = getStructured<{ results: Array<{ workspaceId: string; instance: { path: string } }> }>(searchResult);
-      expect(searchPayload.results.some((entry) => entry.workspaceId === 'remote-main' && entry.instance.path === remoteThread.path)).toBe(true);
-    } finally {
-      await client.close();
-      await server.close();
-    }
-  });
-});
-
-function getStructured<T>(result: unknown): T {
-  if (!result || typeof result !== 'object' || !('structuredContent' in result)) {
-    throw new Error('Expected structuredContent in MCP tool response.');
-  }
-  const typed = result as { structuredContent?: unknown };
-  if (!typed.structuredContent) {
-    throw new Error('Expected structuredContent in MCP tool response.');
-  }
-  return typed.structuredContent as T;
-}
-
-function isToolError(result: unknown): boolean {
-  return Boolean(result && typeof result === 'object' && 'isError' in result && (result as { isError?: boolean }).isError);
-}
diff --git a/packages/mcp-server/src/index.ts b/packages/mcp-server/src/index.ts
index 82d7ff6..bbad226 100644
--- a/packages/mcp-server/src/index.ts
+++ b/packages/mcp-server/src/index.ts
@@ -1,2 +1,4 @@
 export * from './mcp-server.js';
 export * from './mcp-http-server.js';
+export * from './mcp/types.js';
+export * from './mcp/result.js';
diff --git a/packages/mcp-server/src/mcp-http-server.test.ts b/packages/mcp-server/src/mcp-http-server.test.ts
index 040b0b6..cd51428 100644
--- a/packages/mcp-server/src/mcp-http-server.test.ts
+++ b/packages/mcp-server/src/mcp-http-server.test.ts
@@ -7,7 +7,6 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import {
   agent as agentModule,
   registry as registryModule,
-  policy as policyModule,
   thread as threadModule,
   workspace as workspaceModule,
 } from '@versatly/workgraph-kernel';
@@ -15,36 +14,37 @@ import { startWorkgraphMcpHttpServer } from './mcp-http-server.js';
 
 const agent = agentModule;
 const registry = registryModule;
-const policy = policyModule;
 const thread = threadModule;
 const workspace = workspaceModule;
 
 let workspacePath: string;
 
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-http-'));
-  const schemaRegistry = registry.loadRegistry(workspacePath);
-  registry.saveRegistry(workspacePath, schemaRegistry);
-});
+describe('mcp http server', () => {
+  beforeEach(() => {
+    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-http-'));
+    registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
+  });
 
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
+  afterEach(() => {
+    fs.rmSync(workspacePath, { recursive: true, force: true });
+  });
 
-describe('mcp streamable http server', () => {
-  it('serves MCP tools over HTTP with bearer token auth', async () => {
-    policy.upsertParty(workspacePath, 'http-operator', {
-      roles: ['operator'],
-      capabilities: ['mcp:write', 'thread:claim', 'thread:done', 'dispatch:run'],
+  it('serves retained tools over streamable http with bearer auth', async () => {
+    const init = workspace.initWorkspace(workspacePath, { createReadme: false, createBases: false });
+    const registration = agent.registerAgent(workspacePath, 'http-admin', {
+      token: init.bootstrapTrustToken,
+      role: 'roles/admin.md',
+      capabilities: ['mcp:write', 'thread:create', 'thread:claim', 'thread:update', 'thread:complete'],
+      actor: 'http-admin',
     });
-    thread.createThread(workspacePath, 'HTTP MCP task', 'Execute via MCP HTTP', 'seed', { priority: 'high' });
+    thread.createThread(workspacePath, 'HTTP thread', 'Exercise MCP HTTP', 'http-admin');
 
     const handle = await startWorkgraphMcpHttpServer({
       workspacePath,
-      defaultActor: 'http-operator',
+      defaultActor: 'http-admin',
       host: '127.0.0.1',
       port: 0,
-      bearerToken: 'secret-token',
+      bearerToken: 'gateway-token',
     });
 
     const client = new Client({
@@ -54,7 +54,7 @@ describe('mcp streamable http server', () => {
     const transport = new StreamableHTTPClientTransport(new URL(handle.url), {
       requestInit: {
         headers: {
-          authorization: 'Bearer secret-token',
+          authorization: `Bearer ${registration.apiKey}`,
         },
       },
     });
@@ -63,49 +63,26 @@ describe('mcp streamable http server', () => {
     try {
       const tools = await client.listTools();
       expect(tools.tools.some((tool) => tool.name === 'workgraph_status')).toBe(true);
-      expect(tools.tools.some((tool) => tool.name === 'workgraph_company_context')).toBe(true);
+      expect(tools.tools.some((tool) => tool.name === 'wg_post_message')).toBe(true);
 
-      const status = await client.callTool({
-        name: 'workgraph_status',
-        arguments: {},
-      });
+      const status = await client.callTool({ name: 'workgraph_status', arguments: {} });
       expect(isToolError(status)).toBe(false);
 
-      const companyContext = await client.callTool({
-        name: 'workgraph_company_context',
-        arguments: {
-          actor: 'http-operator',
-        },
-      });
-      expect(isToolError(companyContext)).toBe(false);
-
-      const runCreated = await client.callTool({
-        name: 'workgraph_dispatch_create',
-        arguments: {
-          actor: 'http-operator',
-          objective: 'HTTP MCP run',
-        },
-      });
-      const runId = extractStructured<{ run: { id: string } }>(runCreated).run.id;
-      const runExecuted = await client.callTool({
-        name: 'workgraph_dispatch_execute',
+      const claimed = await client.callTool({
+        name: 'workgraph_thread_claim',
         arguments: {
-          actor: 'http-operator',
-          runId,
-          agents: ['http-agent-1', 'http-agent-2'],
-          maxSteps: 30,
-          stepDelayMs: 0,
+          actor: 'http-admin',
+          threadPath: 'threads/http-thread.md',
         },
       });
-      const executed = extractStructured<{ run: { status: string } }>(runExecuted);
-      expect(executed.run.status).toBe('succeeded');
+      expect(isToolError(claimed)).toBe(false);
     } finally {
       await client.close();
       await handle.close();
     }
   });
 
-  it('accepts wildcard Accept and handles stateless follow-up requests', async () => {
+  it('accepts wildcard accept headers during initialization', async () => {
     const handle = await startWorkgraphMcpHttpServer({
       workspacePath,
       defaultActor: 'system',
@@ -115,19 +92,6 @@ describe('mcp streamable http server', () => {
 
     try {
       const initializeResponse = await fetch(handle.url, {
-        method: 'POST',
-        headers: {
-          accept: '*/*',
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify(createInitializeRequest(1)),
-      });
-      expect(initializeResponse.status).toBe(200);
-      const initializePayload = parseMcpHttpResponse(await initializeResponse.text());
-      expect(initializePayload?.result?.serverInfo?.name).toBeTruthy();
-      expect(initializeResponse.headers.get('mcp-session-id')).toBeTruthy();
-
-      const toolsResponse = await fetch(handle.url, {
         method: 'POST',
         headers: {
           accept: '*/*',
@@ -135,204 +99,27 @@ describe('mcp streamable http server', () => {
         },
         body: JSON.stringify({
           jsonrpc: '2.0',
-          id: 2,
-          method: 'tools/list',
-          params: {},
+          id: 1,
+          method: 'initialize',
+          params: {
+            protocolVersion: '2025-03-26',
+            capabilities: {},
+            clientInfo: {
+              name: 'workgraph-http-client',
+              version: '1.0.0',
+            },
+          },
         }),
       });
-      expect(toolsResponse.status).toBe(200);
-      const toolsPayload = parseMcpHttpResponse(await toolsResponse.text());
-      expect(Array.isArray(toolsPayload?.result?.tools)).toBe(true);
-    } finally {
-      await handle.close();
-    }
-  });
-
-  it('enforces strict credential identity for MCP write tools', async () => {
-    const init = workspace.initWorkspace(workspacePath, { createReadme: false, createBases: false });
-    const registration = agent.registerAgent(workspacePath, 'mcp-admin', {
-      token: init.bootstrapTrustToken,
-      capabilities: ['mcp:write', 'thread:claim', 'thread:done', 'dispatch:run', 'agent:approve-registration'],
-    });
-    expect(registration.apiKey).toBeDefined();
-    policy.upsertParty(workspacePath, 'mcp-admin', {
-      roles: ['admin'],
-      capabilities: ['mcp:write', 'thread:claim', 'thread:done', 'dispatch:run', 'agent:approve-registration'],
-    }, {
-      actor: 'mcp-admin',
-      skipAuthorization: true,
-    });
-    thread.createThread(workspacePath, 'Strict MCP thread', 'Strict credential enforcement', 'seed');
-
-    const serverConfigPath = path.join(workspacePath, '.workgraph', 'server.json');
-    const serverConfig = JSON.parse(fs.readFileSync(serverConfigPath, 'utf-8')) as Record<string, unknown>;
-    serverConfig.auth = {
-      mode: 'strict',
-      allowUnauthenticatedFallback: false,
-    };
-    fs.writeFileSync(serverConfigPath, `${JSON.stringify(serverConfig, null, 2)}\n`, 'utf-8');
-
-    const handle = await startWorkgraphMcpHttpServer({
-      workspacePath,
-      defaultActor: 'system',
-      host: '127.0.0.1',
-      port: 0,
-    });
-    const authClient = new Client({
-      name: 'workgraph-mcp-http-strict-auth-client',
-      version: '1.0.0',
-    });
-    const authTransport = new StreamableHTTPClientTransport(new URL(handle.url), {
-      requestInit: {
-        headers: {
-          authorization: `Bearer ${registration.apiKey}`,
-        },
-      },
-    });
-    const anonymousClient = new Client({
-      name: 'workgraph-mcp-http-strict-anon-client',
-      version: '1.0.0',
-    });
-    const anonymousTransport = new StreamableHTTPClientTransport(new URL(handle.url), {
-      requestInit: {
-        headers: {},
-      },
-    });
-
-    await authClient.connect(authTransport);
-    await anonymousClient.connect(anonymousTransport);
-    try {
-      const spoofed = await authClient.callTool({
-        name: 'workgraph_thread_claim',
-        arguments: {
-          threadPath: 'threads/strict-mcp-thread.md',
-          actor: 'spoofed-actor',
-        },
-      });
-      expect(isToolError(spoofed)).toBe(true);
-
-      const claimed = await authClient.callTool({
-        name: 'workgraph_thread_claim',
-        arguments: {
-          threadPath: 'threads/strict-mcp-thread.md',
-          actor: 'mcp-admin',
-        },
-      });
-      expect(isToolError(claimed)).toBe(false);
-
-      const noCredentialWrite = await anonymousClient.callTool({
-        name: 'workgraph_dispatch_create',
-        arguments: {
-          objective: 'strict mode should deny anonymous mutation',
-        },
-      });
-      expect(isToolError(noCredentialWrite)).toBe(true);
-    } finally {
-      await authClient.close();
-      await anonymousClient.close();
-      await handle.close();
-    }
-  });
-
-  it('accepts x-api-key header for MCP auth', async () => {
-    const init = workspace.initWorkspace(workspacePath, { createReadme: false, createBases: false });
-    const registration = agent.registerAgent(workspacePath, 'mcp-admin', {
-      token: init.bootstrapTrustToken,
-      capabilities: ['mcp:write', 'thread:claim', 'thread:done', 'dispatch:run', 'agent:approve-registration'],
-    });
-    expect(registration.apiKey).toBeDefined();
-    policy.upsertParty(workspacePath, 'mcp-admin', {
-      roles: ['admin'],
-      capabilities: ['mcp:write', 'thread:claim', 'thread:done', 'dispatch:run', 'agent:approve-registration'],
-    }, {
-      actor: 'mcp-admin',
-      skipAuthorization: true,
-    });
-    thread.createThread(workspacePath, 'x-api-key thread', 'x-api-key auth', 'seed');
-
-    const serverConfigPath = path.join(workspacePath, '.workgraph', 'server.json');
-    const serverConfig = JSON.parse(fs.readFileSync(serverConfigPath, 'utf-8')) as Record<string, unknown>;
-    serverConfig.auth = {
-      mode: 'strict',
-      allowUnauthenticatedFallback: false,
-    };
-    fs.writeFileSync(serverConfigPath, `${JSON.stringify(serverConfig, null, 2)}\n`, 'utf-8');
-
-    const handle = await startWorkgraphMcpHttpServer({
-      workspacePath,
-      defaultActor: 'system',
-      host: '127.0.0.1',
-      port: 0,
-      bearerToken: 'gateway-token',
-    });
-    const client = new Client({
-      name: 'workgraph-mcp-http-x-api-key-client',
-      version: '1.0.0',
-    });
-    const transport = new StreamableHTTPClientTransport(new URL(handle.url), {
-      requestInit: {
-        headers: {
-          'x-api-key': registration.apiKey,
-        },
-      },
-    });
 
-    await client.connect(transport);
-    try {
-      const claim = await client.callTool({
-        name: 'workgraph_thread_claim',
-        arguments: {
-          threadPath: 'threads/x-api-key-thread.md',
-          actor: 'mcp-admin',
-        },
-      });
-      expect(isToolError(claim)).toBe(false);
+      expect(initializeResponse.status).toBe(200);
+      expect(initializeResponse.headers.get('mcp-session-id')).toBeTruthy();
     } finally {
-      await client.close();
       await handle.close();
     }
   });
 });
 
-function extractStructured<T>(result: unknown): T {
-  if (!result || typeof result !== 'object' || !('structuredContent' in result)) {
-    throw new Error('Expected structuredContent in MCP result.');
-  }
-  return (result as { structuredContent: T }).structuredContent;
-}
-
 function isToolError(result: unknown): boolean {
-  if (!result || typeof result !== 'object') return false;
-  if (!('isError' in result)) return false;
-  return (result as { isError?: boolean }).isError === true;
-}
-
-function createInitializeRequest(id: number): Record<string, unknown> {
-  return {
-    jsonrpc: '2.0',
-    id,
-    method: 'initialize',
-    params: {
-      protocolVersion: '2025-03-26',
-      capabilities: {},
-      clientInfo: {
-        name: 'workgraph-http-compat-client',
-        version: '1.0.0',
-      },
-    },
-  };
-}
-
-function parseMcpHttpResponse(body: string): any {
-  const trimmed = body.trim();
-  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-    return JSON.parse(trimmed);
-  }
-  for (const line of body.split('\n')) {
-    if (!line.startsWith('data:')) continue;
-    const payload = line.slice('data:'.length).trim();
-    if (!payload) continue;
-    return JSON.parse(payload);
-  }
-  throw new Error(`Unable to parse MCP HTTP response body: ${body}`);
+  return Boolean(result && typeof result === 'object' && 'isError' in result && (result as { isError?: boolean }).isError);
 }
diff --git a/packages/mcp-server/src/mcp-server.test.ts b/packages/mcp-server/src/mcp-server.test.ts
index fc947cf..9646824 100644
--- a/packages/mcp-server/src/mcp-server.test.ts
+++ b/packages/mcp-server/src/mcp-server.test.ts
@@ -1,26 +1,31 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
 import {
-  registry as registryModule,
   policy as policyModule,
+  registry as registryModule,
   thread as threadModule,
+  workspace as workspaceModule,
 } from '@versatly/workgraph-kernel';
 import { createWorkgraphMcpServer } from './mcp-server.js';
 
-const registry = registryModule;
 const policy = policyModule;
+const registry = registryModule;
 const thread = threadModule;
+const workspace = workspaceModule;
 
 let workspacePath: string;
 
 beforeEach(() => {
   workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-server-'));
-  const schemaRegistry = registry.loadRegistry(workspacePath);
-  registry.saveRegistry(workspacePath, schemaRegistry);
+  workspace.initWorkspace(workspacePath, {
+    createReadme: false,
+    createBases: false,
+  });
+  registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
 });
 
 afterEach(() => {
@@ -28,377 +33,10 @@ afterEach(() => {
 });
 
 describe('workgraph mcp server', () => {
-  it('exposes read tools/resources and enforces policy-scoped write tools', async () => {
-    const coordinationThread = thread.createThread(
-      workspacePath,
-      'MCP task',
-      'Validate MCP write path',
-      'agent-seed',
-      { priority: 'high' },
-    );
-    thread.createThread(
-      workspacePath,
-      'MCP follow-up',
-      'Validate dispatch execute path',
-      'agent-seed',
-      { priority: 'medium', deps: [coordinationThread.path] },
-    );
-
-    const server = createWorkgraphMcpServer({
-      workspacePath,
-      defaultActor: 'agent-mcp',
-    });
-    const client = new Client({
-      name: 'workgraph-mcp-test-client',
-      version: '1.0.0',
-    });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-
-    await Promise.all([
-      server.connect(serverTransport),
-      client.connect(clientTransport),
-    ]);
-
-    try {
-      const tools = await client.listTools();
-      const toolNames = tools.tools.map((entry) => entry.name);
-      expect(toolNames).toContain('workgraph_status');
-      expect(toolNames).toContain('workgraph_company_context');
-      expect(toolNames).toContain('workgraph_primitive_schema');
-      expect(toolNames).toContain('workgraph_ledger_reconcile');
-      expect(toolNames).toContain('workgraph_thread_create');
-      expect(toolNames).toContain('workgraph_thread_claim');
-      expect(toolNames).toContain('workgraph_thread_block');
-      expect(toolNames).toContain('workgraph_thread_unblock');
-      expect(toolNames).toContain('workgraph_thread_handoff');
-      expect(toolNames).toContain('workgraph_thread_release');
-      expect(toolNames).toContain('workgraph_thread_heartbeat');
-      expect(toolNames).toContain('workgraph_thread_join');
-      expect(toolNames).toContain('workgraph_dispatch_execute');
-      expect(toolNames).toContain('workgraph_trigger_create');
-      expect(toolNames).toContain('workgraph_trigger_fire');
-      expect(toolNames).toContain('workgraph_create_decision');
-      expect(toolNames).toContain('workgraph_record_lesson');
-      expect(toolNames).toContain('workgraph_record_pattern');
-      expect(toolNames).toContain('workgraph_create_mission');
-      expect(toolNames).toContain('workgraph_mission_status');
-
-      const statusTool = await client.callTool({
-        name: 'workgraph_status',
-        arguments: {},
-      });
-      expect('isError' in statusTool && statusTool.isError).toBeFalsy();
-      const statusPayload = getStructured<{ threads: { total: number } }>(statusTool);
-      expect(statusPayload.threads.total).toBeGreaterThan(0);
-
-      const companyContextResult = await client.callTool({
-        name: 'workgraph_company_context',
-        arguments: {
-          actor: 'agent-mcp',
-        },
-      });
-      expect(isToolError(companyContextResult)).toBe(false);
-      const companyContextPayload = getStructured<{
-        teams: unknown[];
-        clients: unknown[];
-        recentDecisions: unknown[];
-        patterns: unknown[];
-      }>(companyContextResult);
-      expect(Array.isArray(companyContextPayload.teams)).toBe(true);
-      expect(Array.isArray(companyContextPayload.clients)).toBe(true);
-      expect(Array.isArray(companyContextPayload.recentDecisions)).toBe(true);
-      expect(Array.isArray(companyContextPayload.patterns)).toBe(true);
-
-      const statusResource = await client.readResource({ uri: 'workgraph://status' });
-      const firstContent = statusResource.contents[0];
-      const statusText = firstContent && 'text' in firstContent ? firstContent.text : '';
-      expect(statusText).toContain('"threads"');
-
-      const schemaResult = await client.callTool({
-        name: 'workgraph_primitive_schema',
-        arguments: {
-          typeName: 'thread',
-        },
-      });
-      expect(isToolError(schemaResult)).toBe(false);
-      const schemaPayload = getStructured<{ type: string; fields: Array<{ name: string }> }>(schemaResult);
-      expect(schemaPayload.type).toBe('thread');
-      expect(schemaPayload.fields.some((field) => field.name === 'goal')).toBe(true);
-
-      const reconcileResult = await client.callTool({
-        name: 'workgraph_ledger_reconcile',
-        arguments: {},
-      });
-      expect(isToolError(reconcileResult)).toBe(false);
-      const reconcilePayload = getStructured<{ totalThreads: number; issues: unknown[] }>(reconcileResult);
-      expect(reconcilePayload.totalThreads).toBeGreaterThan(0);
-
-      const blockedWrite = await client.callTool({
-        name: 'workgraph_thread_claim',
-        arguments: {
-          threadPath: coordinationThread.path,
-          actor: 'agent-mcp',
-        },
-      });
-      expect(isToolError(blockedWrite)).toBe(true);
-
-      policy.upsertParty(workspacePath, 'agent-mcp', {
-        roles: ['operator'],
-        capabilities: [
-          'mcp:write',
-          'thread:create',
-          'thread:update',
-          'thread:claim',
-          'thread:done',
-          'dispatch:run',
-          'policy:manage',
-          'promote:trigger',
-        ],
-      });
-
-      const createdDecision = await client.callTool({
-        name: 'workgraph_create_decision',
-        arguments: {
-          title: 'Adopt company context graph',
-          actor: 'agent-mcp',
-          rationale: 'Improve organizational context quality for autonomous agents.',
-          participants: ['agent-mcp', 'agent-mcp-2'],
-          alternatives: ['Keep ad-hoc context notes'],
-        },
-      });
-      expect(isToolError(createdDecision)).toBe(false);
-      const decisionPayload = getStructured<{ decision: { path: string; fields: { title: string } } }>(createdDecision);
-      expect(decisionPayload.decision.path).toMatch(/^decisions\//);
-      expect(decisionPayload.decision.fields.title).toBe('Adopt company context graph');
-
-      const recordedLesson = await client.callTool({
-        name: 'workgraph_record_lesson',
-        arguments: {
-          title: 'Track decisions with explicit rationale',
-          actor: 'agent-mcp',
-          severity: 'important',
-          sourceEvent: 'postmortem-2026-03-14',
-        },
-      });
-      expect(isToolError(recordedLesson)).toBe(false);
-      const lessonPayload = getStructured<{ lesson: { path: string; fields: { severity: string } } }>(recordedLesson);
-      expect(lessonPayload.lesson.path).toMatch(/^lessons\//);
-      expect(lessonPayload.lesson.fields.severity).toBe('important');
-
-      const recordedPattern = await client.callTool({
-        name: 'workgraph_record_pattern',
-        arguments: {
-          title: 'Decision preflight checklist',
-          actor: 'agent-mcp',
-          steps: ['Gather stakeholders', 'Capture alternatives', 'Record rationale'],
-          exceptions: ['Emergency incident response'],
-        },
-      });
-      expect(isToolError(recordedPattern)).toBe(false);
-      const patternPayload = getStructured<{ pattern: { path: string; fields: { title: string } } }>(recordedPattern);
-      expect(patternPayload.pattern.path).toMatch(/^patterns\//);
-      expect(patternPayload.pattern.fields.title).toBe('Decision preflight checklist');
-
-      const companyContextAfterWrites = await client.callTool({
-        name: 'workgraph_company_context',
-        arguments: {
-          actor: 'agent-mcp',
-        },
-      });
-      expect(isToolError(companyContextAfterWrites)).toBe(false);
-      const contextAfterWritesPayload = getStructured<{
-        recentDecisions: Array<{ title: string }>;
-        patterns: Array<{ title: string }>;
-      }>(companyContextAfterWrites);
-      expect(contextAfterWritesPayload.recentDecisions.some((entry) => entry.title === 'Adopt company context graph')).toBe(true);
-      expect(contextAfterWritesPayload.patterns.some((entry) => entry.title === 'Decision preflight checklist')).toBe(true);
-
-      const created = await client.callTool({
-        name: 'workgraph_thread_create',
-        arguments: {
-          title: 'MCP lifecycle thread',
-          goal: 'Validate full MCP thread lifecycle operations.',
-          actor: 'agent-mcp',
-          priority: 'high',
-          tags: ['mcp'],
-        },
-      });
-      expect(isToolError(created)).toBe(false);
-      const createdPayload = getStructured<{
-        thread: { path: string };
-      }>(created);
-
-      const joined = await client.callTool({
-        name: 'workgraph_thread_join',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          role: 'participant',
-        },
-      });
-      expect(isToolError(joined)).toBe(false);
-
-      const claimed = await client.callTool({
-        name: 'workgraph_thread_claim',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-        },
-      });
-      expect(isToolError(claimed)).toBe(false);
-      const claimedPayload = getStructured<{
-        thread: { path: string };
-        context: { threadPath: string; totalEntries: number };
-      }>(claimed);
-      expect(claimedPayload.thread.path).toBe(createdPayload.thread.path);
-      expect(claimedPayload.context.threadPath).toBe(createdPayload.thread.path);
-      expect(claimedPayload.context.totalEntries).toBe(0);
-
-      const heartbeat = await client.callTool({
-        name: 'workgraph_thread_heartbeat',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          note: 'Still in progress',
-        },
-      });
-      expect(isToolError(heartbeat)).toBe(false);
-
-      const blocked = await client.callTool({
-        name: 'workgraph_thread_block',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          reason: 'Waiting for dependency confirmation',
-        },
-      });
-      expect(isToolError(blocked)).toBe(false);
-      const blockedPayload = getStructured<{ thread: { fields: { status: string } } }>(blocked);
-      expect(blockedPayload.thread.fields.status).toBe('blocked');
-
-      const unblocked = await client.callTool({
-        name: 'workgraph_thread_unblock',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          reason: 'Dependency resolved',
-        },
-      });
-      expect(isToolError(unblocked)).toBe(false);
-      const unblockedPayload = getStructured<{ thread: { fields: { status: string } } }>(unblocked);
-      expect(unblockedPayload.thread.fields.status).toBe('active');
-
-      const handedOff = await client.callTool({
-        name: 'workgraph_thread_handoff',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          toActor: 'agent-mcp',
-          reason: 'No-op handoff for MCP coverage',
-        },
-      });
-      expect(isToolError(handedOff)).toBe(false);
-
-      const released = await client.callTool({
-        name: 'workgraph_thread_release',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          reason: 'Ready for final completion',
-        },
-      });
-      expect(isToolError(released)).toBe(false);
-      const releasedPayload = getStructured<{ thread: { fields: { status: string } } }>(released);
-      expect(releasedPayload.thread.fields.status).toBe('open');
-
-      const reclaimed = await client.callTool({
-        name: 'workgraph_thread_claim',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-        },
-      });
-      expect(isToolError(reclaimed)).toBe(false);
-
-      const done = await client.callTool({
-        name: 'workgraph_thread_done',
-        arguments: {
-          threadPath: createdPayload.thread.path,
-          actor: 'agent-mcp',
-          output: 'Completed from MCP write tool. https://github.com/versatly/workgraph/pull/72',
-          reason: 'Lifecycle complete',
-        },
-      });
-      expect(isToolError(done)).toBe(false);
-
-      const runCreated = await client.callTool({
-        name: 'workgraph_dispatch_create',
-        arguments: {
-          actor: 'agent-mcp',
-          objective: 'Execute pending threads from MCP',
-        },
-      });
-      const createdRunPayload = getStructured<{ run: { id: string } }>(runCreated);
-      expect(createdRunPayload.run.id).toMatch(/^run_/);
-
-      const runExecuted = await client.callTool({
-        name: 'workgraph_dispatch_execute',
-        arguments: {
-          actor: 'agent-mcp',
-          runId: createdRunPayload.run.id,
-          agents: ['agent-mcp-1', 'agent-mcp-2'],
-          maxSteps: 20,
-          stepDelayMs: 0,
-        },
-      });
-      expect(isToolError(runExecuted)).toBe(false);
-      const executedPayload = getStructured<{ run: { status: string } }>(runExecuted);
-      expect(executedPayload.run.status).toBe('succeeded');
-
-      const triggerCreated = await client.callTool({
-        name: 'workgraph_trigger_create',
-        arguments: {
-          actor: 'agent-mcp',
-          name: 'MCP manual trigger',
-          type: 'manual',
-          condition: { type: 'manual' },
-          action: {
-            type: 'dispatch-run',
-            objective: 'Run from MCP trigger for {{target}}',
-          },
-        },
-      });
-      expect(isToolError(triggerCreated)).toBe(false);
-      const triggerPayload = getStructured<{ trigger: { path: string } }>(triggerCreated);
-
-      const triggerFired = await client.callTool({
-        name: 'workgraph_trigger_fire',
-        arguments: {
-          actor: 'agent-mcp',
-          triggerRef: triggerPayload.trigger.path,
-          eventKey: 'mcp-trigger-evt-1',
-          context: {
-            target: 'coordination',
-          },
-          execute: true,
-          maxSteps: 10,
-          stepDelayMs: 0,
-        },
-      });
-      expect(isToolError(triggerFired)).toBe(false);
-      const firedPayload = getStructured<{ run: { status: string; objective: string } }>(triggerFired);
-      expect(firedPayload.run.status).toBe('succeeded');
-      expect(firedPayload.run.objective).toContain('coordination');
-    } finally {
-      await client.close();
-      await server.close();
-    }
-  });
-
-  it('exposes primitive tool coverage with context/graph/dispatch aliases', async () => {
+  it('exposes the retained tools and resources', async () => {
     policy.upsertParty(workspacePath, 'agent-mcp', {
       roles: ['operator'],
-      capabilities: ['mcp:write', 'thread:claim', 'thread:done', 'dispatch:run', 'policy:manage', 'promote:trigger'],
+      capabilities: ['mcp:write', 'thread:create', 'thread:update', 'thread:claim', 'thread:complete', 'agent:register'],
     });
 
     const server = createWorkgraphMcpServer({
@@ -406,7 +44,7 @@ describe('workgraph mcp server', () => {
       defaultActor: 'agent-mcp',
     });
     const client = new Client({
-      name: 'workgraph-mcp-test-client-tools',
+      name: 'workgraph-mcp-test-client',
       version: '1.0.0',
     });
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
@@ -419,17 +57,18 @@ describe('workgraph mcp server', () => {
     try {
       const tools = await client.listTools();
       const toolNames = new Set(tools.tools.map((entry) => entry.name));
-      // Core tools our MCP server exposes
-      const expectedTools = [
+      for (const toolName of [
         'workgraph_status',
         'workgraph_brief',
         'workgraph_company_context',
         'workgraph_query',
+        'workgraph_search',
+        'workgraph_lens_list',
+        'workgraph_lens_show',
         'workgraph_primitive_schema',
         'workgraph_thread_list',
         'workgraph_thread_show',
-        'workgraph_ledger_recent',
-        'workgraph_ledger_reconcile',
+        'workgraph_agent_list',
         'workgraph_graph_hygiene',
         'workgraph_thread_create',
         'workgraph_thread_claim',
@@ -441,26 +80,11 @@ describe('workgraph mcp server', () => {
         'workgraph_thread_join',
         'workgraph_thread_done',
         'workgraph_checkpoint_create',
-        'workgraph_create_decision',
-        'workgraph_record_lesson',
-        'workgraph_record_pattern',
-        'workgraph_dispatch_create',
-        'workgraph_dispatch_execute',
-        'workgraph_dispatch_followup',
-        'workgraph_dispatch_stop',
-        'workgraph_trigger_create',
-        'workgraph_trigger_update',
-        'workgraph_trigger_delete',
-        'workgraph_trigger_fire',
-        'workgraph_trigger_engine_cycle',
-        'workgraph_autonomy_run',
-        'workgraph_create_mission',
-        'workgraph_plan_mission',
-        'workgraph_approve_mission',
-        'workgraph_start_mission',
-        'workgraph_intervene_mission',
-        'workgraph_mission_status',
-        'workgraph_mission_progress',
+        'workgraph_agent_register',
+        'workgraph_agent_request_registration',
+        'workgraph_agent_list_registration_requests',
+        'workgraph_agent_review_registration',
+        'workgraph_agent_heartbeat',
         'wg_post_message',
         'wg_ask',
         'wg_create_thread',
@@ -470,32 +94,48 @@ describe('workgraph mcp server', () => {
         'wg_thread_context_list',
         'wg_thread_context_prune',
         'wg_heartbeat',
-      ];
-      for (const name of expectedTools) {
-        expect(toolNames.has(name)).toBe(true);
+      ]) {
+        expect(toolNames.has(toolName)).toBe(true);
       }
 
-      // Verify status tool works end-to-end
-      expect(toolNames.size).toBeGreaterThan(10);
+      const statusTool = await client.callTool({
+        name: 'workgraph_status',
+        arguments: {},
+      });
+      expect(isToolError(statusTool)).toBe(false);
+      const statusPayload = getStructured<{ threads: { total: number } }>(statusTool);
+      expect(statusPayload.threads.total).toBe(0);
+
+      const statusResource = await client.readResource({ uri: 'workgraph://status' });
+      const firstContent = statusResource.contents[0];
+      const statusText = firstContent && 'text' in firstContent ? firstContent.text : '';
+      expect(statusText).toContain('"threads"');
     } finally {
       await client.close();
       await server.close();
     }
   });
 
-  it('supports deterministic v2 collaboration tools with schema/auth/idempotency handling', async () => {
-    const parent = thread.createThread(
+  it('supports retained thread and collaboration flows end-to-end', async () => {
+    const initPolicy = policy.upsertParty(workspacePath, 'agent-mcp', {
+      roles: ['operator'],
+      capabilities: ['mcp:write', 'thread:create', 'thread:update', 'thread:claim', 'thread:complete', 'agent:register'],
+    });
+    expect(initPolicy.id).toBe('agent-mcp');
+
+    const seededThread = thread.createThread(
       workspacePath,
-      'Parent coordination',
-      'Coordinate collaboration flow',
-      'seed-agent',
+      'Parent collaboration thread',
+      'Coordinate MCP collaboration flow',
+      'agent-seed',
     );
+
     const server = createWorkgraphMcpServer({
       workspacePath,
-      defaultActor: 'agent-v2',
+      defaultActor: 'agent-mcp',
     });
     const client = new Client({
-      name: 'workgraph-mcp-test-client-v2',
+      name: 'workgraph-mcp-collaboration-client',
       version: '1.0.0',
     });
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
@@ -506,297 +146,193 @@ describe('workgraph mcp server', () => {
     ]);
 
     try {
-      let schemaRejected = false;
-      try {
-        const schemaResult = await client.callTool({
-          name: 'wg_post_message',
-          arguments: {
-            threadPath: parent.path,
-            body: 'should fail schema',
-            messageType: 'invalid-message-type',
-          },
-        });
-        schemaRejected = isToolError(schemaResult);
-      } catch {
-        schemaRejected = true;
-      }
-      expect(schemaRejected).toBe(true);
-
-      const denied = await client.callTool({
-        name: 'wg_post_message',
+      const created = await client.callTool({
+        name: 'workgraph_thread_create',
         arguments: {
-          threadPath: parent.path,
-          body: 'Auth denied message',
-          idempotencyKey: 'post-denied-key',
+          actor: 'agent-mcp',
+          title: 'MCP created thread',
+          goal: 'Validate retained MCP thread tools.',
+          priority: 'high',
+          tags: ['mcp'],
         },
       });
-      expect(isToolError(denied)).toBe(true);
-      const deniedPayload = getStructured<{ ok: boolean; error: { code: string } }>(denied);
-      expect(deniedPayload.ok).toBe(false);
-      expect(deniedPayload.error.code).toBe('POLICY_DENIED');
+      expect(isToolError(created)).toBe(false);
+      const createdPath = getStructured<{ thread: { path: string } }>(created).thread.path;
 
-      policy.upsertParty(workspacePath, 'agent-v2', {
-        roles: ['operator'],
-        capabilities: ['mcp:write', 'thread:update', 'thread:create', 'agent:heartbeat'],
+      const claimed = await client.callTool({
+        name: 'workgraph_thread_claim',
+        arguments: {
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+        },
       });
+      expect(isToolError(claimed)).toBe(false);
 
-      const posted = await client.callTool({
-        name: 'wg_post_message',
+      const contextAdded = await client.callTool({
+        name: 'wg_thread_context_add',
         arguments: {
-          threadPath: parent.path,
-          body: 'Coordination message',
-          messageType: 'message',
-          idempotencyKey: 'post-idem-key',
-          evidence: [
-            {
-              kind: 'link',
-              url: 'https://github.com/versatly/workgraph/pull/999',
-              title: 'PR evidence',
-            },
-          ],
-          metadata: {
-            source: 'test',
-            attempt: 1,
-          },
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+          title: 'Decision context',
+          content: 'Capture the key collaboration context for this thread.',
+          source: 'docs/context.md',
+          relevance: 0.8,
         },
       });
-      expect(isToolError(posted)).toBe(false);
-      const postedPayload = getStructured<{
-        ok: boolean;
-        data: { operation: string; event: { id: string } };
-      }>(posted);
-      expect(postedPayload.ok).toBe(true);
-      expect(postedPayload.data.operation).toBe('created');
+      expect(isToolError(contextAdded)).toBe(false);
 
-      const postReplay = await client.callTool({
-        name: 'wg_post_message',
+      const contextSearch = await client.callTool({
+        name: 'wg_thread_context_search',
         arguments: {
-          threadPath: parent.path,
-          body: 'Coordination message',
-          messageType: 'message',
-          idempotencyKey: 'post-idem-key',
-          evidence: [
-            {
-              kind: 'link',
-              url: 'https://github.com/versatly/workgraph/pull/999',
-              title: 'PR evidence',
-            },
-          ],
-          metadata: {
-            source: 'test',
-            attempt: 1,
-          },
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+          query: 'collaboration context',
+          limit: 5,
         },
       });
-      expect(isToolError(postReplay)).toBe(false);
-      const replayPayload = getStructured<{
-        data: { operation: string; event: { id: string } };
-      }>(postReplay);
-      expect(replayPayload.data.operation).toBe('replayed');
-      expect(replayPayload.data.event.id).toBe(postedPayload.data.event.id);
+      expect(isToolError(contextSearch)).toBe(false);
+      const contextPayload = getStructured<{ data: { count: number } }>(contextSearch);
+      expect(contextPayload.data.count).toBe(1);
 
-      const postConflict = await client.callTool({
+      const posted = await client.callTool({
         name: 'wg_post_message',
         arguments: {
-          threadPath: parent.path,
-          body: 'Changed body should conflict',
-          messageType: 'message',
-          idempotencyKey: 'post-idem-key',
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+          body: 'Coordination message from MCP.',
+          idempotencyKey: 'post-1',
         },
       });
-      expect(isToolError(postConflict)).toBe(true);
-      const conflictPayload = getStructured<{ ok: boolean; error: { code: string } }>(postConflict);
-      expect(conflictPayload.ok).toBe(false);
-      expect(conflictPayload.error.code).toBe('IDEMPOTENCY_CONFLICT');
-
-      const asked = await client.callTool({
-        name: 'wg_ask',
+      expect(isToolError(posted)).toBe(false);
+      const replayed = await client.callTool({
+        name: 'wg_post_message',
         arguments: {
-          threadPath: parent.path,
-          question: 'Can you provide a status update?',
-          idempotencyKey: 'ask-idem-key',
-          awaitReply: false,
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+          body: 'Coordination message from MCP.',
+          idempotencyKey: 'post-1',
         },
       });
-      expect(isToolError(asked)).toBe(false);
-      const askPayload = getStructured<{
-        data: {
-          operation: string;
-          status: string;
-          correlation_id: string;
-          ask: { id: string };
-        };
-      }>(asked);
-      expect(askPayload.data.operation).toBe('created');
-      expect(askPayload.data.status).toBe('pending');
+      expect(isToolError(replayed)).toBe(false);
+      const replayPayload = getStructured<{ data: { operation: string } }>(replayed);
+      expect(replayPayload.data.operation).toBe('replayed');
 
-      const askReplay = await client.callTool({
+      const asked = await client.callTool({
         name: 'wg_ask',
         arguments: {
-          threadPath: parent.path,
-          question: 'Can you provide a status update?',
-          idempotencyKey: 'ask-idem-key',
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+          question: 'Can you confirm the current status?',
+          idempotencyKey: 'ask-1',
           awaitReply: false,
         },
       });
-      expect(isToolError(askReplay)).toBe(false);
-      const askReplayPayload = getStructured<{
-        data: {
-          operation: string;
-          correlation_id: string;
-          ask: { id: string };
-        };
-      }>(askReplay);
-      expect(askReplayPayload.data.operation).toBe('replayed');
-      expect(askReplayPayload.data.correlation_id).toBe(askPayload.data.correlation_id);
-      expect(askReplayPayload.data.ask.id).toBe(askPayload.data.ask.id);
+      expect(isToolError(asked)).toBe(false);
 
       const spawned = await client.callTool({
         name: 'wg_spawn_thread',
         arguments: {
-          parentThreadPath: parent.path,
-          title: 'Child coordination task',
-          goal: 'Implement child flow',
-          idempotencyKey: 'spawn-idem-key',
-          tags: ['coordination'],
-          contextRefs: ['spaces/platform.md'],
+          actor: 'agent-mcp',
+          parentThreadPath: seededThread.path,
+          title: 'Spawned child thread',
+          goal: 'Handle a collaboration child task.',
+          idempotencyKey: 'spawn-1',
         },
       });
       expect(isToolError(spawned)).toBe(false);
-      const spawnedPayload = getStructured<{
-        data: { operation: string; thread: { path: string } };
-      }>(spawned);
-      expect(spawnedPayload.data.operation).toBe('created');
 
-      const spawnReplay = await client.callTool({
-        name: 'wg_spawn_thread',
+      const heartbeat = await client.callTool({
+        name: 'wg_heartbeat',
         arguments: {
-          parentThreadPath: parent.path,
-          title: 'Child coordination task',
-          goal: 'Implement child flow',
-          idempotencyKey: 'spawn-idem-key',
-          tags: ['coordination'],
-          contextRefs: ['spaces/platform.md'],
+          actor: 'agent-mcp',
+          status: 'busy',
+          currentWork: createdPath,
+          threadPath: createdPath,
+          threadLeaseMinutes: 10,
         },
       });
-      expect(isToolError(spawnReplay)).toBe(false);
-      const spawnReplayPayload = getStructured<{
-        data: { operation: string; thread: { path: string } };
-      }>(spawnReplay);
-      expect(spawnReplayPayload.data.operation).toBe('replayed');
-      expect(spawnReplayPayload.data.thread.path).toBe(spawnedPayload.data.thread.path);
+      expect(isToolError(heartbeat)).toBe(false);
 
-      const createdStandalone = await client.callTool({
-        name: 'wg_create_thread',
+      const done = await client.callTool({
+        name: 'workgraph_thread_done',
         arguments: {
-          title: 'Standalone MCP task',
-          goal: 'Create a top-level thread without parent',
-          idempotencyKey: 'create-idem-key',
-          priority: 'high',
-          tags: ['standalone'],
+          actor: 'agent-mcp',
+          threadPath: createdPath,
+          output: 'Finished via MCP https://github.com/versatly/workgraph/pull/999',
+          evidence: ['https://github.com/versatly/workgraph/pull/999'],
         },
       });
-      expect(isToolError(createdStandalone)).toBe(false);
-      const createdStandalonePayload = getStructured<{
-        data: { operation: string; thread: { path: string; parent: string | null } };
-      }>(createdStandalone);
-      expect(createdStandalonePayload.data.operation).toBe('created');
-      expect(createdStandalonePayload.data.thread.parent).toBeNull();
+      expect(isToolError(done)).toBe(false);
+    } finally {
+      await client.close();
+      await server.close();
+    }
+  });
 
-      const createReplay = await client.callTool({
-        name: 'wg_create_thread',
-        arguments: {
-          title: 'Standalone MCP task',
-          goal: 'Create a top-level thread without parent',
-          idempotencyKey: 'create-idem-key',
-          priority: 'high',
-          tags: ['standalone'],
-        },
-      });
-      expect(isToolError(createReplay)).toBe(false);
-      const createReplayPayload = getStructured<{
-        data: { operation: string; thread: { path: string } };
-      }>(createReplay);
-      expect(createReplayPayload.data.operation).toBe('replayed');
-      expect(createReplayPayload.data.thread.path).toBe(createdStandalonePayload.data.thread.path);
+  it('supports actor registration request and review tools', async () => {
+    policy.upsertParty(workspacePath, 'admin-reviewer', {
+      roles: ['admin'],
+      capabilities: ['mcp:write', 'agent:register', 'agent:approve-registration', 'policy:manage'],
+    }, {
+      actor: 'system',
+      skipAuthorization: true,
+    });
 
-      const contextAdded = await client.callTool({
-        name: 'wg_thread_context_add',
-        arguments: {
-          threadPath: createdStandalonePayload.data.thread.path,
-          title: 'Decision record',
-          content: 'Use delivery-id plus digest dedup in gateway.',
-          source: 'adr/2026-03-11',
-          relevance: 0.8,
-        },
-      });
-      expect(isToolError(contextAdded)).toBe(false);
+    const server = createWorkgraphMcpServer({
+      workspacePath,
+      defaultActor: 'admin-reviewer',
+    });
+    const client = new Client({
+      name: 'workgraph-mcp-registration-client',
+      version: '1.0.0',
+    });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
 
-      const contextList = await client.callTool({
-        name: 'wg_thread_context_list',
-        arguments: {
-          threadPath: createdStandalonePayload.data.thread.path,
-        },
-      });
-      expect(isToolError(contextList)).toBe(false);
-      const contextListPayload = getStructured<{
-        data: { count: number; entries: Array<{ title: string }> };
-      }>(contextList);
-      expect(contextListPayload.data.count).toBe(1);
-      expect(contextListPayload.data.entries[0]?.title).toBe('Decision record');
+    await Promise.all([
+      server.connect(serverTransport),
+      client.connect(clientTransport),
+    ]);
 
-      const contextSearch = await client.callTool({
-        name: 'wg_thread_context_search',
+    try {
+      const requested = await client.callTool({
+        name: 'workgraph_agent_request_registration',
         arguments: {
-          threadPath: createdStandalonePayload.data.thread.path,
-          query: 'delivery dedup',
-          limit: 5,
+          actor: 'candidate-agent',
+          name: 'candidate-agent',
+          role: 'roles/contributor.md',
+          capabilities: ['thread:create'],
+          note: 'Please approve me for collaboration work.',
         },
       });
-      expect(isToolError(contextSearch)).toBe(false);
-      const contextSearchPayload = getStructured<{
-        data: { count: number; results: Array<{ title: string; bm25_score: number }> };
-      }>(contextSearch);
-      expect(contextSearchPayload.data.count).toBe(1);
-      expect(contextSearchPayload.data.results[0]?.title).toBe('Decision record');
-      expect(contextSearchPayload.data.results[0]?.bm25_score ?? 0).toBeGreaterThan(0);
+      expect(isToolError(requested)).toBe(false);
+      const requestPath = getStructured<{ request: { path: string } }>(requested).request.path;
 
-      const contextPrune = await client.callTool({
-        name: 'wg_thread_context_prune',
+      const listed = await client.callTool({
+        name: 'workgraph_agent_list_registration_requests',
         arguments: {
-          threadPath: createdStandalonePayload.data.thread.path,
-          minRelevance: 0.9,
+          actor: 'admin-reviewer',
+          status: 'pending',
         },
       });
-      expect(isToolError(contextPrune)).toBe(false);
-      const contextPrunePayload = getStructured<{
-        data: { removed_count: number; kept_count: number };
-      }>(contextPrune);
-      expect(contextPrunePayload.data.removed_count).toBe(1);
-      expect(contextPrunePayload.data.kept_count).toBe(0);
+      expect(isToolError(listed)).toBe(false);
+      const listedPayload = getStructured<{ count: number }>(listed);
+      expect(listedPayload.count).toBe(1);
 
-      const heartbeatResult = await client.callTool({
-        name: 'wg_heartbeat',
+      const reviewed = await client.callTool({
+        name: 'workgraph_agent_review_registration',
         arguments: {
-          actor: 'agent-v2',
-          status: 'busy',
-          currentWork: parent.path,
-          threadPath: parent.path,
-          threadLeaseMinutes: 20,
+          actor: 'admin-reviewer',
+          requestRef: requestPath,
+          decision: 'approved',
+          role: 'roles/contributor.md',
+          capabilities: ['thread:create', 'thread:update'],
+          note: 'Approved for retained-scope collaboration work.',
         },
       });
-      expect(isToolError(heartbeatResult)).toBe(false);
-      const heartbeatPayload = getStructured<{
-        data: {
-          operation: string;
-          presence: { status: string };
-          threads: { touched: unknown[]; skipped: unknown[] };
-        };
-      }>(heartbeatResult);
-      expect(heartbeatPayload.data.operation).toBe('updated');
-      expect(heartbeatPayload.data.presence.status).toBe('busy');
-      expect(Array.isArray(heartbeatPayload.data.threads.touched)).toBe(true);
-      expect(Array.isArray(heartbeatPayload.data.threads.skipped)).toBe(true);
+      expect(isToolError(reviewed)).toBe(false);
+      const reviewPayload = getStructured<{ decision: string; request: { fields: { status: string } } }>(reviewed);
+      expect(reviewPayload.decision).toBe('approved');
+      expect(reviewPayload.request.fields.status).toBe('approved');
     } finally {
       await client.close();
       await server.close();
diff --git a/packages/mcp-server/src/mcp-server.ts b/packages/mcp-server/src/mcp-server.ts
index 2a855c3..5aad26f 100644
--- a/packages/mcp-server/src/mcp-server.ts
+++ b/packages/mcp-server/src/mcp-server.ts
@@ -1,24 +1,15 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { registerDefaultDispatchAdaptersIntoKernelRegistry } from '@versatly/workgraph-runtime-adapter-core';
 import { registerCollaborationTools } from './mcp/tools/collaboration-tools.js';
 import { registerResources } from './mcp/resources.js';
+import { type WorkgraphMcpServerOptions } from './mcp/types.js';
 import { registerReadTools } from './mcp/tools/read-tools.js';
 import { registerWriteTools } from './mcp/tools/write-tools.js';
 
 const DEFAULT_SERVER_NAME = 'workgraph-mcp-server';
 const DEFAULT_SERVER_VERSION = '0.1.0';
 
-export interface WorkgraphMcpServerOptions {
-  workspacePath: string;
-  defaultActor?: string;
-  readOnly?: boolean;
-  name?: string;
-  version?: string;
-}
-
 export function createWorkgraphMcpServer(options: WorkgraphMcpServerOptions): McpServer {
-  registerDefaultDispatchAdaptersIntoKernelRegistry();
   const server = new McpServer({
     name: options.name ?? DEFAULT_SERVER_NAME,
     version: options.version ?? DEFAULT_SERVER_VERSION,
diff --git a/packages/mcp-server/src/mcp/tools/read-tools.ts b/packages/mcp-server/src/mcp/tools/read-tools.ts
index 93c0cba..b247ceb 100644
--- a/packages/mcp-server/src/mcp/tools/read-tools.ts
+++ b/packages/mcp-server/src/mcp/tools/read-tools.ts
@@ -2,40 +2,30 @@ import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import {
   agent as agentModule,
-  federation as federationModule,
+  contextGraphContract as contextGraphContractModule,
   graph as graphModule,
   ledger as ledgerModule,
   lens as lensModule,
-  mission as missionModule,
   orientation as orientationModule,
-  projections as projectionsModule,
   query as queryModule,
   registry as registryModule,
-  searchQmdAdapter as searchQmdAdapterModule,
   store as storeModule,
-  transport as transportModule,
   thread as threadModule,
-  threadAudit as threadAuditModule,
 } from '@versatly/workgraph-kernel';
 import { resolveActor } from '../auth.js';
 import { errorResult, okResult, renderStatusSummary } from '../result.js';
 import { type WorkgraphMcpServerOptions } from '../types.js';
 
 const agent = agentModule;
-const federation = federationModule;
+const contextGraphContract = contextGraphContractModule;
 const graph = graphModule;
 const ledger = ledgerModule;
 const lens = lensModule;
-const mission = missionModule;
 const orientation = orientationModule;
-const projections = projectionsModule;
 const query = queryModule;
 const registry = registryModule;
-const searchQmdAdapter = searchQmdAdapterModule;
 const store = storeModule;
-const transport = transportModule;
 const thread = threadModule;
-const threadAudit = threadAuditModule;
 
 export function registerReadTools(server: McpServer, options: WorkgraphMcpServerOptions): void {
   server.registerTool(
@@ -62,7 +52,7 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     'workgraph_brief',
     {
       title: 'Workgraph Brief',
-      description: 'Return actor-centric operational brief (claims, blockers, and next work).',
+      description: 'Return actor-centric operational brief for thread collaboration.',
       inputSchema: {
         actor: z.string().optional(),
         recentCount: z.number().int().min(1).max(100).optional(),
@@ -88,21 +78,25 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
   );
 
   server.registerTool(
-    'workgraph_agent_list',
+    'workgraph_company_context',
     {
-      title: 'Agent List',
-      description: 'List known agent presence entries.',
+      title: 'Company Context',
+      description: 'Return the current company context snapshot for an actor.',
+      inputSchema: {
+        actor: z.string().optional(),
+      },
       annotations: {
         readOnlyHint: true,
         idempotentHint: true,
       },
     },
-    async () => {
+    async (args) => {
       try {
-        const agents = agent.list(options.workspacePath);
+        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
+        const companyContext = orientation.companyContext(options.workspacePath, actor);
         return okResult(
-          { agents, count: agents.length },
-          `Agent list returned ${agents.length} entry(s).`,
+          companyContext,
+          `Company context for ${actor}: teams=${companyContext.teams.length}, decisions=${companyContext.recentDecisions.length}.`,
         );
       } catch (error) {
         return errorResult(error);
@@ -111,26 +105,19 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
   );
 
   server.registerTool(
-    'workgraph_company_context',
+    'workgraph_agent_list',
     {
-      title: 'Workgraph Company Context',
-      description: 'Return company context graph view for an actor.',
-      inputSchema: {
-        actor: z.string().optional(),
-      },
+      title: 'Agent List',
+      description: 'List known agent presence entries.',
       annotations: {
         readOnlyHint: true,
         idempotentHint: true,
       },
     },
-    async (args) => {
+    async () => {
       try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const companyContext = orientation.companyContext(options.workspacePath, actor);
-        return okResult(
-          companyContext,
-          `Company context for ${actor}: teams=${companyContext.teams.length}, clients=${companyContext.clients.length}.`,
-        );
+        const agents = agent.list(options.workspacePath);
+        return okResult({ agents, count: agents.length }, `Agent list returned ${agents.length} entry(s).`);
       } catch (error) {
         return errorResult(error);
       }
@@ -163,20 +150,7 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     },
     async (args) => {
       try {
-        const results = query.queryPrimitives(options.workspacePath, {
-          type: args.type,
-          status: args.status,
-          owner: args.owner,
-          tag: args.tag,
-          text: args.text,
-          pathIncludes: args.pathIncludes,
-          updatedAfter: args.updatedAfter,
-          updatedBefore: args.updatedBefore,
-          createdAfter: args.createdAfter,
-          createdBefore: args.createdBefore,
-          limit: args.limit,
-          offset: args.offset,
-        });
+        const results = query.queryPrimitives(options.workspacePath, args);
         return okResult({ results, count: results.length }, `Query returned ${results.length} primitive(s).`);
       } catch (error) {
         return errorResult(error);
@@ -192,7 +166,6 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
       inputSchema: {
         text: z.string().min(1),
         type: z.string().optional(),
-        mode: z.enum(['auto', 'core', 'qmd']).optional(),
         limit: z.number().int().min(0).max(1000).optional(),
       },
       annotations: {
@@ -202,18 +175,11 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     },
     async (args) => {
       try {
-        const result = searchQmdAdapter.search(options.workspacePath, args.text, {
-          mode: args.mode,
+        const results = query.keywordSearch(options.workspacePath, args.text, {
           type: args.type,
           limit: args.limit,
         });
-        return okResult(
-          {
-            ...result,
-            count: result.results.length,
-          },
-          `Search returned ${result.results.length} result(s) in ${result.mode} mode.`,
-        );
+        return okResult({ results, count: results.length }, `Search returned ${results.length} result(s).`);
       } catch (error) {
         return errorResult(error);
       }
@@ -233,10 +199,7 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     async () => {
       try {
         const lenses = lens.listContextLenses();
-        return okResult(
-          { lenses, count: lenses.length },
-          `Lens list returned ${lenses.length} item(s).`,
-        );
+        return okResult({ lenses, count: lenses.length }, `Lens list returned ${lenses.length} item(s).`);
       } catch (error) {
         return errorResult(error);
       }
@@ -272,10 +235,7 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
             limit: args.limit,
             outputPath: args.outputPath,
           });
-          return okResult(
-            materialized,
-            `Materialized lens ${materialized.lens} to ${materialized.outputPath}.`,
-          );
+          return okResult(materialized, `Materialized lens ${materialized.lens} to ${materialized.outputPath}.`);
         }
         const generated = lens.generateContextLens(options.workspacePath, args.lensId, {
           actor,
@@ -336,64 +296,11 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     },
   );
 
-  server.registerTool(
-    'workgraph_mission_status',
-    {
-      title: 'Mission Status',
-      description: 'Read one mission primitive and computed progress.',
-      inputSchema: {
-        missionRef: z.string().min(1),
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async (args) => {
-      try {
-        const missionInstance = mission.missionStatus(options.workspacePath, args.missionRef);
-        const progress = mission.missionProgress(options.workspacePath, missionInstance.path);
-        return okResult(
-          { mission: missionInstance, progress },
-          `Mission ${missionInstance.path} is ${String(missionInstance.fields.status)}.`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_mission_progress',
-    {
-      title: 'Mission Progress',
-      description: 'Read aggregate mission progress across milestones and features.',
-      inputSchema: {
-        missionRef: z.string().min(1),
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async (args) => {
-      try {
-        const progress = mission.missionProgress(options.workspacePath, args.missionRef);
-        return okResult(
-          progress,
-          `Mission progress ${progress.mid}: ${progress.percentComplete}% (${progress.doneFeatures}/${progress.totalFeatures} features).`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
   server.registerTool(
     'workgraph_thread_list',
     {
       title: 'Thread List',
-      description: 'List workspace threads, optionally filtered by status/space/readiness.',
+      description: 'List workspace threads, optionally filtered by status, readiness, or space.',
       inputSchema: {
         status: z.string().optional(),
         readyOnly: z.boolean().optional(),
@@ -487,291 +394,10 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
   );
 
   server.registerTool(
-    'wg_transport_outbox_list',
-    {
-      title: 'Transport Outbox List',
-      description: 'List persistent outbound transport records.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const records = transport.listTransportOutbox(options.workspacePath);
-        return okResult({ records, count: records.length }, `Transport outbox has ${records.length} record(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_transport_inbox_list',
-    {
-      title: 'Transport Inbox List',
-      description: 'List persistent inbound transport records.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const records = transport.listTransportInbox(options.workspacePath);
-        return okResult({ records, count: records.length }, `Transport inbox has ${records.length} record(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_transport_dead_letter_list',
-    {
-      title: 'Transport Dead Letter List',
-      description: 'List failed transport deliveries available for inspection and replay.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const records = transport.listTransportDeadLetters(options.workspacePath);
-        return okResult({ records, count: records.length }, `Transport dead-letter queue has ${records.length} record(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_federation_status',
-    {
-      title: 'Federation Status',
-      description: 'Read workspace federation identity and remote handshake status.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const status = federation.federationStatus(options.workspacePath);
-        return okResult(status, `Federation status loaded for ${status.remotes.length} remote(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_federation_resolve_ref',
-    {
-      title: 'Federation Resolve Ref',
-      description: 'Resolve one typed or legacy federated reference with authority and staleness metadata.',
-      inputSchema: {
-        ref: z.union([z.string().min(1), z.object({}).passthrough()]),
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async (args) => {
-      try {
-        const resolved = federation.resolveFederatedRef(options.workspacePath, args.ref as any);
-        return okResult(
-          resolved,
-          `Resolved federated ref to ${resolved.source}:${resolved.instance.path} (authority=${resolved.authority}).`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_federation_search',
-    {
-      title: 'Federation Search',
-      description: 'Search local and remote workspaces through read-only federation capability negotiation.',
-      inputSchema: {
-        query: z.string().min(1),
-        type: z.string().optional(),
-        limit: z.number().int().min(0).max(1000).optional(),
-        remoteIds: z.array(z.string()).optional(),
-        includeLocal: z.boolean().optional(),
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async (args) => {
-      try {
-        const result = federation.searchFederated(options.workspacePath, args.query, {
-          type: args.type,
-          limit: args.limit,
-          remoteIds: args.remoteIds,
-          includeLocal: args.includeLocal,
-        });
-        return okResult(
-          result,
-          `Federation search returned ${result.results.length} result(s) with ${result.errors.length} remote error(s).`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_run_health',
-    {
-      title: 'Run Health Projection',
-      description: 'Return the run health projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildRunHealthProjection(options.workspacePath);
-        return okResult(projection, `Run health: active=${projection.summary.activeRuns}, stale=${projection.summary.staleRuns}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_risk_dashboard',
-    {
-      title: 'Risk Dashboard Projection',
-      description: 'Return the risk dashboard projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildRiskDashboardProjection(options.workspacePath);
-        return okResult(projection, `Risk dashboard: blocked=${projection.summary.blockedThreads}, violations=${projection.summary.policyViolations}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_mission_progress_projection',
-    {
-      title: 'Mission Progress Projection',
-      description: 'Return the mission progress projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildMissionProgressProjection(options.workspacePath);
-        return okResult(projection, `Mission progress projection covers ${projection.summary.totalMissions} mission(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_transport_health',
-    {
-      title: 'Transport Health Projection',
-      description: 'Return the transport health projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildTransportHealthProjection(options.workspacePath);
-        return okResult(projection, `Transport health: outbox=${projection.summary.outboxDepth}, dead-letter=${projection.summary.deadLetterCount}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_federation_status_projection',
-    {
-      title: 'Federation Status Projection',
-      description: 'Return the federation status projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildFederationStatusProjection(options.workspacePath);
-        return okResult(projection, `Federation projection covers ${projection.summary.remotes} remote(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_trigger_health',
-    {
-      title: 'Trigger Health Projection',
-      description: 'Return the trigger health projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildTriggerHealthProjection(options.workspacePath);
-        return okResult(projection, `Trigger health: total=${projection.summary.totalTriggers}, errors=${projection.summary.errorTriggers}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_autonomy_health',
-    {
-      title: 'Autonomy Health Projection',
-      description: 'Return the autonomy health projection.',
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-      },
-    },
-    async () => {
-      try {
-        const projection = projections.buildAutonomyHealthProjection(options.workspacePath);
-        return okResult(projection, `Autonomy health: running=${projection.summary.running}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_ledger_reconcile',
+    'workgraph_graph_hygiene',
     {
-      title: 'Ledger Reconcile',
-      description: 'Audit thread files against ledger claims, leases, and dependency wiring.',
+      title: 'Graph Hygiene',
+      description: 'Generate a wiki-link graph hygiene report.',
       annotations: {
         readOnlyHint: true,
         idempotentHint: true,
@@ -779,10 +405,10 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     },
     async () => {
       try {
-        const report = threadAudit.reconcileThreadState(options.workspacePath);
+        const report = graph.graphHygieneReport(options.workspacePath);
         return okResult(
           report,
-          `Ledger reconcile ${report.ok ? 'ok' : 'issues'}: ${report.issues.length} issue(s) across ${report.totalThreads} thread(s).`,
+          `Graph hygiene: nodes=${report.nodeCount}, edges=${report.edgeCount}, orphans=${report.orphanCount}, broken=${report.brokenLinkCount}`,
         );
       } catch (error) {
         return errorResult(error);
@@ -791,10 +417,10 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
   );
 
   server.registerTool(
-    'workgraph_graph_hygiene',
+    'workgraph_context_graph_contract',
     {
-      title: 'Graph Hygiene',
-      description: 'Generate wiki-link graph hygiene report.',
+      title: 'Context Graph Contract',
+      description: 'Evaluate core context graph contract invariants for the current workspace.',
       annotations: {
         readOnlyHint: true,
         idempotentHint: true,
@@ -802,11 +428,12 @@ export function registerReadTools(server: McpServer, options: WorkgraphMcpServer
     },
     async () => {
       try {
-        const report = graph.graphHygieneReport(options.workspacePath);
-        return okResult(
-          report,
-          `Graph hygiene: nodes=${report.nodeCount}, edges=${report.edgeCount}, orphans=${report.orphanCount}, broken=${report.brokenLinkCount}`,
-        );
+        const report = contextGraphContract.evaluateCoreContextGraphInvariants({
+          registry: registry.loadRegistry(options.workspacePath),
+          queryFilterKeys: ['type', 'status', 'owner', 'tag', 'text', 'pathIncludes', 'updatedAfter', 'updatedBefore', 'createdAfter', 'createdBefore', 'limit', 'offset'],
+          lenses: lens.listContextLenses(),
+        });
+        return okResult(report, `Context graph contract ${report.ok ? 'passes' : 'has violations'} (${report.violations.length}).`);
       } catch (error) {
         return errorResult(error);
       }
diff --git a/packages/mcp-server/src/mcp/tools/write-tools.ts b/packages/mcp-server/src/mcp/tools/write-tools.ts
index 71c2b47..59ac856 100644
--- a/packages/mcp-server/src/mcp/tools/write-tools.ts
+++ b/packages/mcp-server/src/mcp/tools/write-tools.ts
@@ -2,80 +2,37 @@ import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import {
   agent as agentModule,
-  autonomy as autonomyModule,
-  cursorBridge as cursorBridgeModule,
-  dispatch as dispatchModule,
-  mission as missionModule,
-  missionOrchestrator as missionOrchestratorModule,
   orientation as orientationModule,
+  registry as registryModule,
   store as storeModule,
-  transport as transportModule,
-  threadContext as threadContextModule,
   thread as threadModule,
-  trigger as triggerModule,
-  triggerEngine as triggerEngineModule,
 } from '@versatly/workgraph-kernel';
 import { checkWriteGate, resolveActor } from '../auth.js';
 import { errorResult, okResult } from '../result.js';
 import { type WorkgraphMcpServerOptions } from '../types.js';
 
 const agent = agentModule;
-const autonomy = autonomyModule;
-const cursorBridge = cursorBridgeModule;
-const dispatch = dispatchModule;
-const mission = missionModule;
-const missionOrchestrator = missionOrchestratorModule;
 const orientation = orientationModule;
+const registry = registryModule;
 const store = storeModule;
-const transport = transportModule;
-const threadContext = threadContextModule;
 const thread = threadModule;
-const trigger = triggerModule;
-const triggerEngine = triggerEngineModule;
 
-const missionFeatureInputSchema = z.union([
-  z.string().min(1),
-  z.object({
-    title: z.string().min(1),
-    goal: z.string().min(1).optional(),
-    threadPath: z.string().min(1).optional(),
-    priority: z.enum(['urgent', 'high', 'medium', 'low']).optional(),
-    deps: z.array(z.string()).optional(),
-    tags: z.array(z.string()).optional(),
-  }),
-]);
-
-const missionMilestoneInputSchema = z.object({
-  id: z.string().min(1).optional(),
-  title: z.string().min(1),
-  deps: z.array(z.string()).optional(),
-  features: z.array(missionFeatureInputSchema).min(1),
-  validation: z.object({
-    strategy: z.enum(['automated', 'manual', 'hybrid']).optional(),
-    criteria: z.array(z.string()).optional(),
-  }).optional(),
-});
-
-const triggerConditionSchema = z.union([
-  z.string(),
-  z.object({}).passthrough(),
-]);
-
-const triggerContextSchema = z.object({}).passthrough();
+const threadStatusSchema = z.enum(['open', 'active', 'blocked', 'done', 'cancelled']);
+const agentStatusSchema = z.enum(['online', 'busy', 'offline']);
 
 export function registerWriteTools(server: McpServer, options: WorkgraphMcpServerOptions): void {
   server.registerTool(
     'workgraph_agent_register',
     {
       title: 'Agent Register',
-      description: 'Register an agent using trust-token fallback flow.',
+      description: 'Register an actor using the configured bootstrap token flow.',
       inputSchema: {
         name: z.string().min(1),
         actor: z.string().optional(),
         token: z.string().optional(),
         role: z.string().optional(),
         capabilities: z.array(z.string()).optional(),
-        status: z.enum(['online', 'busy', 'offline']).optional(),
+        status: agentStatusSchema.optional(),
         currentTask: z.string().optional(),
       },
       annotations: {
@@ -86,26 +43,24 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mcp:write'], {
+        const gate = checkWriteGate(options, actor, ['agent:register', 'mcp:write'], {
           action: 'mcp.agent.register',
           target: 'agents',
         });
         if (!gate.allowed) return errorResult(gate.reason);
-        const token = typeof args.token === 'string' && args.token.trim().length > 0
-          ? args.token.trim()
-          : process.env.WORKGRAPH_TRUST_TOKEN;
+        const token = readNonEmptyString(args.token) ?? process.env.WORKGRAPH_TRUST_TOKEN;
         if (!token) {
-          return errorResult('Missing trust token. Provide token argument or set WORKGRAPH_TRUST_TOKEN.');
+          throw new Error('Missing trust token. Provide token argument or set WORKGRAPH_TRUST_TOKEN.');
         }
-        const registered = agent.registerAgent(options.workspacePath, args.name, {
+        const result = agent.registerAgent(options.workspacePath, args.name, {
           token,
           role: args.role,
           capabilities: args.capabilities,
           status: args.status,
           currentTask: args.currentTask,
-          actor: args.actor,
+          actor,
         });
-        return okResult(registered, `Registered agent ${registered.agentName}.`);
+        return okResult(result, `Registered agent ${result.agentName}.`);
       } catch (error) {
         return errorResult(error);
       }
@@ -113,16 +68,16 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
   );
 
   server.registerTool(
-    'workgraph_agent_heartbeat',
+    'workgraph_agent_request_registration',
     {
-      title: 'Agent Heartbeat',
-      description: 'Create/update an agent presence heartbeat.',
+      title: 'Agent Request Registration',
+      description: 'Create a governed actor registration request.',
       inputSchema: {
         name: z.string().min(1),
         actor: z.string().optional(),
-        status: z.enum(['online', 'busy', 'offline']).optional(),
-        currentTask: z.string().optional(),
+        role: z.string().optional(),
         capabilities: z.array(z.string()).optional(),
+        note: z.string().optional(),
       },
       annotations: {
         destructiveHint: true,
@@ -132,66 +87,16 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['agent:heartbeat', 'mcp:write'], {
-          action: 'mcp.agent.heartbeat',
-          target: args.name,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const presence = agent.heartbeat(options.workspacePath, args.name, {
-          actor: args.actor,
-          status: args.status,
-          currentTask: args.currentTask,
+        if (options.readOnly) {
+          return errorResult('MCP server is configured read-only; write tool is disabled.');
+        }
+        const result = agent.submitRegistrationRequest(options.workspacePath, args.name, {
+          actor,
+          role: args.role,
           capabilities: args.capabilities,
+          note: args.note,
         });
-        return okResult({ presence }, `Heartbeated agent ${args.name}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_create_mission',
-    {
-      title: 'Mission Create',
-      description: 'Create a mission primitive in planning status.',
-      inputSchema: {
-        title: z.string().min(1),
-        goal: z.string().min(1),
-        actor: z.string().optional(),
-        mid: z.string().min(1).optional(),
-        description: z.string().optional(),
-        priority: z.enum(['urgent', 'high', 'medium', 'low']).optional(),
-        owner: z.string().optional(),
-        project: z.string().optional(),
-        space: z.string().optional(),
-        constraints: z.array(z.string()).optional(),
-        tags: z.array(z.string()).optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mission:create', 'mcp:write'], {
-          action: 'mcp.mission.create',
-          target: 'missions',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const created = mission.createMission(options.workspacePath, args.title, args.goal, actor, {
-          mid: args.mid,
-          description: args.description,
-          priority: args.priority,
-          owner: args.owner,
-          project: args.project,
-          space: args.space,
-          constraints: args.constraints,
-          tags: args.tags,
-        });
-        return okResult({ mission: created }, `Created mission ${created.path}.`);
+        return okResult(result, `Created registration request for ${result.agentName}.`);
       } catch (error) {
         return errorResult(error);
       }
@@ -199,42 +104,24 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
   );
 
   server.registerTool(
-    'workgraph_plan_mission',
+    'workgraph_agent_list_registration_requests',
     {
-      title: 'Mission Plan',
-      description: 'Define or update mission milestones and feature threads.',
+      title: 'Agent List Registration Requests',
+      description: 'List actor registration requests by status.',
       inputSchema: {
-        missionRef: z.string().min(1),
         actor: z.string().optional(),
-        goal: z.string().optional(),
-        constraints: z.array(z.string()).optional(),
-        estimatedRuns: z.number().int().min(0).optional(),
-        estimatedCostUsd: z.number().min(0).nullable().optional(),
-        replaceMilestones: z.boolean().optional(),
-        milestones: z.array(missionMilestoneInputSchema).min(1),
+        status: z.enum(['pending', 'approved', 'rejected']).optional(),
       },
       annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
+        readOnlyHint: true,
+        idempotentHint: true,
       },
     },
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mission:update', 'thread:create', 'mcp:write'], {
-          action: 'mcp.mission.plan',
-          target: args.missionRef,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = mission.planMission(options.workspacePath, args.missionRef, {
-          goal: args.goal,
-          constraints: args.constraints,
-          estimated_runs: args.estimatedRuns,
-          estimated_cost_usd: args.estimatedCostUsd,
-          replaceMilestones: args.replaceMilestones,
-          milestones: args.milestones,
-        }, actor);
-        return okResult({ mission: updated }, `Planned mission ${updated.path}.`);
+        const requests = agent.listRegistrationRequests(options.workspacePath, args.status);
+        return okResult({ actor, status: args.status, requests, count: requests.length }, `Listed ${requests.length} registration request(s).`);
       } catch (error) {
         return errorResult(error);
       }
@@ -242,13 +129,19 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
   );
 
   server.registerTool(
-    'workgraph_approve_mission',
+    'workgraph_agent_review_registration',
     {
-      title: 'Mission Approve',
-      description: 'Approve a mission plan and move it to approved status.',
+      title: 'Agent Review Registration',
+      description: 'Approve or reject a pending actor registration request.',
       inputSchema: {
-        missionRef: z.string().min(1),
+        requestRef: z.string().min(1),
         actor: z.string().optional(),
+        decision: z.enum(['approved', 'rejected']),
+        role: z.string().optional(),
+        capabilities: z.array(z.string()).optional(),
+        scopes: z.array(z.string()).optional(),
+        expiresAt: z.string().optional(),
+        note: z.string().optional(),
       },
       annotations: {
         destructiveHint: true,
@@ -258,13 +151,25 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mission:update', 'mcp:write'], {
-          action: 'mcp.mission.approve',
-          target: args.missionRef,
+        const gate = checkWriteGate(options, actor, ['agent:approve-registration', 'policy:manage', 'mcp:write'], {
+          action: 'mcp.agent.review-registration',
+          target: args.requestRef,
         });
         if (!gate.allowed) return errorResult(gate.reason);
-        const updated = mission.approveMission(options.workspacePath, args.missionRef, actor);
-        return okResult({ mission: updated }, `Approved mission ${updated.path}.`);
+        const result = agent.reviewRegistrationRequest(
+          options.workspacePath,
+          args.requestRef,
+          actor,
+          args.decision,
+          {
+            role: args.role,
+            capabilities: args.capabilities,
+            scopes: args.scopes,
+            expiresAt: args.expiresAt,
+            note: args.note,
+          },
+        );
+        return okResult(result, `Registration request ${args.requestRef} reviewed as ${args.decision}.`);
       } catch (error) {
         return errorResult(error);
       }
@@ -272,14 +177,16 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
   );
 
   server.registerTool(
-    'workgraph_start_mission',
+    'workgraph_agent_heartbeat',
     {
-      title: 'Mission Start',
-      description: 'Start mission execution and run one orchestrator cycle.',
+      title: 'Agent Heartbeat',
+      description: 'Update actor presence and capabilities.',
       inputSchema: {
-        missionRef: z.string().min(1),
+        name: z.string().min(1),
         actor: z.string().optional(),
-        runCycle: z.boolean().optional(),
+        status: agentStatusSchema.optional(),
+        currentTask: z.string().optional(),
+        capabilities: z.array(z.string()).optional(),
       },
       annotations: {
         destructiveHint: true,
@@ -289,60 +196,18 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mission:update', 'dispatch:run', 'mcp:write'], {
-          action: 'mcp.mission.start',
-          target: args.missionRef,
+        const gate = checkWriteGate(options, actor, ['agent:heartbeat', 'mcp:write'], {
+          action: 'mcp.agent.heartbeat',
+          target: args.name,
         });
         if (!gate.allowed) return errorResult(gate.reason);
-        const updated = mission.startMission(options.workspacePath, args.missionRef, actor);
-        const cycle = args.runCycle === false
-          ? null
-          : missionOrchestrator.runMissionOrchestratorCycle(options.workspacePath, updated.path, actor);
-        return okResult({ mission: updated, cycle }, `Started mission ${updated.path}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_intervene_mission',
-    {
-      title: 'Mission Intervene',
-      description: 'Apply mission intervention updates (priority/status/skip/append milestones).',
-      inputSchema: {
-        missionRef: z.string().min(1),
-        actor: z.string().optional(),
-        reason: z.string().min(1),
-        setPriority: z.enum(['urgent', 'high', 'medium', 'low']).optional(),
-        setStatus: z.enum(['planning', 'approved', 'active', 'validating', 'completed', 'failed']).optional(),
-        skipFeature: z.object({
-          milestoneId: z.string().min(1),
-          threadPath: z.string().min(1),
-        }).optional(),
-        appendMilestones: z.array(missionMilestoneInputSchema).optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mission:update', 'thread:update', 'mcp:write'], {
-          action: 'mcp.mission.intervene',
-          target: args.missionRef,
+        const presence = agent.heartbeat(options.workspacePath, args.name, {
+          actor,
+          status: args.status,
+          currentTask: args.currentTask,
+          capabilities: args.capabilities,
         });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = mission.interveneMission(options.workspacePath, args.missionRef, {
-          reason: args.reason,
-          setPriority: args.setPriority,
-          setStatus: args.setStatus,
-          skipFeature: args.skipFeature,
-          appendMilestones: args.appendMilestones,
-        }, actor);
-        return okResult({ mission: updated }, `Intervened mission ${updated.path}.`);
+        return okResult({ presence }, `Heartbeated agent ${args.name}.`);
       } catch (error) {
         return errorResult(error);
       }
@@ -353,7 +218,7 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     'workgraph_thread_create',
     {
       title: 'Thread Create',
-      description: 'Create a new thread primitive (policy-scoped write).',
+      description: 'Create a new collaboration thread.',
       inputSchema: {
         title: z.string().min(1),
         goal: z.string().min(1),
@@ -394,41 +259,30 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
   );
 
   server.registerTool(
-    'workgraph_thread_block',
+    'workgraph_thread_claim',
     {
-      title: 'Thread Block',
-      description: 'Mark a thread blocked with a reason (policy-scoped write).',
+      title: 'Thread Claim',
+      description: 'Claim an open thread for an actor.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
-        reason: z.string().min(1),
       },
       annotations: {
         destructiveHint: true,
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:update', 'mcp:write'], {
-          action: 'mcp.thread.block',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = thread.block(options.workspacePath, args.threadPath, actor, 'external/manual', args.reason);
-        return okResult({ thread: updated }, `Blocked ${updated.path} as ${actor}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:claim', 'mcp:write'], args.threadPath, () =>
+      thread.claim(options.workspacePath, args.threadPath, resolveActor(options.workspacePath, args.actor, options.defaultActor)),
+      'Claimed thread',
+    ),
   );
 
   server.registerTool(
-    'workgraph_thread_unblock',
+    'workgraph_thread_release',
     {
-      title: 'Thread Unblock',
-      description: 'Unblock a blocked thread (policy-scoped write).',
+      title: 'Thread Release',
+      description: 'Release an active thread back to open.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
@@ -439,167 +293,125 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:update', 'mcp:write'], {
-          action: 'mcp.thread.unblock',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = thread.unblock(options.workspacePath, args.threadPath, actor);
-        const reasonSuffix = args.reason ? ` Reason: ${args.reason}` : '';
-        return okResult({ thread: updated }, `Unblocked ${updated.path} as ${actor}.${reasonSuffix}`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:update', 'mcp:write'], args.threadPath, () =>
+      thread.release(options.workspacePath, args.threadPath, resolveActor(options.workspacePath, args.actor, options.defaultActor), args.reason),
+      'Released thread',
+    ),
   );
 
   server.registerTool(
-    'workgraph_thread_handoff',
+    'workgraph_thread_heartbeat',
     {
-      title: 'Thread Handoff',
-      description: 'Hand off a claimed thread to another actor (policy-scoped write).',
+      title: 'Thread Heartbeat',
+      description: 'Refresh the heartbeat on a claimed thread.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
-        fromActor: z.string().optional(),
-        toActor: z.string().min(1),
-        reason: z.string().optional(),
+        leaseMinutes: z.number().int().min(1).max(240).optional(),
       },
       annotations: {
         destructiveHint: true,
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const fromActor = resolveActor(options.workspacePath, args.fromActor, actor);
-        const gate = checkWriteGate(options, fromActor, ['thread:update', 'mcp:write'], {
-          action: 'mcp.thread.handoff',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = thread.handoff(options.workspacePath, args.threadPath, fromActor, args.toActor, args.reason);
-        return okResult({ thread: updated }, `Handed off ${updated.path} from ${fromActor} to ${args.toActor}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:update', 'mcp:write'], args.threadPath, () =>
+      thread.heartbeat(
+        options.workspacePath,
+        args.threadPath,
+        resolveActor(options.workspacePath, args.actor, options.defaultActor),
+        args.leaseMinutes,
+      ),
+      'Heartbeated thread',
+    ),
   );
 
   server.registerTool(
-    'workgraph_thread_release',
+    'workgraph_thread_join',
     {
-      title: 'Thread Release',
-      description: 'Release a claimed thread back to open (policy-scoped write).',
+      title: 'Thread Join',
+      description: 'Join a thread as a participant.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
-        reason: z.string().optional(),
+        role: z.enum(['contributor', 'reviewer', 'observer']).optional(),
       },
       annotations: {
         destructiveHint: true,
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:claim', 'mcp:write'], {
-          action: 'mcp.thread.release',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = thread.release(options.workspacePath, args.threadPath, actor, args.reason);
-        return okResult({ thread: updated }, `Released ${updated.path} as ${actor}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:update', 'mcp:write'], args.threadPath, () =>
+      thread.joinThread(
+        options.workspacePath,
+        args.threadPath,
+        resolveActor(options.workspacePath, args.actor, options.defaultActor),
+        args.role,
+      ),
+      'Joined thread',
+    ),
   );
 
   server.registerTool(
-    'workgraph_thread_heartbeat',
+    'workgraph_thread_handoff',
     {
-      title: 'Thread Heartbeat',
-      description: 'Refresh heartbeat metadata for a claimed thread (policy-scoped write).',
+      title: 'Thread Handoff',
+      description: 'Hand off a claimed thread to another actor.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
-        note: z.string().optional(),
+        toActor: z.string().min(1),
+        reason: z.string().optional(),
       },
       annotations: {
         destructiveHint: true,
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:update', 'mcp:write'], {
-          action: 'mcp.thread.heartbeat',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = thread.heartbeat(options.workspacePath, args.threadPath, actor);
-        return okResult(
-          {
-            thread: updated,
-            ...(args.note ? { note: args.note } : {}),
-          },
-          `Heartbeated ${updated.path} as ${actor}.`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:update', 'mcp:write'], args.threadPath, () =>
+      thread.handoff(
+        options.workspacePath,
+        args.threadPath,
+        resolveActor(options.workspacePath, args.actor, options.defaultActor),
+        args.toActor,
+        args.reason,
+      ),
+      'Handed off thread',
+    ),
   );
 
   server.registerTool(
-    'workgraph_thread_join',
+    'workgraph_thread_block',
     {
-      title: 'Thread Join',
-      description: 'Join a thread as a participant (policy-scoped write).',
+      title: 'Thread Block',
+      description: 'Block an active thread on a dependency or reason.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
-        role: z.string().optional(),
+        blockedBy: z.string().optional(),
+        reason: z.string().optional(),
       },
       annotations: {
         destructiveHint: true,
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:update', 'mcp:write'], {
-          action: 'mcp.thread.join',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const role = args.role === 'participant' ? 'contributor' : args.role;
-        const updated = thread.joinThread(
-          options.workspacePath,
-          args.threadPath,
-          actor,
-          role as Parameters<typeof thread.joinThread>[3],
-        );
-        return okResult({ thread: updated }, `Joined ${updated.path} as ${actor}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:update', 'mcp:write'], args.threadPath, () =>
+      thread.block(
+        options.workspacePath,
+        args.threadPath,
+        resolveActor(options.workspacePath, args.actor, options.defaultActor),
+        args.blockedBy ?? 'external/manual',
+        args.reason,
+      ),
+      'Blocked thread',
+    ),
   );
 
   server.registerTool(
-    'workgraph_thread_claim',
+    'workgraph_thread_unblock',
     {
-      title: 'Thread Claim',
-      description: 'Claim a thread for an actor (policy-scoped write).',
+      title: 'Thread Unblock',
+      description: 'Unblock a blocked thread.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
@@ -609,39 +421,21 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
         idempotentHint: false,
       },
     },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:claim', 'mcp:write'], {
-          action: 'mcp.thread.claim',
-          target: args.threadPath,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = thread.claim(options.workspacePath, args.threadPath, actor);
-        const contextSummary = threadContext.summarizeThreadContext(options.workspacePath, updated.path, { topN: 3 });
-        return okResult(
-          {
-            thread: updated,
-            context: contextSummary,
-          },
-          `Claimed ${updated.path} as ${actor}.`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
+    async (args) => mutateThread(options, args.actor, ['thread:update', 'mcp:write'], args.threadPath, () =>
+      thread.unblock(options.workspacePath, args.threadPath, resolveActor(options.workspacePath, args.actor, options.defaultActor)),
+      'Unblocked thread',
+    ),
   );
 
   server.registerTool(
     'workgraph_thread_done',
     {
       title: 'Thread Done',
-      description: 'Mark a thread as done with output summary (policy-scoped write).',
+      description: 'Complete a claimed thread with optional evidence and output.',
       inputSchema: {
         threadPath: z.string().min(1),
         actor: z.string().optional(),
         output: z.string().optional(),
-        reason: z.string().optional(),
         evidence: z.array(z.string()).optional(),
       },
       annotations: {
@@ -649,21 +443,47 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
         idempotentHint: false,
       },
     },
+    async (args) => mutateThread(options, args.actor, ['thread:complete', 'mcp:write'], args.threadPath, () =>
+      thread.done(
+        options.workspacePath,
+        args.threadPath,
+        resolveActor(options.workspacePath, args.actor, options.defaultActor),
+        args.output,
+        { evidence: args.evidence },
+      ),
+      'Completed thread',
+    ),
+  );
+
+  server.registerTool(
+    'workgraph_thread_update_status',
+    {
+      title: 'Thread Update Status',
+      description: 'Update thread lifecycle status through one canonical tool.',
+      inputSchema: {
+        threadPath: z.string().min(1),
+        actor: z.string().optional(),
+        status: threadStatusSchema,
+        reason: z.string().optional(),
+        output: z.string().optional(),
+        blockedBy: z.string().optional(),
+        leaseMinutes: z.number().int().min(1).max(240).optional(),
+      },
+      annotations: {
+        destructiveHint: true,
+        idempotentHint: false,
+      },
+    },
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['thread:done', 'mcp:write'], {
-          action: 'mcp.thread.done',
+        const gate = checkWriteGate(options, actor, ['thread:update', 'mcp:write'], {
+          action: 'mcp.thread.update-status',
           target: args.threadPath,
         });
         if (!gate.allowed) return errorResult(gate.reason);
-        const output = args.reason
-          ? [args.output, `Reason: ${args.reason}`].filter((entry): entry is string => Boolean(entry)).join('\n\n')
-          : args.output;
-        const updated = thread.done(options.workspacePath, args.threadPath, actor, output, {
-          evidence: args.evidence,
-        });
-        return okResult({ thread: updated }, `Marked ${updated.path} done as ${actor}.`);
+        const updated = updateThreadStatus(options.workspacePath, args, actor);
+        return okResult({ thread: updated }, `Updated thread ${updated.path} to ${String(updated.fields.status)}.`);
       } catch (error) {
         return errorResult(error);
       }
@@ -674,7 +494,7 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     'workgraph_checkpoint_create',
     {
       title: 'Checkpoint Create',
-      description: 'Create a checkpoint primitive for hand-off continuity (policy-scoped write).',
+      description: 'Create a checkpoint for actor handoff continuity.',
       inputSchema: {
         actor: z.string().optional(),
         summary: z.string().min(1),
@@ -690,7 +510,7 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['checkpoint:create', 'mcp:write'], {
+        const gate = checkWriteGate(options, actor, ['thread:update', 'mcp:write'], {
           action: 'mcp.checkpoint.create',
           target: 'checkpoints',
         });
@@ -708,26 +528,25 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
   );
 
   server.registerTool(
-    'workgraph_create_decision',
+    'workgraph_primitive_define',
     {
-      title: 'Decision Create',
-      description: 'Create a decision primitive with rationale, participants, and alternatives.',
+      title: 'Primitive Define',
+      description: 'Define a new primitive type for the context graph registry.',
       inputSchema: {
-        title: z.string().min(1),
         actor: z.string().optional(),
-        status: z.enum(['draft', 'proposed', 'approved', 'active', 'superseded', 'reverted']).optional(),
-        date: z.string().optional(),
-        decidedBy: z.string().optional(),
-        participants: z.array(z.string()).optional(),
-        alternatives: z.array(z.string()).optional(),
-        rationale: z.string().optional(),
-        consequences: z.array(z.string()).optional(),
-        supersedes: z.string().optional(),
-        relatedRefs: z.array(z.string()).optional(),
-        externalLinks: z.array(z.string()).optional(),
-        contextRefs: z.array(z.string()).optional(),
-        tags: z.array(z.string()).optional(),
-        body: z.string().optional(),
+        name: z.string().min(1),
+        description: z.string().min(1),
+        directory: z.string().optional(),
+        fields: z.record(z.string(), z.object({
+          type: z.enum(['string', 'number', 'boolean', 'list', 'date', 'ref', 'any']),
+          required: z.boolean().optional(),
+          default: z.unknown().optional(),
+          description: z.string().optional(),
+          enum: z.array(z.union([z.string(), z.number(), z.boolean()])).optional(),
+          template: z.enum(['slug', 'semver', 'email', 'url', 'iso-date']).optional(),
+          pattern: z.string().optional(),
+          refTypes: z.array(z.string()).optional(),
+        })),
       },
       annotations: {
         destructiveHint: true,
@@ -737,699 +556,79 @@ export function registerWriteTools(server: McpServer, options: WorkgraphMcpServe
     async (args) => {
       try {
         const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mcp:write'], {
-          action: 'mcp.decision.create',
-          target: 'decisions',
+        const gate = checkWriteGate(options, actor, ['policy:manage', 'mcp:write'], {
+          action: 'mcp.primitive.define',
+          target: '.workgraph/registry.json',
         });
         if (!gate.allowed) return errorResult(gate.reason);
-        const decision = store.create(
+        const defined = registry.defineType(
           options.workspacePath,
-          'decision',
-          {
-            title: args.title,
-            date: args.date ?? new Date().toISOString(),
-            status: args.status,
-            decided_by: args.decidedBy ?? actor,
-            participants: args.participants ?? [],
-            alternatives: args.alternatives ?? [],
-            rationale: args.rationale,
-            consequences: args.consequences ?? [],
-            supersedes: args.supersedes,
-            related_refs: args.relatedRefs ?? [],
-            external_links: args.externalLinks ?? [],
-            context_refs: args.contextRefs ?? [],
-            tags: args.tags ?? [],
-          },
-          args.body ?? '',
+          args.name,
+          args.description,
+          args.fields,
           actor,
+          args.directory,
         );
-        return okResult({ decision }, `Created decision ${decision.path}.`);
+        return okResult({ type: defined }, `Defined primitive type ${defined.name}.`);
       } catch (error) {
         return errorResult(error);
       }
     },
   );
+}
 
-  server.registerTool(
-    'workgraph_record_lesson',
-    {
-      title: 'Lesson Record',
-      description: 'Record a lesson with severity and source event context.',
-      inputSchema: {
-        title: z.string().min(1),
-        actor: z.string().optional(),
-        date: z.string().optional(),
-        confidence: z.string().optional(),
-        severity: z.enum(['critical', 'important', 'minor']).optional(),
-        sourceEvent: z.string().optional(),
-        appliesTo: z.array(z.string()).optional(),
-        relatedRefs: z.array(z.string()).optional(),
-        contextRefs: z.array(z.string()).optional(),
-        tags: z.array(z.string()).optional(),
-        body: z.string().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mcp:write'], {
-          action: 'mcp.lesson.record',
-          target: 'lessons',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const lesson = store.create(
-          options.workspacePath,
-          'lesson',
-          {
-            title: args.title,
-            date: args.date ?? new Date().toISOString(),
-            confidence: args.confidence,
-            severity: args.severity,
-            source_event: args.sourceEvent,
-            applies_to: args.appliesTo ?? [],
-            related_refs: args.relatedRefs ?? [],
-            context_refs: args.contextRefs ?? [],
-            tags: args.tags ?? [],
-          },
-          args.body ?? '',
-          actor,
-        );
-        return okResult({ lesson }, `Recorded lesson ${lesson.path}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_record_pattern',
-    {
-      title: 'Pattern Record',
-      description: 'Record a reusable pattern with steps and exceptions.',
-      inputSchema: {
-        title: z.string().min(1),
-        actor: z.string().optional(),
-        description: z.string().optional(),
-        steps: z.array(z.string()).optional(),
-        exceptions: z.array(z.string()).optional(),
-        appliesTo: z.array(z.string()).optional(),
-        relatedRefs: z.array(z.string()).optional(),
-        tags: z.array(z.string()).optional(),
-        body: z.string().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['mcp:write'], {
-          action: 'mcp.pattern.record',
-          target: 'patterns',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const pattern = store.create(
-          options.workspacePath,
-          'pattern',
-          {
-            title: args.title,
-            description: args.description,
-            steps: args.steps ?? [],
-            exceptions: args.exceptions ?? [],
-            applies_to: args.appliesTo ?? [],
-            related_refs: args.relatedRefs ?? [],
-            tags: args.tags ?? [],
-          },
-          args.body ?? '',
-          actor,
-        );
-        return okResult({ pattern }, `Recorded pattern ${pattern.path}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_dispatch_create',
-    {
-      title: 'Dispatch Create',
-      description: 'Create a dispatch run request (policy-scoped write).',
-      inputSchema: {
-        actor: z.string().optional(),
-        objective: z.string().min(1),
-        adapter: z.string().optional(),
-        idempotencyKey: z.string().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.dispatch.create',
-          target: '.workgraph/dispatch-runs',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = dispatch.createRun(options.workspacePath, {
-          actor,
-          objective: args.objective,
-          adapter: args.adapter,
-          idempotencyKey: args.idempotencyKey,
-        });
-        return okResult({ run }, `Created run ${run.id} (${run.status}).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_dispatch_execute',
-    {
-      title: 'Dispatch Execute',
-      description: 'Execute one queued/running run through its adapter (policy-scoped write).',
-      inputSchema: {
-        actor: z.string().optional(),
-        runId: z.string().min(1),
-        agents: z.array(z.string()).optional(),
-        maxSteps: z.number().int().min(1).max(5000).optional(),
-        stepDelayMs: z.number().int().min(0).max(5000).optional(),
-        space: z.string().optional(),
-        createCheckpoint: z.boolean().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.dispatch.execute',
-          target: `.workgraph/runs/${args.runId}`,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = await dispatch.executeRun(options.workspacePath, args.runId, {
-          actor,
-          agents: args.agents,
-          maxSteps: args.maxSteps,
-          stepDelayMs: args.stepDelayMs,
-          space: args.space,
-          createCheckpoint: args.createCheckpoint,
-        });
-        return okResult({ run }, `Executed run ${run.id} -> ${run.status}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_dispatch_followup',
-    {
-      title: 'Dispatch Follow-up',
-      description: 'Send follow-up input to a run (policy-scoped write).',
-      inputSchema: {
-        actor: z.string().optional(),
-        runId: z.string().min(1),
-        input: z.string().min(1),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.dispatch.followup',
-          target: `.workgraph/runs/${args.runId}`,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = dispatch.followup(options.workspacePath, args.runId, actor, args.input);
-        return okResult({ run }, `Follow-up recorded for ${run.id}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_dispatch_stop',
-    {
-      title: 'Dispatch Stop',
-      description: 'Stop/cancel a run (policy-scoped write).',
-      inputSchema: {
-        actor: z.string().optional(),
-        runId: z.string().min(1),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.dispatch.stop',
-          target: `.workgraph/runs/${args.runId}`,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = dispatch.stop(options.workspacePath, args.runId, actor);
-        return okResult({ run }, `Stopped run ${run.id}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_trigger_create',
-    {
-      title: 'Trigger Create',
-      description: 'Create a trigger primitive with programmable condition/action payloads.',
-      inputSchema: {
-        actor: z.string().optional(),
-        name: z.string().min(1),
-        type: z.enum(['cron', 'webhook', 'event', 'manual']),
-        condition: triggerConditionSchema.optional(),
-        action: triggerConditionSchema.optional(),
-        enabled: z.boolean().optional(),
-        cooldown: z.number().int().min(0).optional(),
-        body: z.string().optional(),
-        tags: z.array(z.string()).optional(),
-        path: z.string().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'promote:trigger', 'mcp:write'], {
-          action: 'mcp.trigger.create',
-          target: 'triggers',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const created = trigger.createTrigger(options.workspacePath, {
-          actor,
-          name: args.name,
-          type: args.type,
-          condition: args.condition,
-          action: args.action,
-          enabled: args.enabled,
-          cooldown: args.cooldown,
-          body: args.body,
-          tags: args.tags,
-          path: args.path,
-        });
-        return okResult({ trigger: created }, `Created trigger ${created.path}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_trigger_update',
-    {
-      title: 'Trigger Update',
-      description: 'Update trigger metadata or programmable condition/action payloads.',
-      inputSchema: {
-        actor: z.string().optional(),
-        triggerRef: z.string().min(1),
-        name: z.string().optional(),
-        type: z.enum(['cron', 'webhook', 'event', 'manual']).optional(),
-        condition: triggerConditionSchema.optional(),
-        action: triggerConditionSchema.optional(),
-        enabled: z.boolean().optional(),
-        cooldown: z.number().int().min(0).optional(),
-        body: z.string().optional(),
-        tags: z.array(z.string()).optional(),
-        lastFired: z.string().nullable().optional(),
-        nextFireAt: z.string().nullable().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'promote:trigger', 'mcp:write'], {
-          action: 'mcp.trigger.update',
-          target: args.triggerRef,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = trigger.updateTrigger(options.workspacePath, args.triggerRef, {
-          actor,
-          name: args.name,
-          type: args.type,
-          condition: args.condition,
-          action: args.action,
-          enabled: args.enabled,
-          cooldown: args.cooldown,
-          body: args.body,
-          tags: args.tags,
-          lastFired: args.lastFired,
-          nextFireAt: args.nextFireAt,
-        });
-        return okResult({ trigger: updated }, `Updated trigger ${updated.path}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_trigger_delete',
-    {
-      title: 'Trigger Delete',
-      description: 'Delete a trigger primitive.',
-      inputSchema: {
-        actor: z.string().optional(),
-        triggerRef: z.string().min(1),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.trigger.delete',
-          target: args.triggerRef,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        trigger.deleteTrigger(options.workspacePath, args.triggerRef, actor);
-        return okResult({ deleted: true, triggerRef: args.triggerRef }, `Deleted trigger ${args.triggerRef}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_trigger_fire',
-    {
-      title: 'Trigger Fire',
-      description: 'Manually fire a trigger into a dispatch run, optionally executing it immediately.',
-      inputSchema: {
-        actor: z.string().optional(),
-        triggerRef: z.string().min(1),
-        eventKey: z.string().optional(),
-        objective: z.string().optional(),
-        adapter: z.string().optional(),
-        context: triggerContextSchema.optional(),
-        execute: z.boolean().optional(),
-        retryFailed: z.boolean().optional(),
-        agents: z.array(z.string()).optional(),
-        maxSteps: z.number().int().min(1).max(5000).optional(),
-        stepDelayMs: z.number().int().min(0).max(5000).optional(),
-        space: z.string().optional(),
-        createCheckpoint: z.boolean().optional(),
-        timeoutMs: z.number().int().min(1).max(60 * 60_000).optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.trigger.fire',
-          target: args.triggerRef,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const fired = await trigger.fireTriggerAndExecute(options.workspacePath, args.triggerRef, {
-          actor,
-          eventKey: args.eventKey,
-          objective: args.objective,
-          adapter: args.adapter,
-          context: args.context,
-          execute: args.execute,
-          retryFailed: args.retryFailed,
-          executeInput: {
-            agents: args.agents,
-            maxSteps: args.maxSteps,
-            stepDelayMs: args.stepDelayMs,
-            space: args.space,
-            createCheckpoint: args.createCheckpoint,
-            timeoutMs: args.timeoutMs,
-          },
-        });
-        return okResult(fired, `Fired trigger ${fired.triggerPath} into run ${fired.run.id}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_trigger_engine_cycle',
-    {
-      title: 'Trigger Engine Cycle',
-      description: 'Process trigger events from ledger with idempotent cursor tracking.',
-      inputSchema: {
-        actor: z.string().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.trigger.cycle',
-          target: '.workgraph/trigger-state.json',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const result = triggerEngine.runTriggerEngineCycle(options.workspacePath, {
-          actor,
-        });
-        return okResult(
-          result,
-          `Trigger cycle evaluated ${result.evaluated} triggers, fired ${result.fired} action(s).`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'workgraph_autonomy_run',
-    {
-      title: 'Autonomy Run',
-      description: 'Run autonomous collaboration cycles with drift checks.',
-      inputSchema: {
-        actor: z.string().optional(),
-        adapter: z.string().optional(),
-        agents: z.array(z.string()).optional(),
-        maxCycles: z.number().int().min(1).max(10_000).optional(),
-        maxIdleCycles: z.number().int().min(1).max(1_000).optional(),
-        pollMs: z.number().int().min(1).max(60_000).optional(),
-        watch: z.boolean().optional(),
-        maxSteps: z.number().int().min(1).max(5000).optional(),
-        stepDelayMs: z.number().int().min(0).max(5000).optional(),
-        executeTriggers: z.boolean().optional(),
-        executeReadyThreads: z.boolean().optional(),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.autonomy.run',
-          target: '.workgraph/autonomy',
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const result = await autonomy.runAutonomyLoop(options.workspacePath, {
-          actor,
-          adapter: args.adapter,
-          agents: args.agents,
-          maxCycles: args.maxCycles,
-          maxIdleCycles: args.maxIdleCycles,
-          pollMs: args.pollMs,
-          watch: args.watch,
-          maxSteps: args.maxSteps,
-          stepDelayMs: args.stepDelayMs,
-          executeTriggers: args.executeTriggers,
-          executeReadyThreads: args.executeReadyThreads,
-        });
-        return okResult(
-          result,
-          `Autonomy completed ${result.cycles.length} cycle(s); final ready threads=${result.finalReadyThreads}.`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-
-  server.registerTool(
-    'wg_transport_replay',
-    {
-      title: 'Transport Replay',
-      description: 'Replay an outbox or dead-letter transport delivery.',
-      inputSchema: {
-        actor: z.string().optional(),
-        recordType: z.enum(['outbox', 'dead-letter']),
-        id: z.string().min(1),
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(options.workspacePath, args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ['dispatch:run', 'mcp:write'], {
-          action: 'mcp.transport.replay',
-          target: `.workgraph/transport/${args.recordType}/${args.id}`,
-        });
-        if (!gate.allowed) return errorResult(gate.reason);
-        const replayed = await replayTransportRecord(options.workspacePath, args.recordType, args.id);
-        return okResult(
-          replayed,
-          `Replayed ${args.recordType} transport record ${args.id}.`,
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    },
-  );
-}
-
-async function replayTransportRecord(
-  workspacePath: string,
-  recordType: 'outbox' | 'dead-letter',
-  id: string,
+async function mutateThread(
+  options: WorkgraphMcpServerOptions,
+  actorInput: string | undefined,
+  requiredCapabilities: string[],
+  threadPath: string,
+  action: () => ReturnType<typeof thread.createThread> | Promise<ReturnType<typeof thread.createThread>>,
+  summaryPrefix: string,
 ) {
-  const outbox = recordType === 'outbox'
-    ? transport.readTransportOutboxRecord(workspacePath, id)
-    : resolveDeadLetterSourceOutbox(workspacePath, id);
-  if (!outbox) {
-    throw new Error(`Transport record not found or not replayable: ${recordType}/${id}`);
+  try {
+    const actor = resolveActor(options.workspacePath, actorInput, options.defaultActor);
+    const gate = checkWriteGate(options, actor, requiredCapabilities, {
+      action: `mcp.thread.${summaryPrefix.toLowerCase().replace(/\s+/g, '-')}`,
+      target: threadPath,
+    });
+    if (!gate.allowed) return errorResult(gate.reason);
+    const updated = await action();
+    return okResult({ thread: updated }, `${summaryPrefix} ${updated.path}.`);
+  } catch (error) {
+    return errorResult(error);
   }
-  const replayed = await transport.replayTransportOutboxRecord(workspacePath, outbox.id, async (record) => {
-    if (record.deliveryHandler === 'dashboard-webhook') {
-      await replayDashboardWebhook(record);
-      return;
-    }
-    if (record.deliveryHandler === 'runtime-bridge') {
-      await replayRuntimeBridge(workspacePath, record);
-      return;
-    }
-    if (record.deliveryHandler === 'trigger-action') {
-      await replayTriggerAction(workspacePath, record);
-      return;
-    }
-    throw new Error(`Unsupported transport replay handler "${record.deliveryHandler}".`);
-  });
-  if (!replayed) {
-    throw new Error(`Transport outbox record not found: ${outbox.id}`);
-  }
-  if (recordType === 'dead-letter') {
-    transport.markTransportDeadLetterReplayed(workspacePath, id);
-  }
-  return replayed;
 }
 
-function resolveDeadLetterSourceOutbox(
+function updateThreadStatus(
   workspacePath: string,
-  id: string,
+  args: {
+    threadPath: string;
+    status: z.infer<typeof threadStatusSchema>;
+    reason?: string;
+    output?: string;
+    blockedBy?: string;
+    leaseMinutes?: number;
+  },
+  actor: string,
 ) {
-  const deadLetter = transport.readTransportDeadLetter(workspacePath, id);
-  if (!deadLetter) return null;
-  if (deadLetter.sourceRecordType !== 'outbox') {
-    throw new Error(`Dead-letter record ${id} is not replayable from source type "${deadLetter.sourceRecordType}".`);
-  }
-  return transport.readTransportOutboxRecord(workspacePath, deadLetter.sourceRecordId);
-}
-
-async function replayDashboardWebhook(record: ReturnType<typeof transport.readTransportOutboxRecord> extends infer T ? Exclude<T, null> : never): Promise<void> {
-  const payload = record.envelope.payload;
-  const request = payload && typeof payload === 'object' ? (payload as Record<string, unknown>).request : undefined;
-  const requestRecord = request && typeof request === 'object' ? request as Record<string, unknown> : {};
-  const url = typeof requestRecord.url === 'string' ? requestRecord.url : record.deliveryTarget;
-  const method = typeof requestRecord.method === 'string' ? requestRecord.method : 'POST';
-  const headers = requestRecord.headers && typeof requestRecord.headers === 'object'
-    ? requestRecord.headers as Record<string, string>
-    : { 'content-type': 'application/json' };
-  const body = typeof requestRecord.body === 'string'
-    ? requestRecord.body
-    : JSON.stringify(record.envelope.payload);
-  const response = await fetch(url, {
-    method,
-    headers,
-    body,
-  });
-  if (!response.ok) {
-    throw new Error(`Dashboard webhook replay failed (${response.status}).`);
+  switch (args.status) {
+    case 'open':
+      return thread.release(workspacePath, args.threadPath, actor, args.reason);
+    case 'active':
+      return thread.claim(workspacePath, args.threadPath, actor, {
+        leaseTtlMinutes: args.leaseMinutes,
+      });
+    case 'blocked':
+      return thread.block(workspacePath, args.threadPath, actor, args.blockedBy ?? 'external/manual', args.reason);
+    case 'done':
+      return thread.done(workspacePath, args.threadPath, actor, args.output);
+    case 'cancelled':
+      return thread.cancel(workspacePath, args.threadPath, actor, args.reason);
   }
 }
 
-async function replayRuntimeBridge(
-  workspacePath: string,
-  record: ReturnType<typeof transport.readTransportOutboxRecord> extends infer T ? Exclude<T, null> : never,
-): Promise<void> {
-  const payload = record.envelope.payload;
-  await cursorBridge.dispatchCursorAutomationEvent(workspacePath, {
-    source: (payload.source as 'webhook' | 'cli-dispatch' | undefined) ?? 'cli-dispatch',
-    eventId: typeof payload.eventId === 'string' ? payload.eventId : undefined,
-    eventType: typeof payload.eventType === 'string' ? payload.eventType : undefined,
-    objective: typeof payload.objective === 'string' ? payload.objective : undefined,
-    actor: typeof payload.actor === 'string' ? payload.actor : undefined,
-    adapter: typeof payload.adapter === 'string' ? payload.adapter : undefined,
-    execute: typeof payload.execute === 'boolean' ? payload.execute : undefined,
-    context: payload.context && typeof payload.context === 'object' && !Array.isArray(payload.context)
-      ? payload.context as Record<string, unknown>
-      : undefined,
-  });
-}
-
-async function replayTriggerAction(
-  workspacePath: string,
-  record: ReturnType<typeof transport.readTransportOutboxRecord> extends infer T ? Exclude<T, null> : never,
-): Promise<void> {
-  const payload = record.envelope.payload;
-  triggerEngine.replayTriggerActionDelivery(workspacePath, {
-    triggerPath: typeof payload.triggerPath === 'string' ? payload.triggerPath : record.deliveryTarget,
-    action: payload.action && typeof payload.action === 'object' && !Array.isArray(payload.action)
-      ? payload.action as Record<string, unknown>
-      : {},
-    context: payload.context && typeof payload.context === 'object' && !Array.isArray(payload.context)
-      ? payload.context as Record<string, unknown>
-      : {},
-    actor: typeof payload.actor === 'string' ? payload.actor : 'system',
-    eventKey: typeof payload.eventKey === 'string' ? payload.eventKey : undefined,
-  });
+function readNonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
 }
diff --git a/packages/mcp-server/src/projection-tools.test.ts b/packages/mcp-server/src/projection-tools.test.ts
deleted file mode 100644
index 312917e..0000000
--- a/packages/mcp-server/src/projection-tools.test.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import {
-  registry as registryModule,
-  thread as threadModule,
-} from '@versatly/workgraph-kernel';
-import { createWorkgraphMcpServer } from './mcp-server.js';
-
-const registry = registryModule;
-const thread = threadModule;
-
-let workspacePath: string;
-
-describe('projection MCP tools', () => {
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-projections-'));
-    registry.saveRegistry(workspacePath, registry.loadRegistry(workspacePath));
-    thread.createThread(workspacePath, 'Projection thread', 'projection thread goal', 'agent-projection');
-  });
-
-  afterEach(() => {
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-  });
-
-  it('exposes projection tools over MCP', async () => {
-    const server = createWorkgraphMcpServer({
-      workspacePath,
-      defaultActor: 'agent-mcp',
-    });
-    const client = new Client({
-      name: 'workgraph-mcp-projection-client',
-      version: '1.0.0',
-    });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    await Promise.all([
-      server.connect(serverTransport),
-      client.connect(clientTransport),
-    ]);
-
-    try {
-      const tools = await client.listTools();
-      const toolNames = tools.tools.map((entry) => entry.name);
-      expect(toolNames).toEqual(expect.arrayContaining([
-        'wg_run_health',
-        'wg_risk_dashboard',
-        'wg_mission_progress_projection',
-        'wg_transport_health',
-        'wg_federation_status_projection',
-        'wg_trigger_health',
-        'wg_autonomy_health',
-      ]));
-
-      const runHealth = await client.callTool({
-        name: 'wg_run_health',
-        arguments: {},
-      });
-      expect(isToolError(runHealth)).toBe(false);
-      const runHealthPayload = getStructured<{ scope: string }>(runHealth);
-      expect(runHealthPayload.scope).toBe('run');
-
-      const triggerHealth = await client.callTool({
-        name: 'wg_trigger_health',
-        arguments: {},
-      });
-      expect(isToolError(triggerHealth)).toBe(false);
-      const triggerHealthPayload = getStructured<{ scope: string }>(triggerHealth);
-      expect(triggerHealthPayload.scope).toBe('trigger');
-    } finally {
-      await client.close();
-      await server.close();
-    }
-  });
-});
-
-function getStructured<T>(result: unknown): T {
-  if (!result || typeof result !== 'object' || !('structuredContent' in result)) {
-    throw new Error('Expected structuredContent in MCP tool response.');
-  }
-  const typed = result as { structuredContent?: unknown };
-  if (!typed.structuredContent) {
-    throw new Error('Expected structuredContent in MCP tool response.');
-  }
-  return typed.structuredContent as T;
-}
-
-function isToolError(result: unknown): boolean {
-  return Boolean(result && typeof result === 'object' && 'isError' in result && (result as { isError?: boolean }).isError);
-}
diff --git a/packages/mcp-server/src/transport-tools.test.ts b/packages/mcp-server/src/transport-tools.test.ts
deleted file mode 100644
index ae3f274..0000000
--- a/packages/mcp-server/src/transport-tools.test.ts
+++ /dev/null
@@ -1,195 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import {
-  cursorBridge as cursorBridgeModule,
-  policy as policyModule,
-  registry as registryModule,
-  thread as threadModule,
-  transport as transportModule,
-  triggerEngine as triggerEngineModule,
-  store as storeModule,
-} from '@versatly/workgraph-kernel';
-import { createWorkgraphMcpServer } from './mcp-server.js';
-
-const cursorBridge = cursorBridgeModule;
-const policy = policyModule;
-const registry = registryModule;
-const store = storeModule;
-const thread = threadModule;
-const transport = transportModule;
-const triggerEngine = triggerEngineModule;
-
-let workspacePath: string;
-
-describe('transport MCP tools', () => {
-  beforeEach(() => {
-    workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-mcp-transport-'));
-    const schemaRegistry = registry.loadRegistry(workspacePath);
-    registry.saveRegistry(workspacePath, schemaRegistry);
-  });
-
-  afterEach(() => {
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-  });
-
-  it('lists transport records and replays outbox deliveries', async () => {
-    policy.upsertParty(workspacePath, 'agent-mcp', {
-      roles: ['operator'],
-      capabilities: ['mcp:write', 'dispatch:run'],
-    });
-
-    cursorBridge.setupCursorBridge(workspacePath, {
-      actor: 'cursor-ops',
-      enabled: true,
-      allowedEventTypes: ['*'],
-      dispatch: {
-        adapter: 'cursor-cloud',
-        execute: false,
-      },
-    });
-    await cursorBridge.dispatchCursorAutomationEvent(workspacePath, {
-      eventType: 'cursor.automation.manual',
-      eventId: 'evt-transport-1',
-      objective: 'Replay runtime bridge transport',
-    });
-
-    const failedEnvelope = transport.createTransportEnvelope({
-      direction: 'outbound',
-      channel: 'dashboard-webhook',
-      topic: 'thread.done',
-      source: 'test',
-      target: 'https://hooks.example/fail',
-      dedupKeys: ['failed-outbox'],
-      payload: {
-        request: {
-          url: 'https://hooks.example/fail',
-          method: 'POST',
-          headers: {
-            'content-type': 'application/json',
-          },
-          body: '{}',
-        },
-      },
-    });
-    const failedOutbox = transport.createTransportOutboxRecord(workspacePath, {
-      envelope: failedEnvelope,
-      deliveryHandler: 'dashboard-webhook',
-      deliveryTarget: 'https://hooks.example/fail',
-    });
-    transport.markTransportOutboxFailed(workspacePath, failedOutbox.id, {
-      message: 'synthetic failure',
-    });
-
-    store.create(workspacePath, 'trigger', {
-      title: 'Replayable trigger action',
-      status: 'active',
-      condition: { type: 'event', event: 'thread-complete' },
-      action: {
-        type: 'dispatch-run',
-        objective: 'Replay dispatch {{matched_event_latest_target}}',
-      },
-      cooldown: 0,
-    }, '# Trigger\n', 'system');
-    const sourceOne = thread.createThread(workspacePath, 'Replay seed', 'seed event', 'agent-seed');
-    thread.claim(workspacePath, sourceOne.path, 'agent-seed');
-    thread.done(workspacePath, sourceOne.path, 'agent-seed', 'seed done https://github.com/versatly/workgraph/pull/100');
-    triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    const sourceTwo = thread.createThread(workspacePath, 'Replay seed 2', 'second event', 'agent-seed');
-    thread.claim(workspacePath, sourceTwo.path, 'agent-seed');
-    thread.done(workspacePath, sourceTwo.path, 'agent-seed', 'seed 2 done https://github.com/versatly/workgraph/pull/101');
-    triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    const triggerActionOutbox = transport.listTransportOutbox(workspacePath)
-      .find((record) => record.deliveryHandler === 'trigger-action');
-    expect(triggerActionOutbox).toBeDefined();
-
-    const server = createWorkgraphMcpServer({
-      workspacePath,
-      defaultActor: 'agent-mcp',
-    });
-    const client = new Client({
-      name: 'workgraph-mcp-transport-client',
-      version: '1.0.0',
-    });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    await Promise.all([
-      server.connect(serverTransport),
-      client.connect(clientTransport),
-    ]);
-
-    try {
-      const tools = await client.listTools();
-      const toolNames = tools.tools.map((entry) => entry.name);
-      expect(toolNames).toContain('wg_transport_outbox_list');
-      expect(toolNames).toContain('wg_transport_inbox_list');
-      expect(toolNames).toContain('wg_transport_dead_letter_list');
-      expect(toolNames).toContain('wg_transport_replay');
-
-      const outbox = await client.callTool({
-        name: 'wg_transport_outbox_list',
-        arguments: {},
-      });
-      expect(isToolError(outbox)).toBe(false);
-      const outboxPayload = getStructured<{ count: number; records: Array<{ id: string }> }>(outbox);
-      expect(outboxPayload.count).toBeGreaterThanOrEqual(2);
-
-      const deadLetter = await client.callTool({
-        name: 'wg_transport_dead_letter_list',
-        arguments: {},
-      });
-      expect(isToolError(deadLetter)).toBe(false);
-      const deadLetterPayload = getStructured<{ count: number; records: Array<{ sourceRecordId: string }> }>(deadLetter);
-      expect(deadLetterPayload.count).toBe(1);
-      expect(deadLetterPayload.records[0]?.sourceRecordId).toBe(failedOutbox.id);
-
-      const runtimeBridgeOutbox = transport.listTransportOutbox(workspacePath)
-        .find((record) => record.deliveryHandler === 'runtime-bridge');
-      expect(runtimeBridgeOutbox).toBeDefined();
-
-      const replayed = await client.callTool({
-        name: 'wg_transport_replay',
-        arguments: {
-          actor: 'agent-mcp',
-          recordType: 'outbox',
-          id: runtimeBridgeOutbox!.id,
-        },
-      });
-      expect(isToolError(replayed)).toBe(false);
-      const replayedPayload = getStructured<{ status: string }>(replayed);
-      expect(replayedPayload.status).toBe('replayed');
-
-      const replayedTrigger = await client.callTool({
-        name: 'wg_transport_replay',
-        arguments: {
-          actor: 'agent-mcp',
-          recordType: 'outbox',
-          id: triggerActionOutbox!.id,
-        },
-      });
-      expect(isToolError(replayedTrigger)).toBe(false);
-      const replayedTriggerPayload = getStructured<{ status: string }>(replayedTrigger);
-      expect(replayedTriggerPayload.status).toBe('replayed');
-    } finally {
-      await client.close();
-      await server.close();
-    }
-  });
-});
-
-function isToolError(result: unknown): boolean {
-  return Boolean(result && typeof result === 'object' && 'isError' in result && (result as { isError?: boolean }).isError);
-}
-
-function getStructured<T>(result: unknown): T {
-  if (!result || typeof result !== 'object' || !('structuredContent' in result)) {
-    throw new Error('Expected structuredContent in MCP tool response.');
-  }
-  const typed = result as { structuredContent?: unknown };
-  if (!typed.structuredContent) {
-    throw new Error('Expected structuredContent in MCP tool response.');
-  }
-  return typed.structuredContent as T;
-}
diff --git a/packages/obsidian-integration/package.json b/packages/obsidian-integration/package.json
deleted file mode 100644
index e535ab1..0000000
--- a/packages/obsidian-integration/package.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "name": "@versatly/workgraph-obsidian-integration",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-kernel": "workspace:*",
-    "yaml": "^2.8.1"
-  }
-}
diff --git a/packages/obsidian-integration/src/bases.ts b/packages/obsidian-integration/src/bases.ts
deleted file mode 100644
index 0211ed7..0000000
--- a/packages/obsidian-integration/src/bases.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-/**
- * Primitive registry manifest + Obsidian Bases generation.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import YAML from 'yaml';
-import { registry as registryModule } from '@versatly/workgraph-kernel';
-
-const { loadRegistry } = registryModule;
-
-export interface PrimitiveRegistryManifestField {
-  name: string;
-  type: string;
-  required?: boolean;
-  description?: string;
-}
-
-export interface PrimitiveRegistryManifestPrimitive {
-  name: string;
-  directory: string;
-  canonical: boolean;
-  builtIn: boolean;
-  fields: PrimitiveRegistryManifestField[];
-}
-
-export interface PrimitiveRegistryManifest {
-  version: number;
-  generatedAt: string;
-  primitives: PrimitiveRegistryManifestPrimitive[];
-}
-
-export interface GenerateBasesOptions {
-  includeNonCanonical?: boolean;
-  outputDirectory?: string;
-}
-
-export interface GenerateBasesResult {
-  outputDirectory: string;
-  generated: string[];
-}
-
-const REGISTRY_MANIFEST_FILE = '.workgraph/primitive-registry.yaml';
-const DEFAULT_BASES_DIR = '.workgraph/bases';
-
-export function primitiveRegistryManifestPath(workspacePath: string): string {
-  return path.join(workspacePath, REGISTRY_MANIFEST_FILE);
-}
-
-export function readPrimitiveRegistryManifest(workspacePath: string): PrimitiveRegistryManifest {
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  if (!fs.existsSync(manifestPath)) {
-    throw new Error(`Primitive registry manifest not found: ${manifestPath}`);
-  }
-  const raw = fs.readFileSync(manifestPath, 'utf-8');
-  return YAML.parse(raw) as PrimitiveRegistryManifest;
-}
-
-export function syncPrimitiveRegistryManifest(workspacePath: string): PrimitiveRegistryManifest {
-  const registry = loadRegistry(workspacePath);
-  const manifest: PrimitiveRegistryManifest = {
-    version: 1,
-    generatedAt: new Date().toISOString(),
-    primitives: Object.values(registry.types)
-      .map((primitive) => ({
-        name: primitive.name,
-        directory: primitive.directory,
-        canonical: primitive.builtIn,
-        builtIn: primitive.builtIn,
-        fields: Object.entries(primitive.fields).map(([name, field]) => ({
-          name,
-          type: field.type,
-          ...(field.required ? { required: true } : {}),
-          ...(field.description ? { description: field.description } : {}),
-        })),
-      }))
-      .sort((a, b) => a.name.localeCompare(b.name)),
-  };
-
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  ensureDirectory(path.dirname(manifestPath));
-  fs.writeFileSync(manifestPath, YAML.stringify(manifest), 'utf-8');
-  return manifest;
-}
-
-export function generateBasesFromPrimitiveRegistry(
-  workspacePath: string,
-  options: GenerateBasesOptions = {},
-): GenerateBasesResult {
-  const manifest = readPrimitiveRegistryManifest(workspacePath);
-  const includeNonCanonical = options.includeNonCanonical === true;
-  const outputDirectory = path.join(workspacePath, options.outputDirectory ?? DEFAULT_BASES_DIR);
-  ensureDirectory(outputDirectory);
-
-  const generated: string[] = [];
-  const primitives = manifest.primitives.filter((primitive) =>
-    includeNonCanonical ? true : primitive.canonical
-  );
-
-  for (const primitive of primitives) {
-    const relBasePath = `${primitive.name}.base`;
-    const absBasePath = path.join(outputDirectory, relBasePath);
-    const content = renderBaseFile(primitive);
-    fs.writeFileSync(absBasePath, content, 'utf-8');
-    generated.push(path.relative(workspacePath, absBasePath).replace(/\\/g, '/'));
-  }
-
-  return {
-    outputDirectory: path.relative(workspacePath, outputDirectory).replace(/\\/g, '/'),
-    generated: generated.sort(),
-  };
-}
-
-function renderBaseFile(primitive: PrimitiveRegistryManifestPrimitive): string {
-  const columnFields = primitive.fields
-    .map((field) => field.name)
-    .filter((name, idx, arr) => arr.indexOf(name) === idx);
-
-  const baseDoc = {
-    id: primitive.name,
-    title: `${titleCase(primitive.name)} Base`,
-    source: {
-      type: 'folder',
-      path: primitive.directory,
-      extension: 'md',
-    },
-    views: [
-      {
-        id: 'table',
-        type: 'table',
-        name: 'All',
-        columns: ['file.name', ...columnFields],
-      },
-    ],
-  };
-
-  return YAML.stringify(baseDoc);
-}
-
-function ensureDirectory(dirPath: string): void {
-  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
-}
-
-function titleCase(value: string): string {
-  return value
-    .split(/[-_]/g)
-    .filter(Boolean)
-    .map((segment) => segment[0].toUpperCase() + segment.slice(1))
-    .join(' ');
-}
diff --git a/packages/obsidian-integration/src/board.ts b/packages/obsidian-integration/src/board.ts
deleted file mode 100644
index 449ff44..0000000
--- a/packages/obsidian-integration/src/board.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-/**
- * Obsidian Kanban board generation and sync helpers.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { store as storeModule, type PrimitiveInstance } from '@versatly/workgraph-kernel';
-
-const store = storeModule;
-
-export interface BoardOptions {
-  outputPath?: string;
-  includeCancelled?: boolean;
-}
-
-export interface BoardResult {
-  outputPath: string;
-  generatedAt: string;
-  counts: {
-    backlog: number;
-    inProgress: number;
-    blocked: number;
-    done: number;
-    cancelled: number;
-  };
-  content: string;
-}
-
-export function generateKanbanBoard(workspacePath: string, options: BoardOptions = {}): BoardResult {
-  const threads = store.list(workspacePath, 'thread');
-  const grouped = groupThreads(threads);
-  const includeCancelled = options.includeCancelled === true;
-
-  const lanes: Array<{ title: string; items: PrimitiveInstance[]; checkChar: string }> = [
-    { title: 'Backlog', items: grouped.open, checkChar: ' ' },
-    { title: 'In Progress', items: grouped.active, checkChar: ' ' },
-    { title: 'Blocked', items: grouped.blocked, checkChar: ' ' },
-    { title: 'Done', items: grouped.done, checkChar: 'x' },
-  ];
-  if (includeCancelled) {
-    lanes.push({ title: 'Cancelled', items: grouped.cancelled, checkChar: 'x' });
-  }
-
-  const content = renderKanbanMarkdown(lanes);
-  const relOutputPath = options.outputPath ?? 'ops/Workgraph Board.md';
-  const absOutputPath = resolvePathWithinWorkspace(workspacePath, relOutputPath);
-  const parentDir = path.dirname(absOutputPath);
-  if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
-  fs.writeFileSync(absOutputPath, content, 'utf-8');
-
-  return {
-    outputPath: path.relative(workspacePath, absOutputPath).replace(/\\/g, '/'),
-    generatedAt: new Date().toISOString(),
-    counts: {
-      backlog: grouped.open.length,
-      inProgress: grouped.active.length,
-      blocked: grouped.blocked.length,
-      done: grouped.done.length,
-      cancelled: grouped.cancelled.length,
-    },
-    content,
-  };
-}
-
-export function syncKanbanBoard(workspacePath: string, options: BoardOptions = {}): BoardResult {
-  return generateKanbanBoard(workspacePath, options);
-}
-
-function groupThreads(threads: PrimitiveInstance[]): Record<'open' | 'active' | 'blocked' | 'done' | 'cancelled', PrimitiveInstance[]> {
-  const groups = {
-    open: [] as PrimitiveInstance[],
-    active: [] as PrimitiveInstance[],
-    blocked: [] as PrimitiveInstance[],
-    done: [] as PrimitiveInstance[],
-    cancelled: [] as PrimitiveInstance[],
-  };
-
-  for (const thread of threads) {
-    const status = String(thread.fields.status ?? 'open');
-    switch (status) {
-      case 'active':
-        groups.active.push(thread);
-        break;
-      case 'blocked':
-        groups.blocked.push(thread);
-        break;
-      case 'done':
-        groups.done.push(thread);
-        break;
-      case 'cancelled':
-        groups.cancelled.push(thread);
-        break;
-      case 'open':
-      default:
-        groups.open.push(thread);
-        break;
-    }
-  }
-
-  const byPriority = (a: PrimitiveInstance, b: PrimitiveInstance): number => {
-    const rank = (value: unknown): number => {
-      switch (String(value ?? 'medium')) {
-        case 'urgent': return 0;
-        case 'high': return 1;
-        case 'medium': return 2;
-        case 'low': return 3;
-        default: return 4;
-      }
-    };
-    return rank(a.fields.priority) - rank(b.fields.priority) || String(a.fields.title).localeCompare(String(b.fields.title));
-  };
-
-  groups.open.sort(byPriority);
-  groups.active.sort(byPriority);
-  groups.blocked.sort(byPriority);
-  groups.done.sort(byPriority);
-  groups.cancelled.sort(byPriority);
-  return groups;
-}
-
-function renderKanbanMarkdown(lanes: Array<{ title: string; items: PrimitiveInstance[]; checkChar: string }>): string {
-  const settings = {
-    'kanban-plugin': 'board',
-  };
-  const lines: string[] = [
-    '---',
-    'kanban-plugin: board',
-    '---',
-    '',
-  ];
-
-  for (const lane of lanes) {
-    lines.push(`## ${lane.title}`);
-    lines.push('');
-    for (const thread of lane.items) {
-      const title = String(thread.fields.title ?? thread.path);
-      const priority = String(thread.fields.priority ?? 'medium');
-      lines.push(`- [${lane.checkChar}] [[${thread.path}|${title}]] (#${priority})`);
-    }
-    lines.push('');
-    lines.push('');
-    lines.push('');
-  }
-
-  lines.push('%% kanban:settings');
-  lines.push('```');
-  lines.push(JSON.stringify(settings));
-  lines.push('```');
-  lines.push('%%');
-  lines.push('');
-  return lines.join('\n');
-}
-
-function resolvePathWithinWorkspace(workspacePath: string, outputPath: string): string {
-  const base = path.resolve(workspacePath);
-  const resolved = path.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path.sep) && resolved !== base) {
-    throw new Error(`Invalid board output path: ${outputPath}`);
-  }
-  return resolved;
-}
diff --git a/packages/obsidian-integration/src/graph/health.ts b/packages/obsidian-integration/src/graph/health.ts
deleted file mode 100644
index 8b522d6..0000000
--- a/packages/obsidian-integration/src/graph/health.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { graph as graphModule } from '@versatly/workgraph-kernel';
-
-export const { graphHygieneReport } = graphModule;
diff --git a/packages/obsidian-integration/src/index.ts b/packages/obsidian-integration/src/index.ts
deleted file mode 100644
index fe71313..0000000
--- a/packages/obsidian-integration/src/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export * as board from './board.js';
-export { graph } from '@versatly/workgraph-kernel';
-export * as bases from './bases.js';
-export * from './board.js';
-export * from './bases.js';
-export * as kanbanRender from './kanban/render.js';
-export * as kanbanSync from './kanban/sync.js';
-export * as graphHealth from './graph/health.js';
diff --git a/packages/obsidian-integration/src/kanban/render.ts b/packages/obsidian-integration/src/kanban/render.ts
deleted file mode 100644
index 6fd5b0d..0000000
--- a/packages/obsidian-integration/src/kanban/render.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { generateKanbanBoard } from '../board.js';
diff --git a/packages/obsidian-integration/src/kanban/sync.ts b/packages/obsidian-integration/src/kanban/sync.ts
deleted file mode 100644
index 9604b6d..0000000
--- a/packages/obsidian-integration/src/kanban/sync.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { syncKanbanBoard } from '../board.js';
diff --git a/packages/obsidian-integration/tsconfig.json b/packages/obsidian-integration/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/obsidian-integration/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/policy/package.json b/packages/policy/package.json
deleted file mode 100644
index 7f680b9..0000000
--- a/packages/policy/package.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "name": "@versatly/workgraph-policy",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts"
-}
diff --git a/packages/policy/src/contracts.ts b/packages/policy/src/contracts.ts
deleted file mode 100644
index f1a50bc..0000000
--- a/packages/policy/src/contracts.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-export interface GateCheckInput {
-  actor: string;
-  primitiveType: string;
-  fromStatus?: string;
-  toStatus?: string;
-}
-
-export interface GateCheckDecision {
-  allowed: boolean;
-  reason?: string;
-}
diff --git a/packages/policy/src/gates.ts b/packages/policy/src/gates.ts
deleted file mode 100644
index 3c513b9..0000000
--- a/packages/policy/src/gates.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { GateCheckDecision } from './contracts.js';
-import { getParty } from './registry.js';
-
-const SENSITIVE_TYPES = new Set(['decision', 'policy', 'incident', 'trigger']);
-
-export function canTransitionStatus(
-  workspacePath: string,
-  actor: string,
-  primitiveType: string,
-  fromStatus: string | undefined,
-  toStatus: string | undefined,
-): GateCheckDecision {
-  if (!fromStatus || !toStatus || fromStatus === toStatus) {
-    return { allowed: true };
-  }
-
-  if (!SENSITIVE_TYPES.has(primitiveType)) {
-    return { allowed: true };
-  }
-
-  if (actor === 'system') {
-    return { allowed: true };
-  }
-
-  const needsPromotionCapability = ['approved', 'active'].includes(toStatus);
-  if (!needsPromotionCapability) {
-    return { allowed: true };
-  }
-
-  const party = getParty(workspacePath, actor);
-  if (!party) {
-    return {
-      allowed: false,
-      reason: `Policy gate blocked transition ${primitiveType}:${fromStatus}->${toStatus}; actor "${actor}" is not a registered party.`,
-    };
-  }
-
-  const requiredCapabilities = [
-    `promote:${primitiveType}`,
-    'promote:sensitive',
-  ];
-  const hasCapability = requiredCapabilities.some((capability) => party.capabilities.includes(capability));
-  if (!hasCapability) {
-    return {
-      allowed: false,
-      reason: `Policy gate blocked transition ${primitiveType}:${fromStatus}->${toStatus}; actor "${actor}" lacks required capabilities (${requiredCapabilities.join(' or ')}).`,
-    };
-  }
-
-  return { allowed: true };
-}
diff --git a/packages/policy/src/index.ts b/packages/policy/src/index.ts
deleted file mode 100644
index f7a12cb..0000000
--- a/packages/policy/src/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './contracts.js';
-export * from './types.js';
-export * from './registry.js';
-export * from './gates.js';
diff --git a/packages/policy/src/policy-registry.test.ts b/packages/policy/src/policy-registry.test.ts
deleted file mode 100644
index 22f1a89..0000000
--- a/packages/policy/src/policy-registry.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { canTransitionStatus } from './gates.js';
-import { getParty, loadPolicyRegistry, policyPath, upsertParty } from './registry.js';
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-policy-package-'));
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('packages/policy registry + gates', () => {
-  it('seeds and persists policy registry inside workspace', () => {
-    const registry = loadPolicyRegistry(workspacePath);
-    expect(registry.version).toBe(1);
-    expect(registry.parties.system).toBeDefined();
-    expect(fs.existsSync(policyPath(workspacePath))).toBe(true);
-  });
-
-  it('upserts and reads party capabilities', () => {
-    const party = upsertParty(workspacePath, 'agent-policy', {
-      roles: ['operator'],
-      capabilities: ['promote:sensitive'],
-    });
-    expect(party.id).toBe('agent-policy');
-    expect(party.roles).toEqual(['operator']);
-    expect(party.capabilities).toEqual(['promote:sensitive']);
-
-    const fetched = getParty(workspacePath, 'agent-policy');
-    expect(fetched?.id).toBe('agent-policy');
-  });
-
-  it('enforces sensitive transition capabilities', () => {
-    const denied = canTransitionStatus(
-      workspacePath,
-      'agent-unregistered',
-      'policy',
-      'draft',
-      'approved',
-    );
-    expect(denied.allowed).toBe(false);
-    expect(denied.reason).toContain('not a registered party');
-
-    upsertParty(workspacePath, 'agent-policy', {
-      roles: ['operator'],
-      capabilities: ['promote:sensitive'],
-    });
-    const allowed = canTransitionStatus(
-      workspacePath,
-      'agent-policy',
-      'policy',
-      'draft',
-      'approved',
-    );
-    expect(allowed.allowed).toBe(true);
-  });
-});
diff --git a/packages/policy/src/registry.ts b/packages/policy/src/registry.ts
deleted file mode 100644
index f623b48..0000000
--- a/packages/policy/src/registry.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import type { PolicyParty, PolicyRegistry } from './types.js';
-
-const POLICY_FILE = '.workgraph/policy.json';
-const POLICY_VERSION = 1;
-
-export function policyPath(workspacePath: string): string {
-  return path.join(workspacePath, POLICY_FILE);
-}
-
-export function loadPolicyRegistry(workspacePath: string): PolicyRegistry {
-  const targetPath = policyPath(workspacePath);
-  if (!fs.existsSync(targetPath)) {
-    const seeded = seedPolicyRegistry();
-    savePolicyRegistry(workspacePath, seeded);
-    return seeded;
-  }
-
-  try {
-    const parsed = JSON.parse(fs.readFileSync(targetPath, 'utf-8')) as Partial<PolicyRegistry>;
-    if (!parsed.version || !parsed.parties) {
-      return seedPolicyRegistry();
-    }
-    return parsed as PolicyRegistry;
-  } catch {
-    return seedPolicyRegistry();
-  }
-}
-
-export function savePolicyRegistry(workspacePath: string, registry: PolicyRegistry): void {
-  const targetPath = policyPath(workspacePath);
-  const directory = path.dirname(targetPath);
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  fs.writeFileSync(targetPath, `${JSON.stringify(registry, null, 2)}\n`, 'utf-8');
-}
-
-export function upsertParty(
-  workspacePath: string,
-  partyId: string,
-  updates: {
-    roles?: string[];
-    capabilities?: string[];
-  },
-): PolicyParty {
-  const registry = loadPolicyRegistry(workspacePath);
-  const now = new Date().toISOString();
-  const existing = registry.parties[partyId];
-  const next: PolicyParty = {
-    id: partyId,
-    roles: updates.roles ?? existing?.roles ?? [],
-    capabilities: updates.capabilities ?? existing?.capabilities ?? [],
-    createdAt: existing?.createdAt ?? now,
-    updatedAt: now,
-  };
-  registry.parties[partyId] = next;
-  savePolicyRegistry(workspacePath, registry);
-  return next;
-}
-
-export function getParty(workspacePath: string, partyId: string): PolicyParty | null {
-  const registry = loadPolicyRegistry(workspacePath);
-  return registry.parties[partyId] ?? null;
-}
-
-function seedPolicyRegistry(): PolicyRegistry {
-  const now = new Date().toISOString();
-  return {
-    version: POLICY_VERSION,
-    parties: {
-      system: {
-        id: 'system',
-        roles: ['admin'],
-        capabilities: ['promote:sensitive', 'dispatch:run', 'policy:manage'],
-        createdAt: now,
-        updatedAt: now,
-      },
-    },
-  };
-}
diff --git a/packages/policy/src/types.ts b/packages/policy/src/types.ts
deleted file mode 100644
index 445578f..0000000
--- a/packages/policy/src/types.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-export interface PolicyParty {
-  id: string;
-  roles: string[];
-  capabilities: string[];
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface PolicyRegistry {
-  version: number;
-  parties: Record<string, PolicyParty>;
-}
diff --git a/packages/policy/tsconfig.json b/packages/policy/tsconfig.json
deleted file mode 100644
index 31fe328..0000000
--- a/packages/policy/tsconfig.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "src"
-  },
-  "include": [
-    "src/**/*"
-  ]
-}
diff --git a/packages/runtime-adapter-core/package.json b/packages/runtime-adapter-core/package.json
deleted file mode 100644
index dec3fb7..0000000
--- a/packages/runtime-adapter-core/package.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "name": "@versatly/workgraph-runtime-adapter-core",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-adapter-claude-code": "workspace:*",
-    "@versatly/workgraph-adapter-cursor-cloud": "workspace:*",
-    "@versatly/workgraph-adapter-http-webhook": "workspace:*",
-    "@versatly/workgraph-adapter-shell-worker": "workspace:*",
-    "@versatly/workgraph-kernel": "workspace:*"
-  }
-}
diff --git a/packages/runtime-adapter-core/src/adapter-registry.test.ts b/packages/runtime-adapter-core/src/adapter-registry.test.ts
deleted file mode 100644
index dc0e9bc..0000000
--- a/packages/runtime-adapter-core/src/adapter-registry.test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { DispatchAdapter } from './contracts.js';
-import {
-  findDispatchAdapter,
-  listDispatchAdapters,
-  registerDispatchAdapter,
-  registerDispatchAdaptersIntoKernelRegistry,
-  resolveDispatchAdapter,
-} from './adapter-registry.js';
-
-let customCounter = 0;
-
-function nextAdapterName(): string {
-  customCounter += 1;
-  return `runtime-core-custom-${customCounter}`;
-}
-
-function makeAdapter(name: string): DispatchAdapter {
-  return {
-    name,
-    async create() {
-      return { runId: `${name}-run`, status: 'queued' };
-    },
-    async status(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async followup(runId: string) {
-      return { runId, status: 'running' };
-    },
-    async stop(runId: string) {
-      return { runId, status: 'cancelled' };
-    },
-    async logs() {
-      return [];
-    },
-  };
-}
-
-describe('runtime adapter core registry', () => {
-  it('lists built-in adapters in sorted order', () => {
-    const names = listDispatchAdapters();
-    expect(names).toEqual([...names].sort((a, b) => a.localeCompare(b)));
-    expect(names).toEqual(expect.arrayContaining([
-      'shell-subprocess',
-      'webhook',
-    ]));
-  });
-
-  it('finds and resolves built-in adapters with normalized names', () => {
-    const found = findDispatchAdapter('  WEBHOOK ');
-    const resolved = resolveDispatchAdapter(' shell-subprocess ');
-
-    expect(found?.name).toBe('webhook');
-    expect(resolved.name).toBe('shell-subprocess');
-  });
-
-  it('registers and resolves custom adapters through normalized names', () => {
-    const adapterName = nextAdapterName();
-    const factory = vi.fn(() => makeAdapter(adapterName));
-
-    registerDispatchAdapter(`  ${adapterName.toUpperCase()} `, factory);
-    const resolvedA = resolveDispatchAdapter(adapterName);
-    const resolvedB = findDispatchAdapter(` ${adapterName.toUpperCase()} `);
-
-    expect(factory).toHaveBeenCalledTimes(2);
-    expect(resolvedA.name).toBe(adapterName);
-    expect(resolvedB?.name).toBe(adapterName);
-    expect(listDispatchAdapters()).toContain(adapterName);
-  });
-
-  it('throws a helpful error for unknown adapters', () => {
-    expect(() => resolveDispatchAdapter('adapter-that-does-not-exist')).toThrow(
-      'Unknown dispatch adapter "adapter-that-does-not-exist".',
-    );
-  });
-
-  it('registers all adapters into kernel runtime registry', () => {
-    const registered = registerDispatchAdaptersIntoKernelRegistry();
-    expect(registered).toEqual(expect.arrayContaining(['shell-subprocess', 'webhook']));
-  });
-});
diff --git a/packages/runtime-adapter-core/src/adapter-registry.ts b/packages/runtime-adapter-core/src/adapter-registry.ts
deleted file mode 100644
index 271d359..0000000
--- a/packages/runtime-adapter-core/src/adapter-registry.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { runtimeAdapterRegistry } from '@versatly/workgraph-kernel';
-import type { DispatchAdapter } from './contracts.js';
-import { ShellSubprocessAdapter } from './shell-adapter.js';
-import { WebhookDispatchAdapter } from './webhook-adapter.js';
-
-export type DispatchAdapterFactory = () => DispatchAdapter;
-
-const adapterFactories = new Map<string, DispatchAdapterFactory>([
-  ['shell-subprocess', () => new ShellSubprocessAdapter()],
-  ['webhook', () => new WebhookDispatchAdapter()],
-]);
-
-export function registerDispatchAdapter(name: string, factory: DispatchAdapterFactory): void {
-  const safeName = normalizeName(name);
-  if (!safeName) {
-    throw new Error('Adapter name must be a non-empty string.');
-  }
-  adapterFactories.set(safeName, factory);
-}
-
-export function findDispatchAdapter(name: string): DispatchAdapter | undefined {
-  const safeName = normalizeName(name);
-  if (!safeName) return undefined;
-  const factory = adapterFactories.get(safeName);
-  return factory ? factory() : undefined;
-}
-
-export function resolveDispatchAdapter(name: string): DispatchAdapter {
-  const safeName = normalizeName(name);
-  const adapter = findDispatchAdapter(safeName);
-  if (!adapter) {
-    throw new Error(`Unknown dispatch adapter "${name}". Registered adapters: ${listDispatchAdapters().join(', ') || 'none'}.`);
-  }
-  return adapter;
-}
-
-export function listDispatchAdapters(): string[] {
-  return [...adapterFactories.keys()].sort((a, b) => a.localeCompare(b));
-}
-
-export function registerDispatchAdaptersIntoKernelRegistry(): string[] {
-  const registered = listDispatchAdapters();
-  for (const name of registered) {
-    runtimeAdapterRegistry.registerDispatchAdapter(name, () => resolveDispatchAdapter(name));
-  }
-  return registered;
-}
-
-function normalizeName(name: string): string {
-  return String(name || '').trim().toLowerCase();
-}
diff --git a/packages/runtime-adapter-core/src/contracts.ts b/packages/runtime-adapter-core/src/contracts.ts
deleted file mode 100644
index b2e9ee5..0000000
--- a/packages/runtime-adapter-core/src/contracts.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-export type RunStatus =
-  | 'queued'
-  | 'running'
-  | 'succeeded'
-  | 'failed'
-  | 'cancelled';
-
-export interface DispatchAdapterCreateInput {
-  actor: string;
-  objective: string;
-  idempotencyKey?: string;
-  context?: Record<string, unknown>;
-}
-
-export interface DispatchAdapterRunStatus {
-  runId: string;
-  status: RunStatus;
-}
-
-export interface DispatchAdapterExternalIdentity {
-  provider: string;
-  externalRunId: string;
-  externalAgentId?: string;
-  externalThreadId?: string;
-  correlationKeys?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface DispatchAdapterLogEntry {
-  ts: string;
-  level: 'info' | 'warn' | 'error';
-  message: string;
-}
-
-export interface DispatchAdapterExecutionInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  agents?: string[];
-  maxSteps?: number;
-  stepDelayMs?: number;
-  space?: string;
-  createCheckpoint?: boolean;
-  isCancelled?: () => boolean;
-  onHeartbeat?: () => Promise<void> | void;
-  abortSignal?: AbortSignal;
-  heartbeatIntervalMs?: number;
-}
-
-export interface DispatchAdapterExecutionResult {
-  status: RunStatus;
-  output?: string;
-  error?: string;
-  logs: DispatchAdapterLogEntry[];
-  metrics?: Record<string, unknown>;
-}
-
-export interface DispatchAdapterDispatchInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  followups?: Array<{
-    ts: string;
-    actor: string;
-    input: string;
-  }>;
-  external?: DispatchAdapterExternalIdentity;
-  abortSignal?: AbortSignal;
-}
-
-export interface DispatchAdapterExternalUpdate {
-  status?: RunStatus;
-  output?: string;
-  error?: string;
-  logs?: DispatchAdapterLogEntry[];
-  metrics?: Record<string, unknown>;
-  external?: DispatchAdapterExternalIdentity;
-  acknowledged?: boolean;
-  acknowledgedAt?: string;
-  lastKnownAt?: string;
-  metadata?: Record<string, unknown>;
-  message?: string;
-}
-
-export interface DispatchAdapterPollInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  external: DispatchAdapterExternalIdentity;
-  abortSignal?: AbortSignal;
-}
-
-export interface DispatchAdapterCancelInput {
-  workspacePath: string;
-  runId: string;
-  actor: string;
-  objective: string;
-  context?: Record<string, unknown>;
-  external?: DispatchAdapterExternalIdentity;
-  abortSignal?: AbortSignal;
-}
-
-export interface DispatchAdapter {
-  name: string;
-  create(input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus>;
-  status(runId: string): Promise<DispatchAdapterRunStatus>;
-  followup(runId: string, actor: string, input: string): Promise<DispatchAdapterRunStatus>;
-  stop(runId: string, actor: string): Promise<DispatchAdapterRunStatus>;
-  logs(runId: string): Promise<DispatchAdapterLogEntry[]>;
-  dispatch?(input: DispatchAdapterDispatchInput): Promise<DispatchAdapterExternalUpdate>;
-  poll?(input: DispatchAdapterPollInput): Promise<DispatchAdapterExternalUpdate | null>;
-  cancel?(input: DispatchAdapterCancelInput): Promise<DispatchAdapterExternalUpdate>;
-  reconcile?(input: DispatchAdapterPollInput & { event?: Record<string, unknown> }): Promise<DispatchAdapterExternalUpdate | null>;
-  health?(): Promise<Record<string, unknown>>;
-  execute?(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
-}
diff --git a/packages/runtime-adapter-core/src/default-composition.ts b/packages/runtime-adapter-core/src/default-composition.ts
deleted file mode 100644
index 9e100b6..0000000
--- a/packages/runtime-adapter-core/src/default-composition.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import {
-  runtimeAdapterRegistry,
-} from '@versatly/workgraph-kernel';
-import { ClaudeCodeAdapter } from '@versatly/workgraph-adapter-claude-code';
-import { CursorCloudAdapter } from '@versatly/workgraph-adapter-cursor-cloud';
-import { HttpWebhookAdapter } from '@versatly/workgraph-adapter-http-webhook';
-import { ShellWorkerAdapter } from '@versatly/workgraph-adapter-shell-worker';
-
-export function registerDefaultDispatchAdaptersIntoKernelRegistry(): string[] {
-  runtimeAdapterRegistry.registerDispatchAdapter('claude-code', () => new ClaudeCodeAdapter());
-  runtimeAdapterRegistry.registerDispatchAdapter('cursor-cloud', () => new CursorCloudAdapter());
-  runtimeAdapterRegistry.registerDispatchAdapter('http-webhook', () => new HttpWebhookAdapter());
-  runtimeAdapterRegistry.registerDispatchAdapter('shell-worker', () => new ShellWorkerAdapter());
-  return runtimeAdapterRegistry.listDispatchAdapters();
-}
diff --git a/packages/runtime-adapter-core/src/index.ts b/packages/runtime-adapter-core/src/index.ts
deleted file mode 100644
index 42066e1..0000000
--- a/packages/runtime-adapter-core/src/index.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-export * from './contracts.js';
-export * from './shell-adapter.js';
-export * from './webhook-adapter.js';
-export * from './adapter-registry.js';
-export * from './default-composition.js';
diff --git a/packages/runtime-adapter-core/src/shell-adapter.test.ts b/packages/runtime-adapter-core/src/shell-adapter.test.ts
deleted file mode 100644
index bedad95..0000000
--- a/packages/runtime-adapter-core/src/shell-adapter.test.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DispatchAdapterExecutionInput } from './contracts.js';
-import { ShellSubprocessAdapter } from './shell-adapter.js';
-
-vi.mock('node:child_process', () => ({
-  spawn: vi.fn(),
-}));
-
-import { spawn } from 'node:child_process';
-
-interface FakeChildProcess extends EventEmitter {
-  stdout: EventEmitter;
-  stderr: EventEmitter;
-  kill: ReturnType<typeof vi.fn>;
-}
-
-function makeInput(overrides: Partial<DispatchAdapterExecutionInput> = {}): DispatchAdapterExecutionInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run-shell-1',
-    actor: 'agent-shell',
-    objective: 'Test shell adapter',
-    context: {},
-    ...overrides,
-  };
-}
-
-function createFakeChildProcess(): FakeChildProcess {
-  const child = new EventEmitter() as FakeChildProcess;
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  child.kill = vi.fn(() => true) as any;
-  return child;
-}
-
-describe('ShellSubprocessAdapter', () => {
-  const spawnMock = vi.mocked(spawn);
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-    spawnMock.mockReset();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('returns failed when shell command is missing', async () => {
-    const adapter = new ShellSubprocessAdapter();
-    const result = await adapter.execute(makeInput());
-
-    expect(spawnMock).not.toHaveBeenCalled();
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('context.shell_command');
-  });
-
-  it('executes shell command successfully and captures stdout/stderr', async () => {
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      queueMicrotask(() => {
-        child.stdout.emit('data', Buffer.from('hello shell\n'));
-        child.stderr.emit('data', Buffer.from('warning line\n'));
-        child.emit('close', 0);
-      });
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    const adapter = new ShellSubprocessAdapter();
-
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'echo hello shell',
-          shell_cwd: '/tmp/shell-subprocess',
-          shell_timeout_ms: 5_000,
-          shell_env: {
-            TEST_FLAG: 'enabled',
-          },
-        },
-      }),
-    );
-
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    expect(spawnMock).toHaveBeenCalledWith(
-      'echo hello shell',
-      expect.objectContaining({
-        cwd: '/tmp/shell-subprocess',
-        shell: true,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: expect.objectContaining({
-          TEST_FLAG: 'enabled',
-        }),
-      }),
-    );
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('hello shell');
-    expect(result.output).toContain('warning line');
-    expect(result.metrics).toMatchObject({
-      adapter: 'shell-subprocess',
-      exitCode: 0,
-    });
-  });
-
-  it('returns failed result when command exits non-zero', async () => {
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      queueMicrotask(() => {
-        child.stderr.emit('data', Buffer.from('boom\n'));
-        child.emit('close', 7);
-      });
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    const adapter = new ShellSubprocessAdapter();
-
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'false',
-        },
-      }),
-    );
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('Exit code: 7');
-    expect(result.error).toContain('boom');
-  });
-
-  it('marks command as cancelled when cancellation signal is raised', async () => {
-    vi.useFakeTimers();
-    let childRef: FakeChildProcess | undefined;
-    spawnMock.mockImplementation(() => {
-      const child = createFakeChildProcess();
-      child.kill.mockImplementation(() => {
-        queueMicrotask(() => {
-          child.emit('close', 143);
-        });
-        return true;
-      });
-      childRef = child;
-      return child as unknown as ReturnType<typeof spawn>;
-    });
-    let cancelled = false;
-    const adapter = new ShellSubprocessAdapter();
-
-    const execution = adapter.execute(
-      makeInput({
-        context: {
-          shell_command: 'sleep 999',
-        },
-        isCancelled: () => cancelled,
-      }),
-    );
-    cancelled = true;
-    await vi.advanceTimersByTimeAsync(250);
-    const result = await execution;
-
-    expect(childRef?.kill).toHaveBeenCalledWith('SIGTERM');
-    expect(result.status).toBe('cancelled');
-    expect(result.output).toContain('Cancelled: yes');
-  });
-});
diff --git a/packages/runtime-adapter-core/src/shell-adapter.ts b/packages/runtime-adapter-core/src/shell-adapter.ts
deleted file mode 100644
index 03d56f4..0000000
--- a/packages/runtime-adapter-core/src/shell-adapter.ts
+++ /dev/null
@@ -1,261 +0,0 @@
-import { spawn } from 'node:child_process';
-import type {
-  DispatchAdapter,
-  DispatchAdapterCreateInput,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterLogEntry,
-  DispatchAdapterRunStatus,
-} from './contracts.js';
-
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-const MAX_CAPTURE_CHARS = 12_000;
-
-export class ShellSubprocessAdapter implements DispatchAdapter {
-  name = 'shell-subprocess';
-
-  async create(_input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus> {
-    return { runId: 'shell-subprocess-managed', status: 'queued' };
-  }
-
-  async status(runId: string): Promise<DispatchAdapterRunStatus> {
-    return { runId, status: 'running' };
-  }
-
-  async followup(runId: string, _actor: string, _input: string): Promise<DispatchAdapterRunStatus> {
-    return { runId, status: 'running' };
-  }
-
-  async stop(runId: string, _actor: string): Promise<DispatchAdapterRunStatus> {
-    return { runId, status: 'cancelled' };
-  }
-
-  async logs(_runId: string): Promise<DispatchAdapterLogEntry[]> {
-    return [];
-  }
-
-  async execute(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult> {
-    const command = readString(input.context?.shell_command);
-    if (!command) {
-      return {
-        status: 'failed',
-        error: 'shell-subprocess adapter requires context.shell_command.',
-        logs: [],
-      };
-    }
-
-    const shellCwd = readString(input.context?.shell_cwd) ?? input.workspacePath;
-    const timeoutMs = clampInt(readNumber(input.context?.shell_timeout_ms), DEFAULT_TIMEOUT_MS, 1_000, 60 * 60 * 1_000);
-    const shellEnv = readEnv(input.context?.shell_env);
-    const logs: DispatchAdapterLogEntry[] = [];
-    const startedAt = Date.now();
-    const outputParts: string[] = [];
-    const errorParts: string[] = [];
-
-    pushLog(logs, 'info', `shell-subprocess starting command: ${command}`);
-    pushLog(logs, 'info', `shell-subprocess cwd: ${shellCwd}`);
-
-    const result = await runShellCommand({
-      command,
-      cwd: shellCwd,
-      timeoutMs,
-      env: shellEnv,
-      isCancelled: input.isCancelled,
-      onStdout: (chunk) => {
-        outputParts.push(chunk);
-        pushLog(logs, 'info', `[stdout] ${chunk.trimEnd()}`);
-      },
-      onStderr: (chunk) => {
-        errorParts.push(chunk);
-        pushLog(logs, 'warn', `[stderr] ${chunk.trimEnd()}`);
-      },
-    });
-
-    const elapsedMs = Date.now() - startedAt;
-    const stdout = truncateText(outputParts.join(''), MAX_CAPTURE_CHARS);
-    const stderr = truncateText(errorParts.join(''), MAX_CAPTURE_CHARS);
-
-    if (result.cancelled) {
-      pushLog(logs, 'warn', `shell-subprocess command cancelled after ${elapsedMs}ms`);
-      return {
-        status: 'cancelled',
-        output: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, true),
-        logs,
-      };
-    }
-
-    if (result.timedOut) {
-      pushLog(logs, 'error', `shell-subprocess command timed out after ${elapsedMs}ms`);
-      return {
-        status: 'failed',
-        error: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
-        logs,
-      };
-    }
-
-    if (result.exitCode !== 0) {
-      pushLog(logs, 'error', `shell-subprocess command failed with exit code ${result.exitCode}`);
-      return {
-        status: 'failed',
-        error: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
-        logs,
-      };
-    }
-
-    pushLog(logs, 'info', `shell-subprocess command succeeded in ${elapsedMs}ms`);
-    return {
-      status: 'succeeded',
-      output: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
-      logs,
-      metrics: {
-        elapsedMs,
-        exitCode: result.exitCode,
-        adapter: this.name,
-      },
-    };
-  }
-}
-
-interface RunShellCommandOptions {
-  command: string;
-  cwd: string;
-  timeoutMs: number;
-  env: Record<string, string>;
-  isCancelled?: () => boolean;
-  onStdout: (chunk: string) => void;
-  onStderr: (chunk: string) => void;
-}
-
-interface RunShellCommandResult {
-  exitCode: number;
-  timedOut: boolean;
-  cancelled: boolean;
-}
-
-async function runShellCommand(options: RunShellCommandOptions): Promise<RunShellCommandResult> {
-  return new Promise((resolve) => {
-    const child = spawn(options.command, {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      shell: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let resolved = false;
-    let timedOut = false;
-    let cancelled = false;
-    const timeoutHandle = setTimeout(() => {
-      timedOut = true;
-      child.kill('SIGTERM');
-      setTimeout(() => child.kill('SIGKILL'), 1_500).unref();
-    }, options.timeoutMs);
-
-    const cancelWatcher = setInterval(() => {
-      if (options.isCancelled?.()) {
-        cancelled = true;
-        child.kill('SIGTERM');
-      }
-    }, 200);
-    cancelWatcher.unref();
-
-    child.stdout.on('data', (chunk: Buffer) => {
-      options.onStdout(chunk.toString('utf-8'));
-    });
-    child.stderr.on('data', (chunk: Buffer) => {
-      options.onStderr(chunk.toString('utf-8'));
-    });
-
-    child.on('close', (code) => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeoutHandle);
-      clearInterval(cancelWatcher);
-      resolve({
-        exitCode: typeof code === 'number' ? code : 1,
-        timedOut,
-        cancelled,
-      });
-    });
-
-    child.on('error', () => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeoutHandle);
-      clearInterval(cancelWatcher);
-      resolve({
-        exitCode: 1,
-        timedOut,
-        cancelled,
-      });
-    });
-  });
-}
-
-function pushLog(target: DispatchAdapterLogEntry[], level: DispatchAdapterLogEntry['level'], message: string): void {
-  target.push({
-    ts: new Date().toISOString(),
-    level,
-    message,
-  });
-}
-
-function readEnv(value: unknown): Record<string, string> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  const input = value as Record<string, unknown>;
-  const result: Record<string, string> = {};
-  for (const [key, raw] of Object.entries(input)) {
-    if (!key) continue;
-    if (raw === undefined || raw === null) continue;
-    result[key] = String(raw);
-  }
-  return result;
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function readNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function clampInt(value: number | undefined, fallback: number, min: number, max: number): number {
-  const raw = typeof value === 'number' ? Math.trunc(value) : fallback;
-  return Math.min(max, Math.max(min, raw));
-}
-
-function truncateText(value: string, limit: number): string {
-  if (value.length <= limit) return value;
-  return `${value.slice(0, limit)}\n...[truncated]`;
-}
-
-function formatShellOutput(
-  command: string,
-  exitCode: number,
-  stdout: string,
-  stderr: string,
-  elapsedMs: number,
-  cancelled: boolean,
-): string {
-  const lines = [
-    'Shell subprocess execution summary',
-    `Command: ${command}`,
-    `Exit code: ${exitCode}`,
-    `Elapsed ms: ${elapsedMs}`,
-    `Cancelled: ${cancelled ? 'yes' : 'no'}`,
-    '',
-    'STDOUT:',
-    stdout || '(empty)',
-    '',
-    'STDERR:',
-    stderr || '(empty)',
-  ];
-  return lines.join('\n');
-}
diff --git a/packages/runtime-adapter-core/src/webhook-adapter.test.ts b/packages/runtime-adapter-core/src/webhook-adapter.test.ts
deleted file mode 100644
index 14e7ed1..0000000
--- a/packages/runtime-adapter-core/src/webhook-adapter.test.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DispatchAdapterExecutionInput } from './contracts.js';
-import { WebhookDispatchAdapter } from './webhook-adapter.js';
-
-const ENV_KEYS = [
-  'WORKGRAPH_DISPATCH_WEBHOOK_URL',
-  'WORKGRAPH_DISPATCH_WEBHOOK_TOKEN',
-  'WORKGRAPH_DISPATCH_WEBHOOK_STATUS_URL',
-] as const;
-
-function makeInput(overrides: Partial<DispatchAdapterExecutionInput> = {}): DispatchAdapterExecutionInput {
-  return {
-    workspacePath: '/workspace/demo',
-    runId: 'run-webhook-1',
-    actor: 'agent-webhook',
-    objective: 'Test webhook adapter',
-    context: {},
-    ...overrides,
-  };
-}
-
-function mockResponse(options: { ok: boolean; status: number; text: string; statusText?: string }): Response {
-  return {
-    ok: options.ok,
-    status: options.status,
-    statusText: options.statusText ?? '',
-    text: async () => options.text,
-  } as Response;
-}
-
-describe('WebhookDispatchAdapter', () => {
-  const envSnapshot: Record<string, string | undefined> = {};
-  const fetchMock = vi.fn();
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-    for (const key of ENV_KEYS) {
-      envSnapshot[key] = process.env[key];
-      delete process.env[key];
-    }
-    fetchMock.mockReset();
-    vi.stubGlobal('fetch', fetchMock);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-    for (const key of ENV_KEYS) {
-      if (envSnapshot[key] === undefined) {
-        delete process.env[key];
-      } else {
-        process.env[key] = envSnapshot[key];
-      }
-    }
-  });
-
-  it('returns failed when webhook URL is missing', async () => {
-    const adapter = new WebhookDispatchAdapter();
-    const result = await adapter.execute(makeInput());
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('requires context.webhook_url');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('posts payload with headers and returns immediate terminal response', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: true,
-        status: 200,
-        text: JSON.stringify({
-          status: 'succeeded',
-          output: 'remote success',
-        }),
-      }),
-    );
-    const adapter = new WebhookDispatchAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-          webhook_token: 'token-123',
-          webhook_headers: {
-            'X-Trace-Id': 'trace-1',
-            priority: 5,
-          },
-        },
-      }),
-    );
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(fetchMock).toHaveBeenCalledWith('https://dispatch.example/runs', {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'x-trace-id': 'trace-1',
-        priority: '5',
-        authorization: 'Bearer token-123',
-      },
-      body: expect.any(String),
-    });
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toBe('remote success');
-    expect(result.metrics).toMatchObject({
-      adapter: 'webhook',
-      httpStatus: 200,
-    });
-  });
-
-  it('returns failed result for non-2xx webhook responses', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: false,
-        status: 502,
-        statusText: 'Bad Gateway',
-        text: 'upstream down',
-      }),
-    );
-    const adapter = new WebhookDispatchAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-        },
-      }),
-    );
-
-    expect(result.status).toBe('failed');
-    expect(result.error).toContain('webhook request failed (502)');
-    expect(result.error).toContain('upstream down');
-  });
-
-  it('treats acknowledged non-terminal response as synchronous success when no poll URL is provided', async () => {
-    fetchMock.mockResolvedValueOnce(
-      mockResponse({
-        ok: true,
-        status: 202,
-        text: JSON.stringify({
-          status: 'running',
-          accepted: true,
-        }),
-      }),
-    );
-    const adapter = new WebhookDispatchAdapter();
-    const result = await adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-        },
-      }),
-    );
-
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toContain('"accepted":true');
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('polls status endpoint until a terminal result is returned', async () => {
-    vi.useFakeTimers();
-    fetchMock
-      .mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          status: 202,
-          text: JSON.stringify({
-            status: 'running',
-            pollUrl: 'https://dispatch.example/runs/run-webhook-1/status',
-          }),
-        }),
-      )
-      .mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          status: 200,
-          text: JSON.stringify({
-            status: 'running',
-          }),
-        }),
-      )
-      .mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          status: 200,
-          text: JSON.stringify({
-            status: 'succeeded',
-            output: 'poll-complete',
-          }),
-        }),
-      );
-
-    const adapter = new WebhookDispatchAdapter();
-    const execution = adapter.execute(
-      makeInput({
-        context: {
-          webhook_url: 'https://dispatch.example/runs',
-          webhook_poll_ms: 250,
-          webhook_max_wait_ms: 2_000,
-        },
-      }),
-    );
-
-    await vi.advanceTimersByTimeAsync(300);
-    const result = await execution;
-
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      2,
-      'https://dispatch.example/runs/run-webhook-1/status',
-      expect.objectContaining({
-        method: 'GET',
-      }),
-    );
-    expect(result.status).toBe('succeeded');
-    expect(result.output).toBe('poll-complete');
-    expect(result.metrics).toMatchObject({
-      adapter: 'webhook',
-      pollUrl: 'https://dispatch.example/runs/run-webhook-1/status',
-      pollHttpStatus: 200,
-    });
-  });
-});
diff --git a/packages/runtime-adapter-core/src/webhook-adapter.ts b/packages/runtime-adapter-core/src/webhook-adapter.ts
deleted file mode 100644
index c567bc0..0000000
--- a/packages/runtime-adapter-core/src/webhook-adapter.ts
+++ /dev/null
@@ -1,242 +0,0 @@
-import type {
-  DispatchAdapter,
-  DispatchAdapterCreateInput,
-  DispatchAdapterExecutionInput,
-  DispatchAdapterExecutionResult,
-  DispatchAdapterLogEntry,
-  DispatchAdapterRunStatus,
-} from './contracts.js';
-
-const DEFAULT_POLL_MS = 1_000;
-const DEFAULT_MAX_WAIT_MS = 90_000;
-
-export class WebhookDispatchAdapter implements DispatchAdapter {
-  name = 'webhook';
-
-  async create(_input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus> {
-    return { runId: 'webhook-managed', status: 'queued' };
-  }
-
-  async status(runId: string): Promise<DispatchAdapterRunStatus> {
-    return { runId, status: 'running' };
-  }
-
-  async followup(runId: string, _actor: string, _input: string): Promise<DispatchAdapterRunStatus> {
-    return { runId, status: 'running' };
-  }
-
-  async stop(runId: string, _actor: string): Promise<DispatchAdapterRunStatus> {
-    return { runId, status: 'cancelled' };
-  }
-
-  async logs(_runId: string): Promise<DispatchAdapterLogEntry[]> {
-    return [];
-  }
-
-  async execute(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult> {
-    const logs: DispatchAdapterLogEntry[] = [];
-    const webhookUrl = resolveUrl(input.context?.webhook_url, process.env.WORKGRAPH_DISPATCH_WEBHOOK_URL);
-    if (!webhookUrl) {
-      return {
-        status: 'failed',
-        error: 'webhook adapter requires context.webhook_url or WORKGRAPH_DISPATCH_WEBHOOK_URL.',
-        logs,
-      };
-    }
-
-    const token = readString(input.context?.webhook_token) ?? process.env.WORKGRAPH_DISPATCH_WEBHOOK_TOKEN;
-    const headers = {
-      'content-type': 'application/json',
-      ...extractHeaders(input.context?.webhook_headers),
-      ...(token ? { authorization: `Bearer ${token}` } : {}),
-    };
-
-    const payload = {
-      runId: input.runId,
-      actor: input.actor,
-      objective: input.objective,
-      workspacePath: input.workspacePath,
-      context: input.context ?? {},
-      ts: new Date().toISOString(),
-    };
-
-    pushLog(logs, 'info', `webhook posting run ${input.runId} to ${webhookUrl}`);
-    const response = await fetch(webhookUrl, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(payload),
-    });
-    const rawText = await response.text();
-    const parsed = safeParseJson(rawText);
-    pushLog(logs, response.ok ? 'info' : 'error', `webhook response status: ${response.status}`);
-
-    if (!response.ok) {
-      return {
-        status: 'failed',
-        error: `webhook request failed (${response.status}): ${rawText || response.statusText}`,
-        logs,
-      };
-    }
-
-    const immediateStatus = normalizeRunStatus(parsed?.status);
-    if (immediateStatus && isTerminalStatus(immediateStatus)) {
-      return {
-        status: immediateStatus,
-        output: typeof parsed?.output === 'string' ? parsed.output : rawText,
-        error: typeof parsed?.error === 'string' ? parsed.error : undefined,
-        logs,
-        metrics: {
-          adapter: this.name,
-          httpStatus: response.status,
-        },
-      };
-    }
-
-    const pollUrl = resolveUrl(parsed?.pollUrl, input.context?.webhook_status_url, process.env.WORKGRAPH_DISPATCH_WEBHOOK_STATUS_URL);
-    if (!pollUrl) {
-      return {
-        status: 'succeeded',
-        output: rawText || 'webhook acknowledged run successfully.',
-        logs,
-        metrics: {
-          adapter: this.name,
-          httpStatus: response.status,
-        },
-      };
-    }
-
-    const pollMs = clampInt(readNumber(input.context?.webhook_poll_ms), DEFAULT_POLL_MS, 200, 30_000);
-    const maxWaitMs = clampInt(readNumber(input.context?.webhook_max_wait_ms), DEFAULT_MAX_WAIT_MS, 1_000, 15 * 60_000);
-    const startedAt = Date.now();
-    pushLog(logs, 'info', `webhook polling status from ${pollUrl}`);
-
-    while (Date.now() - startedAt < maxWaitMs) {
-      if (input.isCancelled?.()) {
-        pushLog(logs, 'warn', 'webhook run cancelled while polling');
-        return {
-          status: 'cancelled',
-          output: 'webhook polling cancelled by dispatcher.',
-          logs,
-        };
-      }
-
-      const pollResponse = await fetch(pollUrl, {
-        method: 'GET',
-        headers: {
-          ...headers,
-        },
-      });
-      const pollText = await pollResponse.text();
-      const pollJson = safeParseJson(pollText);
-      const pollStatus = normalizeRunStatus(pollJson?.status);
-      pushLog(logs, 'info', `poll status=${pollResponse.status} run_status=${pollStatus ?? 'unknown'}`);
-
-      if (pollStatus && isTerminalStatus(pollStatus)) {
-        return {
-          status: pollStatus,
-          output: typeof pollJson?.output === 'string' ? pollJson.output : pollText,
-          error: typeof pollJson?.error === 'string' ? pollJson.error : undefined,
-          logs,
-          metrics: {
-            adapter: this.name,
-            pollUrl,
-            pollHttpStatus: pollResponse.status,
-            elapsedMs: Date.now() - startedAt,
-          },
-        };
-      }
-
-      await sleep(pollMs);
-    }
-
-    return {
-      status: 'failed',
-      error: `webhook polling exceeded timeout (${maxWaitMs}ms) for run ${input.runId}.`,
-      logs,
-    };
-  }
-}
-
-function pushLog(target: DispatchAdapterLogEntry[], level: DispatchAdapterLogEntry['level'], message: string): void {
-  target.push({
-    ts: new Date().toISOString(),
-    level,
-    message,
-  });
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function resolveUrl(...values: unknown[]): string | undefined {
-  for (const value of values) {
-    const parsed = readString(value);
-    if (!parsed) continue;
-    try {
-      const url = new URL(parsed);
-      if (url.protocol === 'http:' || url.protocol === 'https:') {
-        return url.toString();
-      }
-    } catch {
-      continue;
-    }
-  }
-  return undefined;
-}
-
-function extractHeaders(input: unknown): Record<string, string> {
-  if (!input || typeof input !== 'object' || Array.isArray(input)) return {};
-  const record = input as Record<string, unknown>;
-  const out: Record<string, string> = {};
-  for (const [key, value] of Object.entries(record)) {
-    if (!key || value === undefined || value === null) continue;
-    out[key.toLowerCase()] = String(value);
-  }
-  return out;
-}
-
-function safeParseJson(value: string): Record<string, unknown> | null {
-  if (!value || !value.trim()) return null;
-  try {
-    const parsed = JSON.parse(value) as unknown;
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
-    return parsed as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-function normalizeRunStatus(value: unknown): DispatchAdapterRunStatus['status'] | undefined {
-  const normalized = String(value ?? '').toLowerCase();
-  if (normalized === 'queued' || normalized === 'running' || normalized === 'succeeded' || normalized === 'failed' || normalized === 'cancelled') {
-    return normalized;
-  }
-  return undefined;
-}
-
-function isTerminalStatus(status: DispatchAdapterRunStatus['status']): boolean {
-  return status === 'succeeded' || status === 'failed' || status === 'cancelled';
-}
-
-function readNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function clampInt(value: number | undefined, fallback: number, min: number, max: number): number {
-  const raw = typeof value === 'number' ? Math.trunc(value) : fallback;
-  return Math.min(max, Math.max(min, raw));
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
diff --git a/packages/runtime-adapter-core/tsconfig.json b/packages/runtime-adapter-core/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/runtime-adapter-core/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/sdk/package.json b/packages/sdk/package.json
index d3ac161..931cc78 100644
--- a/packages/sdk/package.json
+++ b/packages/sdk/package.json
@@ -9,14 +9,7 @@
   "main": "src/index.ts",
   "types": "src/index.ts",
   "dependencies": {
-    "@versatly/workgraph-adapter-claude-code": "workspace:*",
-    "@versatly/workgraph-adapter-cursor-cloud": "workspace:*",
-    "@versatly/workgraph-control-api": "workspace:*",
     "@versatly/workgraph-kernel": "workspace:*",
-    "@versatly/workgraph-mcp-server": "workspace:*",
-    "@versatly/workgraph-obsidian-integration": "workspace:*",
-    "@versatly/workgraph-runtime-adapter-core": "workspace:*",
-    "@versatly/workgraph-search-qmd-adapter": "workspace:*",
-    "@versatly/workgraph-skills": "workspace:*"
+    "@versatly/workgraph-mcp-server": "workspace:*"
   }
 }
diff --git a/packages/sdk/src/index.ts b/packages/sdk/src/index.ts
index 8c0541b..6126353 100644
--- a/packages/sdk/src/index.ts
+++ b/packages/sdk/src/index.ts
@@ -1,10 +1,5 @@
 export * from '@versatly/workgraph-kernel';
 
 export * as kernel from '@versatly/workgraph-kernel';
-export * as obsidianIntegration from '@versatly/workgraph-obsidian-integration';
-export * as runtimeAdapterCore from '@versatly/workgraph-runtime-adapter-core';
-export * as adapterCursorCloud from '@versatly/workgraph-adapter-cursor-cloud';
-export * as searchQmdAdapter from '@versatly/workgraph-search-qmd-adapter';
 export * as mcpServer from '@versatly/workgraph-mcp-server';
 export * as mcpHttpServer from '@versatly/workgraph-mcp-server';
-export * as server from '@versatly/workgraph-control-api';
diff --git a/packages/search-qmd-adapter/package.json b/packages/search-qmd-adapter/package.json
deleted file mode 100644
index 20e66ec..0000000
--- a/packages/search-qmd-adapter/package.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "@versatly/workgraph-search-qmd-adapter",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-kernel": "workspace:*"
-  }
-}
diff --git a/packages/search-qmd-adapter/src/index.ts b/packages/search-qmd-adapter/src/index.ts
deleted file mode 100644
index 15b2c5f..0000000
--- a/packages/search-qmd-adapter/src/index.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { query as queryModule, type PrimitiveInstance } from '@versatly/workgraph-kernel';
-
-const query = queryModule;
-
-export interface QmdSearchOptions {
-  mode?: 'auto' | 'core' | 'qmd';
-  type?: string;
-  limit?: number;
-}
-
-export interface QmdSearchResult {
-  mode: 'core' | 'qmd';
-  query: string;
-  results: PrimitiveInstance[];
-  fallbackReason?: string;
-}
-
-export function search(
-  workspacePath: string,
-  text: string,
-  options: QmdSearchOptions = {},
-): QmdSearchResult {
-  const requestedMode = options.mode ?? 'auto';
-  const qmdEnabled = process.env.WORKGRAPH_QMD_ENDPOINT && process.env.WORKGRAPH_QMD_ENDPOINT.trim().length > 0;
-
-  if (requestedMode === 'qmd' && !qmdEnabled) {
-    const results = query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    });
-    return {
-      mode: 'core',
-      query: text,
-      results,
-      fallbackReason: 'QMD mode requested but WORKGRAPH_QMD_ENDPOINT is not configured.',
-    };
-  }
-
-  if (requestedMode === 'qmd' && qmdEnabled) {
-    const results = query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    });
-    return {
-      mode: 'qmd',
-      query: text,
-      results,
-      fallbackReason: 'QMD endpoint configured; using core-compatible local ranking in MVP.',
-    };
-  }
-
-  if (requestedMode === 'auto' && qmdEnabled) {
-    const results = query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    });
-    return {
-      mode: 'qmd',
-      query: text,
-      results,
-      fallbackReason: 'Auto mode selected; QMD endpoint detected; using core-compatible local ranking in MVP.',
-    };
-  }
-
-  return {
-    mode: 'core',
-    query: text,
-    results: query.keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit,
-    }),
-  };
-}
diff --git a/packages/search-qmd-adapter/tsconfig.json b/packages/search-qmd-adapter/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/search-qmd-adapter/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/packages/skills/package.json b/packages/skills/package.json
deleted file mode 100644
index 423ec45..0000000
--- a/packages/skills/package.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "@versatly/workgraph-skills",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@versatly/workgraph-kernel": "workspace:*"
-  }
-}
diff --git a/packages/skills/src/index.ts b/packages/skills/src/index.ts
deleted file mode 100644
index e1fb848..0000000
--- a/packages/skills/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from '@versatly/workgraph-kernel';
diff --git a/packages/skills/tsconfig.json b/packages/skills/tsconfig.json
deleted file mode 100644
index 79e486b..0000000
--- a/packages/skills/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 0e5a073..dee51e9 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,3 +1,2 @@
 packages:
   - "packages/*"
-  - "apps/*"
diff --git a/scripts/generate-demo-workspace.mjs b/scripts/generate-demo-workspace.mjs
deleted file mode 100644
index 498c549..0000000
--- a/scripts/generate-demo-workspace.mjs
+++ /dev/null
@@ -1,168 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Generates a large Obsidian-ready workgraph demo vault.
- *
- * Usage:
- *   node scripts/generate-demo-workspace.mjs /tmp/workgraph-obsidian-demo
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-const targetArg = process.argv[2] ?? '/tmp/workgraph-obsidian-demo';
-const targetPath = path.resolve(targetArg);
-const cliPath = path.resolve('bin/workgraph.js');
-
-function run(args) {
-  const result = spawnSync('node', [cliPath, ...args], {
-    stdio: 'pipe',
-    encoding: 'utf-8',
-  });
-  if (result.status !== 0) {
-    throw new Error(`Command failed: workgraph ${args.join(' ')}\n${result.stdout}\n${result.stderr}`);
-  }
-  return result.stdout.trim();
-}
-
-function writeObsidianConfig(vaultPath) {
-  const obsidianPath = path.join(vaultPath, '.obsidian');
-  fs.mkdirSync(obsidianPath, { recursive: true });
-  const graph = {
-    'collapse-filter': false,
-    showTags: true,
-    showAttachments: true,
-    showOrphans: true,
-    colorGroups: [
-      { query: 'path:context-nodes', color: { a: 1, rgb: 16733525 } },
-      { query: 'path:workflow-cells', color: { a: 1, rgb: 65535 } },
-      { query: 'path:threads', color: { a: 1, rgb: 5635925 } },
-      { query: 'path:skills OR path:ops', color: { a: 1, rgb: 16766720 } },
-      { query: 'path:spaces', color: { a: 1, rgb: 10066329 } },
-    ],
-  };
-  fs.writeFileSync(path.join(obsidianPath, 'graph.json'), JSON.stringify(graph, null, 2) + '\n', 'utf-8');
-}
-
-if (fs.existsSync(targetPath)) {
-  fs.rmSync(targetPath, { recursive: true, force: true });
-}
-
-run(['init', targetPath, '--name', 'WorkGraph Obsidian Demo', '--json']);
-run(['onboard', '-w', targetPath, '--actor', 'agent-architect', '--spaces', 'platform,delivery,research', '--json']);
-run([
-  'primitive', 'define', 'context-node',
-  '-w', targetPath,
-  '--description', 'Malleable context primitive',
-  '--fields', 'cluster:string',
-  '--fields', 'link_primary:ref',
-  '--fields', 'energy:number',
-  '--actor', 'agent-architect',
-  '--json',
-]);
-run([
-  'primitive', 'define', 'workflow-cell',
-  '-w', targetPath,
-  '--description', 'Composable workflow primitive',
-  '--fields', 'lane:string',
-  '--fields', 'upstream:ref',
-  '--fields', 'state:string',
-  '--actor', 'agent-architect',
-  '--json',
-]);
-
-for (let i = 1; i <= 120; i += 1) {
-  const args = [
-    'primitive', 'create', 'context-node', `Context Node ${i}`,
-    '-w', targetPath,
-    '--actor', 'agent-architect',
-    '--set', `cluster=cluster-${((i - 1) % 10) + 1}`,
-    '--set', `energy=${(i * 7) % 100}`,
-    '--body', `# Context Node ${i}\n\nLinks: [[threads/review-workspace-policy-gates.md]] [[skills/workgraph-manual/SKILL.md]]${i > 1 ? ` [[context-nodes/context-node-${i - 1}.md]]` : ''}`,
-    '--json',
-  ];
-  if (i > 1) {
-    args.splice(args.indexOf('--body'), 0, '--set', `link_primary=context-nodes/context-node-${i - 1}.md`);
-  }
-  run(args);
-}
-
-for (let i = 1; i <= 60; i += 1) {
-  const args = [
-    'primitive', 'create', 'workflow-cell', `Workflow Cell ${i}`,
-    '-w', targetPath,
-    '--actor', 'agent-architect',
-    '--set', `lane=lane-${((i - 1) % 6) + 1}`,
-    '--set', 'state=ready',
-    '--body', `# Workflow Cell ${i}\n\nContext link [[context-nodes/context-node-${((i - 1) % 120) + 1}.md]]${i > 1 ? ` [[workflow-cells/workflow-cell-${i - 1}.md]]` : ''}`,
-    '--json',
-  ];
-  if (i > 1) {
-    args.splice(args.indexOf('--body'), 0, '--set', `upstream=workflow-cells/workflow-cell-${i - 1}.md`);
-  }
-  run(args);
-}
-
-for (let i = 1; i <= 70; i += 1) {
-  run([
-    'thread', 'create', `Delivery Thread ${i}`,
-    '-w', targetPath,
-    '--goal', `Implement delivery slice ${i} with context [[context-nodes/context-node-${((i - 1) % 120) + 1}.md]]`,
-    '--priority', 'high',
-    '--actor', `agent-delivery-${((i - 1) % 6) + 1}`,
-    '--space', 'spaces/delivery.md',
-    '--context', `context-nodes/context-node-${((i - 1) % 120) + 1}.md`,
-    '--tags', `delivery,iteration-${i}`,
-    '--json',
-  ]);
-}
-
-for (let i = 1; i <= 40; i += 1) {
-  run([
-    'thread', 'claim', `threads/delivery-thread-${i}.md`,
-    '-w', targetPath,
-    '--actor', `agent-delivery-${((i - 1) % 6) + 1}`,
-    '--json',
-  ]);
-}
-
-for (let i = 1; i <= 20; i += 1) {
-  run([
-    'thread', 'done', `threads/delivery-thread-${i}.md`,
-    '-w', targetPath,
-    '--actor', `agent-delivery-${((i - 1) % 6) + 1}`,
-    '--output', `Completed delivery slice ${i} with linked context [[context-nodes/context-node-${i}.md]]`,
-    '--json',
-  ]);
-}
-
-for (let i = 21; i <= 40; i += 1) {
-  run([
-    'thread', 'block', `threads/delivery-thread-${i}.md`,
-    '-w', targetPath,
-    '--actor', `agent-delivery-${((i - 1) % 6) + 1}`,
-    '--blocked-by', `threads/delivery-thread-${i - 20}.md`,
-    '--reason', 'Waiting for downstream validation',
-    '--json',
-  ]);
-}
-
-run([
-  'skill', 'write', 'workgraph-manual',
-  '-w', targetPath,
-  '--actor', 'agent-architect',
-  '--status', 'active',
-  '--skill-version', '2.4.0',
-  '--tags', 'ops,graph',
-  '--body', '# WorkGraph Manual\n\nOperational links:\n- [[ops/Workgraph Board.md]]\n- [[ops/Command Center.md]]\n- [[context-nodes/context-node-1.md]]\n- [[workflow-cells/workflow-cell-1.md]]',
-  '--json',
-]);
-
-run(['board', 'generate', '-w', targetPath, '--output', 'ops/Workgraph Board.md', '--include-cancelled', '--json']);
-run(['command-center', '-w', targetPath, '--output', 'ops/Command Center.md', '--actor', 'agent-architect', '--json']);
-run(['graph', 'index', '-w', targetPath, '--json']);
-run(['graph', 'hygiene', '-w', targetPath, '--json']);
-
-writeObsidianConfig(targetPath);
-console.log(targetPath);
diff --git a/scripts/product-demo.mjs b/scripts/product-demo.mjs
deleted file mode 100644
index 37e9c79..0000000
--- a/scripts/product-demo.mjs
+++ /dev/null
@@ -1,255 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import http from 'node:http';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { fileURLToPath } from 'node:url';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { startWorkgraphMcpHttpServer } from '../dist/mcp-http-server.js';
-import * as workgraph from '../dist/index.js';
-
-const execFileAsync = promisify(execFile);
-const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const cliPath = path.join(repoRoot, 'bin', 'workgraph.js');
-
-const argv = parseArgs(process.argv.slice(2));
-const workspacePath = argv.workspacePath || fs.mkdtempSync(path.join(os.tmpdir(), 'workgraph-product-demo-'));
-
-await ensureBuiltArtifacts();
-
-const logLines = [];
-const log = (line) => {
-  logLines.push(line);
-  if (!argv.silent) console.error(line);
-};
-
-log(`workspace=${workspacePath}`);
-
-const init = await runCli(['init', workspacePath, '--json'], log);
-await runCli(['policy', 'party', 'upsert', 'demo-operator', '-w', workspacePath, '--roles', 'operators', '--capabilities', 'mcp:write,thread:claim,thread:done,dispatch:run,checkpoint:create', '--json'], log);
-await runCli(['policy', 'party', 'upsert', 'trigger-gate', '-w', workspacePath, '--roles', 'reviewer', '--capabilities', 'promote:sensitive', '--json'], log);
-
-await runCli(['thread', 'create', 'Platform task A', '-w', workspacePath, '--goal', 'A', '--actor', 'lead', '--priority', 'high', '--json'], log);
-await runCli(['thread', 'create', 'Platform task B', '-w', workspacePath, '--goal', 'B', '--actor', 'lead', '--deps', 'threads/platform-task-a.md', '--priority', 'medium', '--json'], log);
-const cursorCloudRun = await runCli(
-  ['dispatch', 'create-execute', 'Cursor cloud autonomous coordination', '-w', workspacePath, '--actor', 'lead', '--agents', 'alpha,beta', '--max-steps', '30', '--step-delay-ms', '0', '--json'],
-  log,
-);
-
-const shellRun = workgraph.dispatch.createRun(workspacePath, {
-  actor: 'lead',
-  adapter: 'shell-worker',
-  objective: 'Shell adapter production run',
-  context: {
-    shell_command: 'printf shell_adapter_ok',
-  },
-});
-const shellExec = await workgraph.dispatch.executeRun(workspacePath, shellRun.id, { actor: 'lead' });
-
-const webhookResult = await runWebhookAdapterDemo(workspacePath);
-
-await runCli(['thread', 'create', 'Blocked trigger source', '-w', workspacePath, '--goal', 'Generate trigger event', '--actor', 'trigger-worker', '--priority', 'high', '--json'], log);
-await runCli(['thread', 'claim', 'threads/blocked-trigger-source.md', '-w', workspacePath, '--actor', 'trigger-worker', '--json'], log);
-await runCli(['thread', 'block', 'threads/blocked-trigger-source.md', '-w', workspacePath, '--actor', 'trigger-worker', '--blocked-by', 'external/upstream', '--reason', 'waiting upstream', '--json'], log);
-await runCli(['primitive', 'create', 'trigger', 'Escalate blocked events', '-w', workspacePath, '--set', 'event=thread.blocked', '--set', 'action=dispatch.review', '--set', 'status=draft', '--actor', 'trigger-gate', '--json'], log);
-await runCli(['primitive', 'update', 'triggers/escalate-blocked-events.md', '-w', workspacePath, '--set', 'status=approved', '--actor', 'trigger-gate', '--json'], log);
-const triggerCycle = await runCli(['trigger', 'engine', 'run', '-w', workspacePath, '--actor', 'trigger-engine', '--max-cycles', '1', '--json'], log);
-
-await runCli(['thread', 'create', 'Autonomy chain 1', '-w', workspacePath, '--goal', 'c1', '--actor', 'auto-lead', '--priority', 'high', '--json'], log);
-await runCli(['thread', 'create', 'Autonomy chain 2', '-w', workspacePath, '--goal', 'c2', '--actor', 'auto-lead', '--deps', 'threads/autonomy-chain-1.md', '--priority', 'medium', '--json'], log);
-const autonomyRun = await runCli(['autonomy', 'run', '-w', workspacePath, '--actor', 'auto-lead', '--agents', 'auto-1,auto-2', '--max-cycles', '6', '--max-idle-cycles', '1', '--poll-ms', '10', '--max-steps', '100', '--step-delay-ms', '0', '--json'], log);
-
-const mcpHttpResult = await runMcpHttpDemo(workspacePath);
-const adapters = await runCli(['dispatch', 'adapters', '--json'], log);
-const ledgerVerify = await runCli(['ledger', 'verify', '-w', workspacePath, '--strict', '--json'], log);
-
-const result = {
-  workspacePath,
-  initSummary: {
-    workspacePath: init.data.workspacePath,
-    generatedBases: init.data.generatedBases.length,
-  },
-  cursorCloud: {
-    runId: cursorCloudRun.data.run.id,
-    status: cursorCloudRun.data.run.status,
-  },
-  shellWorker: {
-    runId: shellRun.id,
-    status: shellExec.status,
-    containsExpectedOutput: String(shellExec.output || '').includes('shell_adapter_ok'),
-  },
-  webhook: webhookResult,
-  triggerEngine: {
-    actions: triggerCycle.data.cycles[0]?.actions?.length ?? 0,
-    driftOk: triggerCycle.data.cycles[0]?.drift?.ok ?? false,
-  },
-  autonomy: {
-    cycles: autonomyRun.data.cycles.length,
-    finalReadyThreads: autonomyRun.data.finalReadyThreads,
-    finalDriftOk: autonomyRun.data.finalDriftOk,
-  },
-  mcpHttp: mcpHttpResult,
-  adapters: adapters.data.adapters,
-  ledgerVerify: ledgerVerify.data,
-};
-
-if (argv.logPath) {
-  fs.writeFileSync(path.resolve(argv.logPath), `${logLines.join('\n')}\n`, 'utf-8');
-}
-
-console.log(JSON.stringify(result, null, 2));
-
-async function runCli(args, logFn) {
-  const { stdout, stderr } = await execFileAsync('node', [cliPath, ...args], {
-    cwd: repoRoot,
-    env: process.env,
-    maxBuffer: 10 * 1024 * 1024,
-  });
-  if (stderr && stderr.trim()) {
-    logFn(`stderr(${args.slice(0, 3).join(' ')}): ${stderr.trim()}`);
-  }
-  const payload = JSON.parse(stdout);
-  logFn(`ok(${args.slice(0, 3).join(' ')}): ${JSON.stringify(payload).slice(0, 180)}`);
-  return payload;
-}
-
-async function runWebhookAdapterDemo(workspacePath) {
-  const server = http.createServer((req, res) => {
-    if (req.method === 'POST' && req.url === '/dispatch') {
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify({
-        status: 'succeeded',
-        output: 'third_party_webhook_success',
-      }));
-      return;
-    }
-    res.writeHead(404);
-    res.end('not found');
-  });
-
-  await new Promise((resolve) => {
-    server.listen(0, '127.0.0.1', resolve);
-  });
-  const address = server.address();
-  const port = typeof address === 'object' && address ? address.port : 0;
-  const run = workgraph.dispatch.createRun(workspacePath, {
-    actor: 'lead',
-    adapter: 'http-webhook',
-    objective: 'Webhook adapter production run',
-    context: {
-      webhook_url: `http://127.0.0.1:${port}/dispatch`,
-    },
-  });
-
-  try {
-    const executed = await workgraph.dispatch.executeRun(workspacePath, run.id, { actor: 'lead' });
-    return {
-      runId: run.id,
-      status: executed.status,
-      output: executed.output,
-    };
-  } finally {
-    await new Promise((resolve) => {
-      server.close(resolve);
-    });
-  }
-}
-
-async function runMcpHttpDemo(workspacePath) {
-  const token = 'demo-token';
-  const handle = await startWorkgraphMcpHttpServer({
-    workspacePath,
-    defaultActor: 'demo-operator',
-    host: '127.0.0.1',
-    port: 0,
-    bearerToken: token,
-  });
-  const client = new Client({
-    name: 'product-demo-http-client',
-    version: '1.0.0',
-  });
-  const transport = new StreamableHTTPClientTransport(new URL(handle.url), {
-    requestInit: {
-      headers: {
-        authorization: `Bearer ${token}`,
-      },
-    },
-  });
-
-  await client.connect(transport);
-  try {
-    const tools = await client.listTools();
-    const status = await client.callTool({
-      name: 'workgraph_status',
-      arguments: {},
-    });
-    const runCreated = await client.callTool({
-      name: 'workgraph_dispatch_create',
-      arguments: {
-        actor: 'demo-operator',
-        objective: 'MCP HTTP run',
-      },
-    });
-    const runId = runCreated.structuredContent?.run?.id;
-    const runExecuted = await client.callTool({
-      name: 'workgraph_dispatch_execute',
-      arguments: {
-        actor: 'demo-operator',
-        runId,
-        agents: ['http-a', 'http-b'],
-        maxSteps: 20,
-        stepDelayMs: 0,
-      },
-    });
-    return {
-      url: handle.url,
-      tools: tools.tools.length,
-      statusError: status.isError === true,
-      runId,
-      runStatus: runExecuted.structuredContent?.run?.status,
-    };
-  } finally {
-    await client.close();
-    await handle.close();
-  }
-}
-
-function parseArgs(args) {
-  const parsed = {
-    workspacePath: undefined,
-    logPath: undefined,
-    silent: false,
-  };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--workspace' && i + 1 < args.length) {
-      parsed.workspacePath = path.resolve(args[++i]);
-      continue;
-    }
-    if (arg === '--log' && i + 1 < args.length) {
-      parsed.logPath = args[++i];
-      continue;
-    }
-    if (arg === '--silent') {
-      parsed.silent = true;
-    }
-  }
-  return parsed;
-}
-
-async function ensureBuiltArtifacts() {
-  const required = [
-    path.join(repoRoot, 'dist', 'index.js'),
-    path.join(repoRoot, 'dist', 'cli.js'),
-    path.join(repoRoot, 'dist', 'mcp-http-server.js'),
-  ];
-  for (const file of required) {
-    if (!fs.existsSync(file)) {
-      throw new Error(`Missing build artifact "${file}". Run "pnpm run build" first.`);
-    }
-  }
-}
diff --git a/scripts/setup-obsidian-demo.mjs b/scripts/setup-obsidian-demo.mjs
deleted file mode 100644
index 570190b..0000000
--- a/scripts/setup-obsidian-demo.mjs
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Configures an Obsidian vault for the WorkGraph demo:
- * - installs Kanban + Terminal community plugins
- * - writes graph color groups and workspace layout
- * - extracts Obsidian AppImage fallback to /tmp/squashfs-root when needed
- *
- * Usage:
- *   node scripts/setup-obsidian-demo.mjs /tmp/workgraph-obsidian-demo
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-const vaultPath = path.resolve(process.argv[2] ?? '/tmp/workgraph-obsidian-demo');
-
-const plugins = {
-  'obsidian-kanban': {
-    files: {
-      'main.js': 'https://github.com/mgmeyers/obsidian-kanban/releases/download/2.0.51/main.js',
-      'manifest.json': 'https://github.com/mgmeyers/obsidian-kanban/releases/download/2.0.51/manifest.json',
-      'styles.css': 'https://github.com/mgmeyers/obsidian-kanban/releases/download/2.0.51/styles.css',
-    },
-  },
-  terminal: {
-    files: {
-      'main.js': 'https://github.com/polyipseity/obsidian-terminal/releases/download/3.21.0/main.js',
-      'manifest.json': 'https://github.com/polyipseity/obsidian-terminal/releases/download/3.21.0/manifest.json',
-      'styles.css': 'https://github.com/polyipseity/obsidian-terminal/releases/download/3.21.0/styles.css',
-    },
-  },
-};
-
-async function download(url) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
-  }
-  return new Uint8Array(await response.arrayBuffer());
-}
-
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
-
-function ensureObsidianAppImageExtracted() {
-  if (fs.existsSync('/tmp/squashfs-root/AppRun')) {
-    return;
-  }
-  const result = spawnSync('/usr/local/bin/obsidian', ['--appimage-extract'], {
-    cwd: '/tmp',
-    stdio: 'inherit',
-  });
-  if (result.status !== 0) {
-    throw new Error('Failed to extract Obsidian AppImage fallback.');
-  }
-}
-
-function writeObsidianConfig(targetVaultPath) {
-  const obsidianDir = path.join(targetVaultPath, '.obsidian');
-  ensureDir(obsidianDir);
-  const graphConfig = {
-    'collapse-filter': false,
-    showTags: true,
-    showAttachments: true,
-    showOrphans: true,
-    colorGroups: [
-      { query: 'path:context-nodes', color: { a: 1, rgb: 16733525 } },
-      { query: 'path:workflow-cells', color: { a: 1, rgb: 65535 } },
-      { query: 'path:threads', color: { a: 1, rgb: 5635925 } },
-      { query: 'path:skills OR path:ops', color: { a: 1, rgb: 16766720 } },
-      { query: 'path:spaces', color: { a: 1, rgb: 10066329 } },
-    ],
-  };
-  const workspaceConfig = {
-    main: {
-      type: 'split',
-      direction: 'vertical',
-      children: [
-        {
-          type: 'tabs',
-          currentTab: 0,
-          children: [
-            {
-              type: 'leaf',
-              state: { type: 'markdown', state: { file: 'ops/Command Center.md' } },
-            },
-          ],
-        },
-        {
-          type: 'tabs',
-          currentTab: 0,
-          children: [
-            {
-              type: 'leaf',
-              state: { type: 'markdown', state: { file: 'ops/Workgraph Board.md' } },
-            },
-          ],
-        },
-      ],
-    },
-  };
-  fs.writeFileSync(path.join(obsidianDir, 'community-plugins.json'), JSON.stringify(Object.keys(plugins), null, 2) + '\n', 'utf-8');
-  fs.writeFileSync(path.join(obsidianDir, 'core-plugins.json'), JSON.stringify(['file-explorer', 'search', 'graph', 'command-palette', 'editor-status', 'backlink', 'outline'], null, 2) + '\n', 'utf-8');
-  fs.writeFileSync(path.join(obsidianDir, 'graph.json'), JSON.stringify(graphConfig, null, 2) + '\n', 'utf-8');
-  fs.writeFileSync(path.join(obsidianDir, 'workspace.json'), JSON.stringify(workspaceConfig, null, 2) + '\n', 'utf-8');
-}
-
-async function installPlugins(targetVaultPath) {
-  const pluginRoot = path.join(targetVaultPath, '.obsidian', 'plugins');
-  ensureDir(pluginRoot);
-  for (const [pluginId, pluginData] of Object.entries(plugins)) {
-    const pluginDir = path.join(pluginRoot, pluginId);
-    ensureDir(pluginDir);
-    for (const [filename, url] of Object.entries(pluginData.files)) {
-      const content = await download(url);
-      fs.writeFileSync(path.join(pluginDir, filename), content);
-    }
-  }
-}
-
-async function main() {
-  if (!fs.existsSync(vaultPath)) {
-    throw new Error(`Vault path does not exist: ${vaultPath}`);
-  }
-  ensureObsidianAppImageExtracted();
-  await installPlugins(vaultPath);
-  writeObsidianConfig(vaultPath);
-  console.log(vaultPath);
-}
-
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
diff --git a/scripts/swarm-orchestrator.mjs b/scripts/swarm-orchestrator.mjs
deleted file mode 100644
index 39a5f3c..0000000
--- a/scripts/swarm-orchestrator.mjs
+++ /dev/null
@@ -1,266 +0,0 @@
-#!/usr/bin/env node
-/**
- * Swarm Orchestrator — Takes a goal, decomposes with an LLM,
- * deploys threads, spawns Docker workers, merges results.
- *
- * Usage:
- *   node swarm-orchestrator.mjs --goal "Write a book about OS kernels" \
- *     --workspace ~/my-vault --max-workers 10 --model claude
- *
- * Flow:
- *   1. Goal → LLM planner → SwarmPlan JSON
- *   2. SwarmPlan → deployPlan() → threads in workspace
- *   3. Spawn N Docker containers, each running worker.mjs
- *   4. Workers claim threads, execute with LLM, write results back
- *   5. Orchestrator monitors progress, synthesizes when done
- */
-
-import { execSync, spawn } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { parseArgs } from 'node:util';
-
-const { values: args } = parseArgs({
-  options: {
-    goal: { type: 'string' },
-    description: { type: 'string', default: '' },
-    workspace: { type: 'string', default: process.cwd() },
-    'max-workers': { type: 'string', default: '10' },
-    'max-tasks': { type: 'string', default: '200' },
-    model: { type: 'string', default: 'claude' },
-    output: { type: 'string', default: 'output.md' },
-    'dry-run': { type: 'boolean', default: false },
-    actor: { type: 'string', default: 'swarm-orchestrator' },
-  },
-});
-
-if (!args.goal) {
-  console.error('Usage: swarm-orchestrator.mjs --goal "Your goal" [options]');
-  process.exit(1);
-}
-
-const WORKSPACE = path.resolve(args.workspace);
-const MAX_WORKERS = parseInt(args['max-workers'], 10);
-const MAX_TASKS = parseInt(args['max-tasks'], 10);
-const WG = `node ${path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'bin', 'workgraph.js')}`;
-
-console.log(`\n🐝 SWARM ORCHESTRATOR`);
-console.log(`Goal: ${args.goal}`);
-console.log(`Workspace: ${WORKSPACE}`);
-console.log(`Max workers: ${MAX_WORKERS}`);
-console.log(`Max tasks: ${MAX_TASKS}`);
-console.log(`Model: ${args.model}\n`);
-
-// ============================================================================
-// Step 1: Decompose goal into tasks using LLM
-// ============================================================================
-
-console.log('📋 Step 1: Decomposing goal into tasks...');
-
-const plannerPrompt = `You are a task decomposition expert. Given a goal, break it into a structured plan with many specific, actionable tasks.
-
-GOAL: ${args.goal}
-${args.description ? `DESCRIPTION: ${args.description}` : ''}
-
-Output a JSON object with this exact structure:
-{
-  "goal": {
-    "title": "Short title",
-    "description": "Full description",
-    "maxTasks": ${MAX_TASKS}
-  },
-  "tasks": [
-    {
-      "title": "Specific task name",
-      "description": "Detailed instructions for an agent to complete this task independently. Include what to research, what to write, expected length, format, etc.",
-      "priority": "high|medium|low",
-      "dependsOn": ["Other task title if dependent"],
-      "tags": ["category"]
-    }
-  ],
-  "phases": [
-    {
-      "name": "Phase name",
-      "description": "What this phase accomplishes",
-      "taskIndices": [0, 1, 2],
-      "parallel": true
-    }
-  ]
-}
-
-Rules:
-- Create ${MAX_TASKS} or fewer tasks
-- Each task must be completable independently by a single agent in 5-15 minutes
-- Tasks that produce text should specify expected word count (500-2000 words each)
-- Use dependencies sparingly — maximize parallelism
-- Group into 3-5 phases
-- Be EXTREMELY specific in task descriptions — the agent has no other context
-
-Output ONLY valid JSON, no markdown fences.`;
-
-let plan;
-try {
-  // Use claude CLI for decomposition
-  const planJson = execSync(
-    `claude -p "${plannerPrompt.replace(/"/g, '\\"')}" --output-format json 2>/dev/null`,
-    { maxBuffer: 10 * 1024 * 1024, timeout: 120000 }
-  ).toString().trim();
-
-  // Extract JSON from response
-  const jsonMatch = planJson.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error('No JSON in LLM response');
-  plan = JSON.parse(jsonMatch[0]);
-  console.log(`   Created ${plan.tasks.length} tasks in ${plan.phases?.length ?? 0} phases`);
-} catch (err) {
-  console.error(`   Failed to decompose: ${err.message}`);
-  process.exit(1);
-}
-
-// Save plan
-const planPath = path.join(WORKSPACE, '.workgraph', 'swarm-plan.json');
-fs.mkdirSync(path.dirname(planPath), { recursive: true });
-fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
-console.log(`   Plan saved to ${planPath}`);
-
-if (args['dry-run']) {
-  console.log('\n🔍 DRY RUN — plan generated but not deployed');
-  console.log(JSON.stringify(plan, null, 2));
-  process.exit(0);
-}
-
-// ============================================================================
-// Step 2: Deploy plan into workspace
-// ============================================================================
-
-console.log('\n📦 Step 2: Deploying plan as threads...');
-
-try {
-  const result = execSync(
-    `${WG} swarm deploy ${planPath} --workspace ${WORKSPACE} --actor ${args.actor} --json`,
-    { maxBuffer: 10 * 1024 * 1024, timeout: 30000 }
-  ).toString();
-  const deployment = JSON.parse(result);
-  console.log(`   Space: ${deployment.spaceSlug}`);
-  console.log(`   Threads: ${deployment.threadPaths.length}`);
-  var spaceSlug = deployment.spaceSlug;
-} catch (err) {
-  console.error(`   Deploy failed: ${err.message}`);
-  process.exit(1);
-}
-
-// ============================================================================
-// Step 3: Spawn workers
-// ============================================================================
-
-console.log(`\n🤖 Step 3: Spawning ${MAX_WORKERS} workers...`);
-
-const workerScript = path.join(path.dirname(new URL(import.meta.url).pathname), 'swarm-worker.mjs');
-const workers = [];
-
-for (let i = 0; i < MAX_WORKERS; i++) {
-  const workerName = `worker-${i + 1}`;
-  console.log(`   Starting ${workerName}...`);
-
-  const proc = spawn('node', [
-    workerScript,
-    '--workspace', WORKSPACE,
-    '--space', spaceSlug,
-    '--actor', workerName,
-    '--model', args.model,
-  ], {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env },
-  });
-
-  workers.push({ name: workerName, proc, completed: 0, errors: 0 });
-
-  proc.stdout.on('data', (data) => {
-    const lines = data.toString().trim().split('\n');
-    for (const line of lines) {
-      if (line.includes('COMPLETED:')) workers[i].completed++;
-      if (line.includes('ERROR:')) workers[i].errors++;
-      console.log(`   [${workerName}] ${line}`);
-    }
-  });
-
-  proc.stderr.on('data', (data) => {
-    console.error(`   [${workerName}] ERR: ${data.toString().trim()}`);
-  });
-}
-
-// ============================================================================
-// Step 4: Monitor progress
-// ============================================================================
-
-console.log('\n📊 Step 4: Monitoring progress...');
-
-const startTime = Date.now();
-const checkInterval = setInterval(() => {
-  try {
-    const statusJson = execSync(
-      `${WG} swarm status ${spaceSlug} --workspace ${WORKSPACE} --json`,
-      { timeout: 10000 }
-    ).toString();
-    const status = JSON.parse(statusJson);
-
-    const elapsed = Math.round((Date.now() - startTime) / 1000);
-    const bar = progressBar(status.percentComplete);
-    console.log(`   [${elapsed}s] ${bar} ${status.done}/${status.total} (${status.percentComplete}%) | Claimed: ${status.claimed} | Open: ${status.open}`);
-
-    if (status.done + status.blocked >= status.total) {
-      clearInterval(checkInterval);
-      finalize(spaceSlug);
-    }
-  } catch {
-    // status check failed, retry next interval
-  }
-}, 10000);
-
-// Also wait for all workers to exit
-Promise.all(workers.map(w => new Promise(resolve => w.proc.on('exit', resolve))))
-  .then(() => {
-    clearInterval(checkInterval);
-    finalize(spaceSlug);
-  });
-
-// ============================================================================
-// Step 5: Synthesize results
-// ============================================================================
-
-let finalized = false;
-function finalize(slug) {
-  if (finalized) return;
-  finalized = true;
-
-  console.log('\n📝 Step 5: Synthesizing results...');
-
-  try {
-    const outputPath = path.resolve(args.output);
-    execSync(
-      `${WG} swarm synthesize ${slug} --workspace ${WORKSPACE} --output ${outputPath}`,
-      { timeout: 30000 }
-    );
-    console.log(`   Output written to: ${outputPath}`);
-
-    // Print summary
-    const totalCompleted = workers.reduce((s, w) => s + w.completed, 0);
-    const totalErrors = workers.reduce((s, w) => s + w.errors, 0);
-    const elapsed = Math.round((Date.now() - startTime) / 1000);
-
-    console.log(`\n✅ SWARM COMPLETE`);
-    console.log(`   Tasks completed: ${totalCompleted}`);
-    console.log(`   Errors: ${totalErrors}`);
-    console.log(`   Workers: ${MAX_WORKERS}`);
-    console.log(`   Time: ${elapsed}s`);
-    console.log(`   Output: ${outputPath}`);
-  } catch (err) {
-    console.error(`   Synthesis failed: ${err.message}`);
-  }
-
-  process.exit(0);
-}
-
-function progressBar(pct) {
-  const filled = Math.round(pct / 5);
-  return '█'.repeat(filled) + '░'.repeat(20 - filled);
-}
diff --git a/scripts/swarm-worker.mjs b/scripts/swarm-worker.mjs
deleted file mode 100644
index 1367ac0..0000000
--- a/scripts/swarm-worker.mjs
+++ /dev/null
@@ -1,115 +0,0 @@
-#!/usr/bin/env node
-/**
- * Swarm Worker — Claims and completes tasks from a swarm space.
- * Designed to run inside a Docker container or as a standalone process.
- *
- * Usage:
- *   node swarm-worker.mjs --workspace /vault --space swarm-slug --actor worker-1
- */
-
-import { execSync } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { parseArgs } from 'node:util';
-
-const { values: args } = parseArgs({
-  options: {
-    workspace: { type: 'string', default: process.cwd() },
-    space: { type: 'string' },
-    actor: { type: 'string', default: `worker-${process.pid}` },
-    model: { type: 'string', default: 'claude' },
-    'max-tasks': { type: 'string', default: '50' },
-    timeout: { type: 'string', default: '600' },
-  },
-});
-
-if (!args.space) {
-  console.error('--space required');
-  process.exit(1);
-}
-
-const WORKSPACE = path.resolve(args.workspace);
-const WG = `node ${path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'bin', 'workgraph.js')}`;
-const MAX_TASKS = parseInt(args['max-tasks'], 10);
-const TIMEOUT_MS = parseInt(args.timeout, 10) * 1000;
-
-let completed = 0;
-let errors = 0;
-
-while (completed + errors < MAX_TASKS) {
-  // Claim next task
-  let claimed;
-  try {
-    const claimJson = execSync(
-      `${WG} swarm claim ${args.space} --workspace ${WORKSPACE} --actor ${args.actor} --json`,
-      { timeout: 10000 }
-    ).toString();
-    claimed = JSON.parse(claimJson);
-    if (!claimed.claimed) {
-      console.log('NO_MORE_TASKS');
-      break;
-    }
-  } catch (err) {
-    console.log('NO_MORE_TASKS');
-    break;
-  }
-
-  console.log(`CLAIMED: ${claimed.path} — ${claimed.title}`);
-
-  // Read the thread to get the task description
-  let taskBody;
-  try {
-    const threadFile = path.join(WORKSPACE, claimed.path);
-    taskBody = fs.readFileSync(threadFile, 'utf-8');
-  } catch {
-    console.log(`ERROR: Could not read ${claimed.path}`);
-    errors++;
-    continue;
-  }
-
-  // Extract task description (everything between frontmatter and ## Output)
-  const bodyMatch = taskBody.match(/---\n[\s\S]*?---\n([\s\S]*?)(?=## Output|$)/);
-  const taskDescription = bodyMatch ? bodyMatch[1].trim() : taskBody;
-
-  // Execute task with LLM
-  const taskPrompt = `You are a focused worker agent. Complete this task thoroughly and return ONLY the result content (no meta-commentary).
-
-TASK: ${claimed.title}
-
-INSTRUCTIONS:
-${taskDescription}
-
-Write your complete result now. Be thorough, detailed, and high-quality.`;
-
-  let result;
-  try {
-    result = execSync(
-      `claude -p "${taskPrompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}" 2>/dev/null`,
-      { maxBuffer: 10 * 1024 * 1024, timeout: TIMEOUT_MS }
-    ).toString().trim();
-  } catch (err) {
-    console.log(`ERROR: LLM failed for ${claimed.path}: ${err.message}`);
-    errors++;
-    continue;
-  }
-
-  // Write result back
-  try {
-    // Save result to temp file then use CLI
-    const tmpFile = path.join(WORKSPACE, '.workgraph', `tmp-${args.actor}-${Date.now()}.md`);
-    fs.writeFileSync(tmpFile, result);
-    execSync(
-      `${WG} swarm complete ${claimed.path} --workspace ${WORKSPACE} --actor ${args.actor} --result @${tmpFile} --json`,
-      { timeout: 10000 }
-    );
-    fs.unlinkSync(tmpFile);
-    completed++;
-    console.log(`COMPLETED: ${claimed.path} (${result.length} chars)`);
-  } catch (err) {
-    console.log(`ERROR: Could not complete ${claimed.path}: ${err.message}`);
-    errors++;
-  }
-}
-
-console.log(`DONE: completed=${completed} errors=${errors}`);
-process.exit(0);
diff --git a/tests/helpers/cli-build.ts b/tests/helpers/cli-build.ts
deleted file mode 100644
index fed0c71..0000000
--- a/tests/helpers/cli-build.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync, type SpawnSyncReturns } from 'node:child_process';
-
-const BUILD_LOCK_DIR = path.join(os.tmpdir(), 'workgraph-cli-build-lock');
-const DIST_ENTRY = path.resolve('dist/cli.js');
-const PNPM_COMMAND = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
-const BUILD_LOCK_POLL_MS = 50;
-const SLEEP_BUFFER = new SharedArrayBuffer(4);
-const SLEEP_ARRAY = new Int32Array(SLEEP_BUFFER);
-const CLI_BUILD_DEPENDENCIES = [
-  path.resolve('package.json'),
-  path.resolve('tsup.config.ts'),
-  path.resolve('packages/cli/src'),
-  path.resolve('packages/kernel/src'),
-  path.resolve('packages/control-api/src'),
-  path.resolve('packages/mcp-server/src'),
-  path.resolve('packages/adapter-claude-code/src'),
-  path.resolve('packages/adapter-cursor-cloud/src'),
-  path.resolve('packages/obsidian-integration/src'),
-  path.resolve('packages/policy/src'),
-  path.resolve('packages/runtime-adapter-core/src'),
-  path.resolve('packages/search-qmd-adapter/src'),
-  path.resolve('packages/sdk/src'),
-  path.resolve('packages/skills/src'),
-];
-
-export function ensureCliBuiltForTests(): void {
-  if (!needsCliBuild()) return;
-
-  acquireBuildLock();
-  try {
-    // Re-check under lock so only one worker pays build cost.
-    if (!needsCliBuild()) return;
-    const result = runBuild();
-    if (result.status !== 0) {
-      throw new Error(`Failed to build CLI for tests.\n${formatBuildFailure(result)}`);
-    }
-  } finally {
-    releaseBuildLock();
-  }
-}
-
-function acquireBuildLock(): void {
-  // Directory creation is atomic; retries coordinate concurrent test workers.
-  while (true) {
-    try {
-      fs.mkdirSync(BUILD_LOCK_DIR);
-      return;
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException).code;
-      if (code !== 'EEXIST') throw error;
-      sleep(BUILD_LOCK_POLL_MS);
-    }
-  }
-}
-
-function releaseBuildLock(): void {
-  fs.rmSync(BUILD_LOCK_DIR, { recursive: true, force: true });
-}
-
-function runBuild(): SpawnSyncReturns<string> {
-  const npmExecPath = process.env.npm_execpath;
-  if (npmExecPath) {
-    return spawnSync(process.execPath, [npmExecPath, 'run', '--silent', 'build'], {
-      encoding: 'utf-8',
-    });
-  }
-  if (process.platform === 'win32') {
-    return spawnSync('cmd.exe', ['/d', '/s', '/c', `${PNPM_COMMAND} run --silent build`], {
-      encoding: 'utf-8',
-    });
-  }
-  return spawnSync(PNPM_COMMAND, ['run', '--silent', 'build'], {
-    encoding: 'utf-8',
-  });
-}
-
-function needsCliBuild(): boolean {
-  if (!fs.existsSync(DIST_ENTRY)) return true;
-  const distMtime = safeMtimeMs(DIST_ENTRY);
-  if (distMtime === null) return true;
-  return CLI_BUILD_DEPENDENCIES.some((entryPath) => hasNewerMtime(entryPath, distMtime));
-}
-
-function hasNewerMtime(entryPath: string, thresholdMtime: number): boolean {
-  if (!fs.existsSync(entryPath)) return false;
-  const stats = fs.statSync(entryPath);
-  if (stats.isFile()) {
-    return stats.mtimeMs > thresholdMtime;
-  }
-  if (!stats.isDirectory()) return false;
-
-  const entries = fs.readdirSync(entryPath);
-  for (const childName of entries) {
-    const childPath = path.join(entryPath, childName);
-    if (hasNewerMtime(childPath, thresholdMtime)) return true;
-  }
-  return false;
-}
-
-function safeMtimeMs(filePath: string): number | null {
-  try {
-    return fs.statSync(filePath).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-
-function formatBuildFailure(result: SpawnSyncReturns<string>): string {
-  const stderr = result.stderr?.trim();
-  const stdout = result.stdout?.trim();
-  const error = result.error?.message;
-  return [
-    `status=${String(result.status)} signal=${String(result.signal)}`,
-    error ? `error=${error}` : '',
-    `stdout:\n${stdout || '(empty)'}`,
-    `stderr:\n${stderr || '(empty)'}`,
-  ].filter(Boolean).join('\n');
-}
-
-function sleep(ms: number): void {
-  Atomics.wait(SLEEP_ARRAY, 0, 0, ms);
-}
diff --git a/tests/integration/cli-compat.test.ts b/tests/integration/cli-compat.test.ts
deleted file mode 100644
index 6314258..0000000
--- a/tests/integration/cli-compat.test.ts
+++ /dev/null
@@ -1,307 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { spawnSync } from 'node:child_process';
-import { ensureCliBuiltForTests } from '../helpers/cli-build.js';
-
-function runCli(args: string[]): { ok: boolean; data?: unknown; error?: string } {
-  ensureCliBuiltForTests();
-  const result = spawnSync('node', [path.resolve('bin/workgraph.js'), ...args], {
-    encoding: 'utf-8',
-  });
-  const output = (result.stdout || result.stderr || '').trim();
-  let parsed: { ok: boolean; data?: unknown; error?: string } | null = null;
-  try {
-    parsed = JSON.parse(output) as { ok: boolean; data?: unknown; error?: string };
-  } catch {
-    throw new Error(`CLI output was not valid JSON for args [${args.join(' ')}]: ${output}`);
-  }
-  return parsed;
-}
-
-describe('CLI compatibility smoke', () => {
-  beforeAll(() => {
-    ensureCliBuiltForTests();
-  });
-
-  it('keeps existing JSON envelope and legacy command behaviors', () => {
-    const workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-cli-compat-'));
-    try {
-      const init = runCli(['init', workspacePath, '--json']);
-      expect(init.ok).toBe(true);
-
-      const create = runCli([
-        'thread', 'create', 'Compatibility Thread',
-        '-w', workspacePath,
-        '--goal', 'Verify legacy flows',
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(create.ok).toBe(true);
-      const createdThreadPath = ((create.data as { thread: { path: string } }).thread.path);
-      const createdThreadEtag = String((create.data as { thread: { fields: { etag: string } } }).thread.fields.etag);
-
-      const conversationCreate = runCli([
-        'conversation', 'create', 'Compatibility Conversation',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--threads', createdThreadPath,
-        '--json',
-      ]);
-      expect(conversationCreate.ok).toBe(true);
-      const conversationPath = String(
-        (conversationCreate.data as { conversation: { path: string } }).conversation.path,
-      );
-
-      const planStepCreate = runCli([
-        'plan-step', 'create', conversationPath, 'Compatibility Plan Step',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--thread', createdThreadPath,
-        '--json',
-      ]);
-      expect(planStepCreate.ok).toBe(true);
-      const planStepPath = String((planStepCreate.data as { step: { path: string } }).step.path);
-
-      const planStepProgress = runCli([
-        'plan-step', 'progress', planStepPath, '35',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(planStepProgress.ok).toBe(true);
-
-      const planStepBlock = runCli([
-        'plan-step', 'block', planStepPath,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--reason', 'waiting for compatibility signal',
-        '--json',
-      ]);
-      expect(planStepBlock.ok).toBe(true);
-
-      const planStepStart = runCli([
-        'plan-step', 'start', planStepPath,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(planStepStart.ok).toBe(true);
-
-      const planStepDone = runCli([
-        'plan-step', 'done', planStepPath,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(planStepDone.ok).toBe(true);
-
-      const conversationMessage = runCli([
-        'conversation', 'message', conversationPath, 'Compatibility plan-step completed',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--kind', 'note',
-        '--thread', createdThreadPath,
-        '--json',
-      ]);
-      expect(conversationMessage.ok).toBe(true);
-
-      const conversationState = runCli([
-        'conversation', 'state', conversationPath,
-        '-w', workspacePath,
-        '--json',
-      ]);
-      expect(conversationState.ok).toBe(true);
-
-      const primitiveUpdate = runCli([
-        'primitive', 'update', createdThreadPath,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--set', 'priority=high',
-        '--etag', createdThreadEtag,
-        '--json',
-      ]);
-      expect(primitiveUpdate.ok).toBe(true);
-
-      const list = runCli(['thread', 'list', '-w', workspacePath, '--json']);
-      expect(list.ok).toBe(true);
-
-      const claim = runCli([
-        'thread', 'claim', 'threads/compatibility-thread.md',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(claim.ok).toBe(true);
-
-      const done = runCli([
-        'thread', 'done', 'threads/compatibility-thread.md',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--output', 'Completed in compatibility test https://github.com/versatly/workgraph/pull/71',
-        '--json',
-      ]);
-      expect(done.ok).toBe(true);
-
-      const ledger = runCli(['ledger', 'show', '-w', workspacePath, '--count', '10', '--json']);
-      expect(ledger.ok).toBe(true);
-
-      const commandCenter = runCli([
-        'command-center',
-        '-w', workspacePath,
-        '--output', 'ops/Command Center.md',
-        '--json',
-      ]);
-      expect(commandCenter.ok).toBe(true);
-
-      const dispatchCreate = runCli([
-        'dispatch', 'create', 'Compatibility dispatch objective',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(dispatchCreate.ok).toBe(true);
-      const runId = String((dispatchCreate.data as { run: { id: string } }).run.id);
-
-      const dispatchMark = runCli([
-        'dispatch', 'mark', runId,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--status', 'running',
-        '--json',
-      ]);
-      expect(dispatchMark.ok).toBe(true);
-
-      const dispatchHeartbeat = runCli([
-        'dispatch', 'heartbeat', runId,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--lease-minutes', '35',
-        '--json',
-      ]);
-      expect(dispatchHeartbeat.ok).toBe(true);
-
-      const dispatchHandoff = runCli([
-        'dispatch', 'handoff', runId,
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--to', 'agent-specialist',
-        '--reason', 'compatibility handoff',
-        '--json',
-      ]);
-      expect(dispatchHandoff.ok).toBe(true);
-
-      const dispatchReconcile = runCli([
-        'dispatch', 'reconcile',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--json',
-      ]);
-      expect(dispatchReconcile.ok).toBe(true);
-
-      const agentHeartbeat = runCli([
-        'agent', 'heartbeat', 'agent-compat',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--status', 'online',
-        '--capabilities', 'cli,testing',
-        '--json',
-      ]);
-      expect(agentHeartbeat.ok).toBe(true);
-
-      const agentList = runCli([
-        'agent', 'list',
-        '-w', workspacePath,
-        '--json',
-      ]);
-      expect(agentList.ok).toBe(true);
-      const lensList = runCli([
-        'lens', 'list',
-        '-w', workspacePath,
-        '--json',
-      ]);
-      expect(lensList.ok).toBe(true);
-
-      const lensShow = runCli([
-        'lens', 'show', 'my-work',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--output', 'ops/lenses/my-work.md',
-        '--json',
-      ]);
-      expect(lensShow.ok).toBe(true);
-
-      const skillWrite = runCli([
-        'skill', 'write', 'compat-skill',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--body', '# Compat Skill',
-        '--json',
-      ]);
-      expect(skillWrite.ok).toBe(true);
-
-      const skillLoad = runCli([
-        'skill', 'load', 'compat-skill',
-        '-w', workspacePath,
-        '--json',
-      ]);
-      expect(skillLoad.ok).toBe(true);
-
-      const integrationList = runCli([
-        'integration', 'list',
-        '-w', workspacePath,
-        '--json',
-      ]);
-      expect(integrationList.ok).toBe(true);
-
-      const integrationInstall = runCli([
-        'integration', 'install', 'clawdapus',
-        '-w', workspacePath,
-        '--actor', 'agent-compat',
-        '--source-url', 'data:text/plain,%23%20Clawdapus%0A',
-        '--json',
-      ]);
-      expect(integrationInstall.ok).toBe(true);
-    } finally {
-      fs.rmSync(workspacePath, { recursive: true, force: true });
-    }
-  });
-
-  it('documents new dispatch, agent, and primitive etag options in --help output', () => {
-    const dispatchHelp = spawnSync('node', [path.resolve('bin/workgraph.js'), 'dispatch', '--help'], {
-      encoding: 'utf-8',
-    });
-    expect(dispatchHelp.status).toBe(0);
-    expect(dispatchHelp.stdout).toContain('heartbeat');
-    expect(dispatchHelp.stdout).toContain('reconcile');
-    expect(dispatchHelp.stdout).toContain('handoff');
-
-    const agentHelp = spawnSync('node', [path.resolve('bin/workgraph.js'), 'agent', '--help'], {
-      encoding: 'utf-8',
-    });
-    expect(agentHelp.status).toBe(0);
-    expect(agentHelp.stdout).toContain('heartbeat');
-    expect(agentHelp.stdout).toContain('list');
-
-    const primitiveUpdateHelp = spawnSync('node', [path.resolve('bin/workgraph.js'), 'primitive', 'update', 'target.md', '--help'], {
-      encoding: 'utf-8',
-    });
-    expect(primitiveUpdateHelp.status).toBe(0);
-    expect(primitiveUpdateHelp.stdout).toContain('--etag');
-
-    const conversationHelp = spawnSync('node', [path.resolve('bin/workgraph.js'), 'conversation', '--help'], {
-      encoding: 'utf-8',
-    });
-    expect(conversationHelp.status).toBe(0);
-    expect(conversationHelp.stdout).toContain('thread-add');
-    expect(conversationHelp.stdout).toContain('state');
-
-    const planStepHelp = spawnSync('node', [path.resolve('bin/workgraph.js'), 'plan-step', '--help'], {
-      encoding: 'utf-8',
-    });
-    expect(planStepHelp.status).toBe(0);
-    expect(planStepHelp.stdout).toContain('progress');
-    expect(planStepHelp.stdout).toContain('block');
-  });
-});
diff --git a/tests/integration/multi-agent-showcase.test.ts b/tests/integration/multi-agent-showcase.test.ts
deleted file mode 100644
index abce7dc..0000000
--- a/tests/integration/multi-agent-showcase.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { ensureCliBuiltForTests } from '../helpers/cli-build.js';
-
-describe('OBJ-09 multi-agent showcase', () => {
-  beforeAll(() => {
-    ensureCliBuiltForTests();
-  });
-
-  it('runs end-to-end from a fresh workspace', () => {
-    const workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-obj09-showcase-'));
-    try {
-      const result = spawnSync(
-        'node',
-        [
-          path.resolve('examples/multi-agent-showcase/run.mjs'),
-          '--workspace',
-          workspacePath,
-          '--skip-build',
-          '--json',
-        ],
-        {
-          encoding: 'utf-8',
-          cwd: path.resolve('.'),
-          env: process.env,
-        },
-      );
-      expect(result.status).toBe(0);
-
-      const output = String(result.stdout ?? '').trim();
-      let parsed: {
-        ok: boolean;
-        checks: Record<string, boolean>;
-        rollup: { threadCount: number; runCount: number; ledgerEntryCount: number };
-      };
-      try {
-        parsed = JSON.parse(output) as typeof parsed;
-      } catch {
-        throw new Error(`Showcase output was not valid JSON:\n${output}`);
-      }
-
-      expect(parsed.ok).toBe(true);
-      expect(parsed.checks.governance).toBe(true);
-      expect(parsed.checks.selfAssemblyClaimedReviewerThread).toBe(true);
-      expect(parsed.checks.planStepCoordinated).toBe(true);
-      expect(parsed.checks.triggerRunEvidence).toBe(true);
-      expect(parsed.checks.ledgerActivity).toBe(true);
-      expect(parsed.rollup.threadCount).toBeGreaterThanOrEqual(4);
-      expect(parsed.rollup.runCount).toBeGreaterThanOrEqual(1);
-      expect(parsed.rollup.ledgerEntryCount).toBeGreaterThan(0);
-
-      expect(fs.existsSync(path.join(workspacePath, '.workgraph', 'ledger.jsonl'))).toBe(true);
-      expect(fs.existsSync(path.join(workspacePath, 'threads'))).toBe(true);
-    } finally {
-      fs.rmSync(workspacePath, { recursive: true, force: true });
-    }
-  });
-});
diff --git a/tests/integration/portability-cli.test.ts b/tests/integration/portability-cli.test.ts
deleted file mode 100644
index d5442a2..0000000
--- a/tests/integration/portability-cli.test.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { ensureCliBuiltForTests } from '../helpers/cli-build.js';
-
-interface CliEnvelope {
-  ok: boolean;
-  data?: unknown;
-  error?: string;
-}
-
-function runCli(args: string[]): CliEnvelope {
-  ensureCliBuiltForTests();
-  const result = spawnSync('node', [path.resolve('bin/workgraph.js'), ...args], {
-    encoding: 'utf-8',
-  });
-  const output = (result.stdout || result.stderr || '').trim();
-  try {
-    return JSON.parse(output) as CliEnvelope;
-  } catch {
-    throw new Error(`CLI output was not valid JSON for args [${args.join(' ')}]: ${output}`);
-  }
-}
-
-describe('portability CLI commands', () => {
-  beforeAll(() => {
-    ensureCliBuiltForTests();
-  });
-
-  it('supports env/export/import commands end-to-end', () => {
-    const sourceWorkspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-portability-source-'));
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-portability-cli-'));
-    const importedWorkspacePath = path.join(tempRoot, 'imported-workspace');
-    const snapshotPath = path.join(tempRoot, 'workspace.tar.gz');
-
-    try {
-      const init = runCli(['init', sourceWorkspacePath, '--json']);
-      expect(init.ok).toBe(true);
-
-      const env = runCli(['env', '--json']);
-      expect(env.ok).toBe(true);
-      expect((env.data as { environment: string }).environment.length).toBeGreaterThan(0);
-
-      const exportResult = runCli([
-        'export',
-        snapshotPath,
-        '-w',
-        sourceWorkspacePath,
-        '--json',
-      ]);
-      expect(exportResult.ok).toBe(true);
-      expect(fs.existsSync(snapshotPath)).toBe(true);
-
-      const importResult = runCli([
-        'import',
-        snapshotPath,
-        '-w',
-        importedWorkspacePath,
-        '--json',
-      ]);
-      expect(importResult.ok).toBe(true);
-      expect(fs.existsSync(path.join(importedWorkspacePath, '.workgraph.json'))).toBe(true);
-
-      const listThreads = runCli(['thread', 'list', '-w', importedWorkspacePath, '--json']);
-      expect(listThreads.ok).toBe(true);
-    } finally {
-      fs.rmSync(sourceWorkspacePath, { recursive: true, force: true });
-      fs.rmSync(tempRoot, { recursive: true, force: true });
-    }
-  });
-
-  it('exposes portability commands in help output', () => {
-    const help = spawnSync('node', [path.resolve('bin/workgraph.js'), '--help'], {
-      encoding: 'utf-8',
-    });
-
-    expect(help.status).toBe(0);
-    expect(help.stdout).toContain('export');
-    expect(help.stdout).toContain('import');
-    expect(help.stdout).toContain('env');
-  });
-});
diff --git a/tests/integration/remote-cli.test.ts b/tests/integration/remote-cli.test.ts
deleted file mode 100644
index 708e8a4..0000000
--- a/tests/integration/remote-cli.test.ts
+++ /dev/null
@@ -1,217 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { policy as policyModule, workspace as workspaceModule } from '@versatly/workgraph-kernel';
-import { startWorkgraphMcpHttpServer } from '@versatly/workgraph-mcp-server';
-import { ensureCliBuiltForTests } from '../helpers/cli-build.js';
-
-interface CliEnvelope {
-  ok: boolean;
-  data?: unknown;
-  error?: string;
-}
-
-const policy = policyModule;
-const workspace = workspaceModule;
-
-async function runCli(args: string[]): Promise<CliEnvelope> {
-  ensureCliBuiltForTests();
-  return new Promise((resolve, reject) => {
-    const child = spawn('node', [path.resolve('bin/workgraph.js'), ...args], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on('error', reject);
-    child.on('close', () => {
-      const output = (stdout || stderr || '').trim();
-      try {
-        resolve(JSON.parse(output) as CliEnvelope);
-      } catch {
-        reject(new Error(`CLI output was not valid JSON for args [${args.join(' ')}]: ${output}`));
-      }
-    });
-  });
-}
-
-describe('CLI remote/API mode', () => {
-  beforeAll(() => {
-    ensureCliBuiltForTests();
-  });
-
-  it('routes key commands through MCP HTTP when --api-url is set', async () => {
-    const workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-cli-remote-'));
-    const init = workspace.initWorkspace(workspacePath, {
-      createReadme: false,
-      createBases: false,
-    });
-    policy.upsertParty(workspacePath, 'remote-admin', {
-      roles: ['operator'],
-      capabilities: ['mcp:write', 'thread:create', 'thread:claim', 'thread:done', 'checkpoint:create', 'agent:heartbeat'],
-    }, {
-      actor: 'remote-admin',
-      skipAuthorization: true,
-    });
-
-    const handle = await startWorkgraphMcpHttpServer({
-      workspacePath,
-      defaultActor: 'remote-admin',
-      host: '127.0.0.1',
-      port: 0,
-      bearerToken: 'remote-test-token',
-    });
-
-    const remoteWorkspacePath = path.join(os.tmpdir(), 'wg-cli-remote-nonexistent-workspace');
-    try {
-      const commonRemoteArgs = ['--api-url', handle.url, '--api-key', 'remote-test-token', '-w', remoteWorkspacePath];
-
-      const threadCreate = await runCli([
-        'thread', 'create', 'Remote API Thread',
-        ...commonRemoteArgs,
-        '--goal', 'Validate remote thread create',
-        '--actor', 'remote-admin',
-        '--json',
-      ]);
-      if (!threadCreate.ok) {
-        throw new Error(`thread create failed: ${JSON.stringify(threadCreate)}`);
-      }
-      const threadPath = String((threadCreate.data as { thread: { path: string } }).thread.path);
-
-      const threadList = await runCli([
-        'thread', 'list',
-        ...commonRemoteArgs,
-        '--json',
-      ]);
-      expect(threadList.ok).toBe(true);
-      expect(((threadList.data as { count: number }).count) >= 1).toBe(true);
-
-      const threadNext = await runCli([
-        'thread', 'next',
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--json',
-      ]);
-      expect(threadNext.ok).toBe(true);
-
-      const threadClaim = await runCli([
-        'thread', 'claim', threadPath,
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--json',
-      ]);
-      expect(threadClaim.ok).toBe(true);
-
-      const threadDone = await runCli([
-        'thread', 'done', threadPath,
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--output', 'Finished via remote API mode https://cursor.com/remote-proof',
-        '--json',
-      ]);
-      expect(threadDone.ok, JSON.stringify(threadDone)).toBe(true);
-
-      const status = await runCli([
-        'status',
-        ...commonRemoteArgs,
-        '--json',
-      ]);
-      expect(status.ok).toBe(true);
-
-      const brief = await runCli([
-        'brief',
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--json',
-      ]);
-      expect(brief.ok).toBe(true);
-
-      const checkpoint = await runCli([
-        'checkpoint', 'Remote checkpoint summary',
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--next', 'finalize validation',
-        '--json',
-      ]);
-      expect(checkpoint.ok).toBe(true);
-
-      const register = await runCli([
-        'agent', 'register', 'remote-agent',
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--token', init.bootstrapTrustToken,
-        '--json',
-      ]);
-      expect(register.ok).toBe(true);
-
-      const heartbeat = await runCli([
-        'agent', 'heartbeat', 'remote-agent',
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--status', 'online',
-        '--json',
-      ]);
-      expect(heartbeat.ok).toBe(true);
-
-      const agentList = await runCli([
-        'agent', 'list',
-        ...commonRemoteArgs,
-        '--json',
-      ]);
-      expect(agentList.ok).toBe(true);
-      expect(((agentList.data as { count: number }).count) >= 1).toBe(true);
-
-      const search = await runCli([
-        'search', 'Remote API Thread',
-        ...commonRemoteArgs,
-        '--json',
-      ]);
-      expect(search.ok).toBe(true);
-      expect(((search.data as { count: number }).count) >= 1).toBe(true);
-
-      const query = await runCli([
-        'query',
-        ...commonRemoteArgs,
-        '--type', 'thread',
-        '--json',
-      ]);
-      expect(query.ok).toBe(true);
-      expect(((query.data as { count: number }).count) >= 1).toBe(true);
-
-      const lensList = await runCli([
-        'lens', 'list',
-        ...commonRemoteArgs,
-        '--json',
-      ]);
-      expect(lensList.ok).toBe(true);
-      expect(((lensList.data as { lenses: unknown[] }).lenses.length) > 0).toBe(true);
-
-      const lensShow = await runCli([
-        'lens', 'show', 'my-work',
-        ...commonRemoteArgs,
-        '--actor', 'remote-admin',
-        '--json',
-      ]);
-      expect(lensShow.ok).toBe(true);
-
-      const remoteTest = await runCli([
-        'remote', 'test',
-        '--api-url', handle.url,
-        '--api-key', 'remote-test-token',
-        '--json',
-      ]);
-      expect(remoteTest.ok).toBe(true);
-      expect(((remoteTest.data as { toolCount: number }).toolCount) > 0).toBe(true);
-    } finally {
-      await handle.close();
-      fs.rmSync(workspacePath, { recursive: true, force: true });
-    }
-  }, 60_000);
-});
diff --git a/tests/integration/trigger-cli.test.ts b/tests/integration/trigger-cli.test.ts
deleted file mode 100644
index e3cb5b7..0000000
--- a/tests/integration/trigger-cli.test.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { ensureCliBuiltForTests } from '../helpers/cli-build.js';
-
-interface CliEnvelope {
-  ok: boolean;
-  data?: unknown;
-  error?: string;
-}
-
-function runCli(args: string[]): CliEnvelope {
-  ensureCliBuiltForTests();
-  const result = spawnSync('node', [path.resolve('bin/workgraph.js'), ...args], {
-    encoding: 'utf-8',
-  });
-  const output = (result.stdout || result.stderr || '').trim();
-  try {
-    return JSON.parse(output) as CliEnvelope;
-  } catch {
-    throw new Error(`CLI output was not valid JSON for args [${args.join(' ')}]: ${output}`);
-  }
-}
-
-describe('trigger CLI programmable primitives', () => {
-  beforeAll(() => {
-    ensureCliBuiltForTests();
-  });
-
-  it('supports trigger CRUD, evaluate, and history commands', () => {
-    const workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-trigger-cli-'));
-    try {
-      const init = runCli(['init', workspacePath, '--json']);
-      expect(init.ok).toBe(true);
-
-      const create = runCli([
-        'trigger', 'create', 'CLI Manual Trigger',
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--type', 'manual',
-        '--condition', '{"type":"manual"}',
-        '--objective', 'Run CLI manual dispatch',
-        '--cooldown', '45',
-        '--json',
-      ]);
-      expect(create.ok).toBe(true);
-      const triggerPath = String((create.data as { trigger: { path: string } }).trigger.path);
-
-      const list = runCli(['trigger', 'list', '-w', workspacePath, '--json']);
-      expect(list.ok).toBe(true);
-      expect(((list.data as { count: number }).count) >= 1).toBe(true);
-
-      const show = runCli(['trigger', 'show', triggerPath, '-w', workspacePath, '--json']);
-      expect(show.ok).toBe(true);
-      expect((show.data as { trigger: { fields: { type: string } } }).trigger.fields.type).toBe('manual');
-
-      const disable = runCli([
-        'trigger', 'disable', triggerPath,
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--json',
-      ]);
-      expect(disable.ok).toBe(true);
-
-      const enable = runCli([
-        'trigger', 'enable', triggerPath,
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--json',
-      ]);
-      expect(enable.ok).toBe(true);
-
-      const evaluateOne = runCli([
-        'trigger', 'evaluate', triggerPath,
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--json',
-      ]);
-      expect(evaluateOne.ok).toBe(true);
-
-      const fire = runCli([
-        'trigger', 'fire', triggerPath,
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--event-key', 'cli-manual-evt-1',
-        '--json',
-      ]);
-      expect(fire.ok).toBe(true);
-      const runId = String((fire.data as { run: { id: string } }).run.id);
-      expect(runId.length > 0).toBe(true);
-
-      const history = runCli([
-        'trigger', 'history', triggerPath,
-        '-w', workspacePath,
-        '--json',
-      ]);
-      expect(history.ok).toBe(true);
-      expect(((history.data as { count: number }).count) > 0).toBe(true);
-
-      const update = runCli([
-        'trigger', 'update', triggerPath,
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--type', 'event',
-        '--condition', '{"type":"event","pattern":"thread.*"}',
-        '--enabled', 'true',
-        '--json',
-      ]);
-      expect(update.ok).toBe(true);
-      expect((update.data as { trigger: { fields: { type: string } } }).trigger.fields.type).toBe('event');
-
-      const remove = runCli([
-        'trigger', 'delete', triggerPath,
-        '-w', workspacePath,
-        '--actor', 'system',
-        '--json',
-      ]);
-      expect(remove.ok).toBe(true);
-    } finally {
-      fs.rmSync(workspacePath, { recursive: true, force: true });
-    }
-  });
-});
diff --git a/tests/stress/capability-matching.test.ts b/tests/stress/capability-matching.test.ts
deleted file mode 100644
index c08577f..0000000
--- a/tests/stress/capability-matching.test.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import {
-  agent as agentModule,
-  capability as capabilityModule,
-  policy as policyModule,
-  store as storeModule,
-  thread as threadModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-
-const agent = agentModule;
-const capability = capabilityModule;
-const policy = policyModule;
-const store = storeModule;
-const thread = threadModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-stress-capability-matching-'));
-  workspace.initWorkspace(workspacePath, { createReadme: false });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('stress: capability matching at scale', () => {
-  it('matches 50 agents against 100 threads under 100ms with accurate scoring', { timeout: 30_000 }, () => {
-    const agentCount = 50;
-    const threadCount = 100;
-    const agentCapabilities = new Map<string, string[]>();
-
-    for (let idx = 0; idx < agentCount; idx += 1) {
-      const agentName = `agent-${idx}`;
-      const capabilities = [
-        `domain:team-${idx % 5}`,
-        `dispatch:lane-${idx % 10}`,
-        `skill:skill-${idx % 10}`,
-        `adapter:adapter-${idx % 4}`,
-      ];
-      agentCapabilities.set(agentName, capabilities);
-      policy.upsertParty(
-        workspacePath,
-        agentName,
-        {
-          roles: ['ops'],
-          capabilities,
-        },
-        {
-          actor: 'system',
-          skipAuthorization: true,
-        },
-      );
-      agent.heartbeat(workspacePath, agentName, {
-        actor: 'system',
-        capabilities,
-      });
-    }
-
-    for (let idx = 0; idx < threadCount; idx += 1) {
-      const sourceAgent = `agent-${idx % agentCount}`;
-      const sourceCapabilities = agentCapabilities.get(sourceAgent) ?? [];
-      const created = thread.createThread(
-        workspacePath,
-        `Capability thread ${idx}`,
-        `Match capabilities for thread ${idx}.`,
-        'system',
-      );
-      store.update(
-        workspacePath,
-        created.path,
-        {
-          required_capabilities: [sourceCapabilities[0], sourceCapabilities[1]],
-          required_skills: [String(sourceCapabilities[2]).replace('skill:', '')],
-          required_adapters: [String(sourceCapabilities[3]).replace('adapter:', '')],
-        },
-        undefined,
-        'system',
-      );
-    }
-
-    const capabilityRegistry = capability.buildAgentCapabilityRegistry(workspacePath);
-    const threadInstances = store.list(workspacePath, 'thread');
-    expect(capabilityRegistry.agents.length).toBeGreaterThanOrEqual(agentCount);
-    const registryNames = new Set(capabilityRegistry.agents.map((entry) => entry.agentName));
-    for (let idx = 0; idx < agentCount; idx += 1) {
-      expect(registryNames.has(`agent-${idx}`)).toBe(true);
-    }
-    expect(threadInstances).toHaveLength(threadCount);
-
-    for (const threadInstance of threadInstances.slice(0, 5)) {
-      for (const profile of capabilityRegistry.agents.slice(0, 5)) {
-        capability.matchThreadToCapabilityProfile(threadInstance, profile);
-      }
-    }
-
-    const start = performance.now();
-    let matchedPairs = 0;
-    for (const threadInstance of threadInstances) {
-      for (const profile of capabilityRegistry.agents) {
-        const result = capability.matchThreadToCapabilityProfile(threadInstance, profile);
-        if (result.matched) {
-          matchedPairs += 1;
-        }
-      }
-    }
-    const elapsedMs = performance.now() - start;
-    expect(elapsedMs).toBeLessThan(100);
-    expect(matchedPairs).toBeGreaterThan(0);
-
-    const scoringThread = thread.createThread(
-      workspacePath,
-      'Scoring accuracy thread',
-      'Validate capability scoring order.',
-      'system',
-    );
-    store.update(
-      workspacePath,
-      scoringThread.path,
-      {
-        required_capabilities: ['domain:team-1', 'dispatch:lane-1'],
-        required_skills: ['skill-1'],
-        required_adapters: ['adapter-1'],
-      },
-      undefined,
-      'system',
-    );
-    const updatedScoringThread = store.read(workspacePath, scoringThread.path);
-    expect(updatedScoringThread).not.toBeNull();
-
-    const agentPerfect = capabilityRegistry.agents.find((entry) => entry.agentName === 'agent-1');
-    const agentPartial = capabilityRegistry.agents.find((entry) => entry.agentName === 'agent-11');
-    const agentPoor = capabilityRegistry.agents.find((entry) => entry.agentName === 'agent-22');
-    expect(agentPerfect).toBeDefined();
-    expect(agentPartial).toBeDefined();
-    expect(agentPoor).toBeDefined();
-
-    const score = (candidate: ReturnType<typeof capability.matchThreadToCapabilityProfile>): number => {
-      const totalMissing =
-        candidate.missing.capabilities.length
-        + candidate.missing.skills.length
-        + candidate.missing.adapters.length;
-      return 100 - totalMissing * 10;
-    };
-
-    const perfectMatch = capability.matchThreadToCapabilityProfile(updatedScoringThread!, agentPerfect!);
-    const partialMatch = capability.matchThreadToCapabilityProfile(updatedScoringThread!, agentPartial!);
-    const poorMatch = capability.matchThreadToCapabilityProfile(updatedScoringThread!, agentPoor!);
-
-    expect(perfectMatch.matched).toBe(true);
-    expect(partialMatch.matched).toBe(false);
-    expect(poorMatch.matched).toBe(false);
-    expect(score(perfectMatch)).toBeGreaterThan(score(partialMatch));
-    expect(score(partialMatch)).toBeGreaterThanOrEqual(score(poorMatch));
-  });
-});
diff --git a/tests/stress/federation-scale.test.ts b/tests/stress/federation-scale.test.ts
deleted file mode 100644
index f216a00..0000000
--- a/tests/stress/federation-scale.test.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  federation as federationModule,
-  registry as registryModule,
-  store as storeModule,
-  thread as threadModule,
-} from '@versatly/workgraph-kernel';
-
-const federation = federationModule;
-const registry = registryModule;
-const store = storeModule;
-const thread = threadModule;
-
-let rootWorkspacePath: string;
-let remoteWorkspacePaths: string[];
-
-beforeEach(() => {
-  rootWorkspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-stress-federation-root-'));
-  registry.saveRegistry(rootWorkspacePath, registry.loadRegistry(rootWorkspacePath));
-  remoteWorkspacePaths = [];
-});
-
-afterEach(() => {
-  fs.rmSync(rootWorkspacePath, { recursive: true, force: true });
-  for (const remotePath of remoteWorkspacePaths) {
-    fs.rmSync(remotePath, { recursive: true, force: true });
-  }
-});
-
-describe('stress: federation at scale', () => {
-  it('supports 20 remotes, 100+ cross-links, and federated search consistency', { timeout: 30_000 }, () => {
-    const remoteCount = 20;
-    const threadsPerRemote = 8;
-    const localThreadCount = 120;
-
-    const remotes = Array.from({ length: remoteCount }, (_value, idx) => {
-      const remotePath = fs.mkdtempSync(path.join(os.tmpdir(), `wg-stress-federation-remote-${idx}-`));
-      remoteWorkspacePaths.push(remotePath);
-      registry.saveRegistry(remotePath, registry.loadRegistry(remotePath));
-
-      for (let threadIdx = 0; threadIdx < threadsPerRemote; threadIdx += 1) {
-        thread.createThread(
-          remotePath,
-          `Remote ${idx} thread ${threadIdx}`,
-          `Federated scale keyword remote-${idx} item-${threadIdx}.`,
-          `remote-agent-${idx}`,
-        );
-      }
-
-      const remoteId = `remote-${idx}`;
-      federation.addRemoteWorkspace(rootWorkspacePath, {
-        id: remoteId,
-        path: remotePath,
-        name: `Remote ${idx}`,
-        tags: ['stress', 'federation'],
-      });
-      const remoteThreads = store.list(remotePath, 'thread').map((entry) => entry.path);
-      return {
-        id: remoteId,
-        path: remotePath,
-        threadPaths: remoteThreads,
-      };
-    });
-
-    const localThreads = Array.from({ length: localThreadCount }, (_value, idx) =>
-      thread.createThread(
-        rootWorkspacePath,
-        `Local federated thread ${idx}`,
-        `Local side federated workload ${idx}.`,
-        'local-agent',
-      ));
-
-    for (const [idx, localThread] of localThreads.entries()) {
-      const remote = remotes[idx % remotes.length];
-      const remoteThreadPath = remote.threadPaths[idx % remote.threadPaths.length];
-      federation.linkThreadToRemoteWorkspace(
-        rootWorkspacePath,
-        localThread.path,
-        remote.id,
-        remoteThreadPath,
-        'local-agent',
-      );
-    }
-
-    const federatedSearch = federation.searchFederated(rootWorkspacePath, 'federated scale keyword', {
-      type: 'thread',
-      includeLocal: true,
-    });
-    expect(federatedSearch.errors).toEqual([]);
-    expect(federatedSearch.results.length).toBeGreaterThanOrEqual(remoteCount * threadsPerRemote);
-
-    const remoteResultIds = new Set(
-      federatedSearch.results
-        .map((entry) => entry.workspaceId)
-        .filter((workspaceId) => workspaceId !== 'local'),
-    );
-    expect(remoteResultIds.size).toBe(remoteCount);
-
-    const localThreadInstances = store.list(rootWorkspacePath, 'thread');
-    let linkedCount = 0;
-    for (const localThread of localThreadInstances) {
-      const links = Array.isArray(localThread.fields.federation_links)
-        ? localThread.fields.federation_links.map((entry) => String(entry))
-        : [];
-      for (const link of links) {
-        const parsed = parseFederationLink(link);
-        expect(parsed).not.toBeNull();
-        const remote = remotes.find((entry) => entry.id === parsed!.remoteId);
-        expect(remote).toBeDefined();
-        const target = store.read(remote!.path, parsed!.remoteThreadPath);
-        expect(target?.type).toBe('thread');
-        linkedCount += 1;
-      }
-    }
-    expect(linkedCount).toBeGreaterThanOrEqual(100);
-  });
-});
-
-function parseFederationLink(link: string): { remoteId: string; remoteThreadPath: string } | null {
-  const prefix = 'federation://';
-  if (!link.startsWith(prefix)) return null;
-  const payload = link.slice(prefix.length);
-  const firstSlash = payload.indexOf('/');
-  if (firstSlash <= 0) return null;
-  const remoteId = payload.slice(0, firstSlash);
-  const remoteThreadPath = payload.slice(firstSlash + 1);
-  if (!remoteId || !remoteThreadPath) return null;
-  return { remoteId, remoteThreadPath };
-}
diff --git a/tests/stress/full-lifecycle.test.ts b/tests/stress/full-lifecycle.test.ts
deleted file mode 100644
index 1c72acc..0000000
--- a/tests/stress/full-lifecycle.test.ts
+++ /dev/null
@@ -1,198 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  agent as agentModule,
-  dispatch as dispatchModule,
-  ledger as ledgerModule,
-  policy as policyModule,
-  store as storeModule,
-  thread as threadModule,
-  threadAudit as threadAuditModule,
-  triggerEngine as triggerEngineModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-
-const agent = agentModule;
-const dispatch = dispatchModule;
-const ledger = ledgerModule;
-const policy = policyModule;
-const store = storeModule;
-const thread = threadModule;
-const threadAudit = threadAuditModule;
-const triggerEngine = triggerEngineModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-let bootstrapToken: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-stress-full-lifecycle-'));
-  const init = workspace.initWorkspace(workspacePath, { createReadme: false });
-  bootstrapToken = init.bootstrapTrustToken;
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('stress: full lifecycle end-to-end', () => {
-  it('runs 5 parallel end-to-end lifecycles with consistent global ledger state', { timeout: 30_000 }, async () => {
-    const adminRegistration = agent.registerAgent(workspacePath, 'admin-agent', {
-      token: bootstrapToken,
-      capabilities: [
-        'thread:create',
-        'thread:update',
-        'thread:claim',
-        'thread:complete',
-        'dispatch:run',
-        'policy:manage',
-      ],
-    });
-    expect(adminRegistration.agentName).toBe('admin-agent');
-
-    const lifecycleCount = 5;
-    const workers = Array.from({ length: lifecycleCount }, (_value, idx) => `worker-${idx}`);
-    for (const workerName of workers) {
-      policy.upsertParty(
-        workspacePath,
-        workerName,
-        {
-          roles: ['ops'],
-          capabilities: ['thread:create', 'thread:update', 'thread:claim', 'thread:complete', 'dispatch:run'],
-        },
-        {
-          actor: 'system',
-          skipAuthorization: true,
-        },
-      );
-      agent.heartbeat(workspacePath, workerName, {
-        actor: 'system',
-        capabilities: ['thread:claim', 'thread:complete', 'dispatch:run'],
-      });
-    }
-
-    const lifecycleResults = await Promise.all(
-      workers.map(async (workerName, idx) => {
-        const createdThread = thread.createThread(
-          workspacePath,
-          `Lifecycle thread ${idx}`,
-          `End-to-end lifecycle work item ${idx}.`,
-          workerName,
-        );
-        store.create(
-          workspacePath,
-          'fact',
-          {
-            title: `Lifecycle audit fact ${idx}`,
-            subject: 'lifecycle',
-            predicate: 'state',
-            object: 'pending',
-            tags: ['stress', 'lifecycle'],
-          },
-          '# Lifecycle Audit\n',
-          workerName,
-          { pathOverride: `facts/lifecycle-audit-${idx}.md` },
-        );
-        const trigger = store.create(
-          workspacePath,
-          'trigger',
-          {
-            title: `Lifecycle trigger ${idx}`,
-            status: 'active',
-            condition: { type: 'event', pattern: `thread.done:${createdThread.path}` },
-            action: {
-              type: 'update-primitive',
-              path: `facts/lifecycle-audit-${idx}.md`,
-              fields: { object: `completed-${idx}` },
-            },
-            cooldown: 0,
-          },
-          '# Lifecycle Trigger\n',
-          'admin-agent',
-          { pathOverride: `triggers/lifecycle-${idx}.md` },
-        );
-        triggerEngine.runTriggerEngineCycle(workspacePath, {
-          actor: workerName,
-          triggerPaths: [trigger.path],
-        });
-
-        const run = dispatch.createRun(workspacePath, {
-          actor: workerName,
-          objective: `Dispatch lifecycle ${idx}`,
-          context: { lifecycle: idx },
-        });
-        dispatch.markRun(workspacePath, run.id, workerName, 'running');
-        dispatch.markRun(workspacePath, run.id, workerName, 'succeeded', {
-          output: `dispatched-${idx}`,
-          contextPatch: { lifecycle_completed: true },
-        });
-
-        thread.claim(workspacePath, createdThread.path, workerName);
-        thread.done(
-          workspacePath,
-          createdThread.path,
-          workerName,
-          `Completed lifecycle ${idx} https://github.com/versatly/workgraph/pull/${1_000 + idx}`,
-          {
-            evidence: [
-              `https://github.com/versatly/workgraph/pull/${1_000 + idx}`,
-            ],
-          },
-        );
-
-        const triggerCycle = triggerEngine.runTriggerEngineCycle(workspacePath, {
-          actor: workerName,
-          triggerPaths: [trigger.path],
-        });
-        expect(triggerCycle.fired).toBe(1);
-
-        const auditTrail = dispatch.auditTrail(workspacePath, run.id);
-        expect(auditTrail.length).toBeGreaterThan(0);
-
-        const threadHistoryOps = ledger.historyOf(workspacePath, createdThread.path).map((entry) => entry.op);
-        expect(threadHistoryOps).toContain('create');
-        expect(threadHistoryOps).toContain('claim');
-        expect(threadHistoryOps).toContain('done');
-
-        return {
-          workerName,
-          runId: run.id,
-          threadPath: createdThread.path,
-          triggerPath: trigger.path,
-        };
-      }),
-    );
-
-    expect(lifecycleResults).toHaveLength(lifecycleCount);
-
-    const verify = ledger.verifyHashChain(workspacePath, { strict: true });
-    expect(verify.ok).toBe(true);
-    expect(verify.issues).toEqual([]);
-
-    const doneEntries = ledger.query(workspacePath, { op: 'done', type: 'thread' });
-    expect(doneEntries.length).toBeGreaterThanOrEqual(lifecycleCount);
-
-    for (const result of lifecycleResults) {
-      const finalThread = store.read(workspacePath, result.threadPath);
-      expect(finalThread?.fields.status).toBe('done');
-
-      const auditFact = store.read(
-        workspacePath,
-        `facts/lifecycle-audit-${result.workerName.replace('worker-', '')}.md`,
-      );
-      expect(auditFact?.fields.object).toContain('completed');
-    }
-
-    const auditReport = threadAudit.reconcileThreadState(workspacePath);
-    const criticalAuditIssues = auditReport.issues.filter((issue) =>
-      issue.kind === 'active_without_claim'
-      || issue.kind === 'active_owner_mismatch'
-      || issue.kind === 'claim_without_active_status'
-      || issue.kind === 'active_without_lease'
-      || issue.kind === 'stale_lease'
-    );
-    expect(criticalAuditIssues).toEqual([]);
-  });
-});
diff --git a/tests/stress/trigger-cascade.test.ts b/tests/stress/trigger-cascade.test.ts
deleted file mode 100644
index 914eb84..0000000
--- a/tests/stress/trigger-cascade.test.ts
+++ /dev/null
@@ -1,221 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  ledger as ledgerModule,
-  safety as safetyModule,
-  store as storeModule,
-  triggerEngine as triggerEngineModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-
-const ledger = ledgerModule;
-const safety = safetyModule;
-const store = storeModule;
-const triggerEngine = triggerEngineModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-stress-trigger-cascade-'));
-  workspace.initWorkspace(workspacePath, { createReadme: false });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('stress: trigger cascade, throttling, and breaker behavior', () => {
-  it('handles deep cascades and 100+ trigger fan-out while safety rails enforce limits', { timeout: 30_000 }, () => {
-    const cascadeLength = 50;
-    for (let idx = 1; idx <= cascadeLength; idx += 1) {
-      store.create(
-        workspacePath,
-        'fact',
-        {
-          title: `Cascade fact ${idx}`,
-          subject: 'cascade',
-          predicate: 'step',
-          object: 'pending',
-          tags: ['stress', 'cascade'],
-        },
-        '# Cascade Fact\n',
-        'system',
-        { pathOverride: `facts/cascade-${idx}.md` },
-      );
-    }
-
-    for (let idx = 0; idx < cascadeLength; idx += 1) {
-      const eventPattern = idx === 0
-        ? 'event.update:events/cascade-seed-0.md'
-        : `fact.update:facts/cascade-${idx}.md`;
-      store.create(
-        workspacePath,
-        'trigger',
-        {
-          title: `Cascade trigger ${idx}`,
-          status: 'active',
-          condition: { type: 'event', pattern: eventPattern },
-          action: {
-            type: 'update-primitive',
-            path: `facts/cascade-${idx + 1}.md`,
-            fields: { object: `fired-${idx}` },
-          },
-          cooldown: 0,
-          tags: ['stress', 'cascade'],
-        },
-        '# Trigger\n',
-        'system',
-        { pathOverride: `triggers/cascade-${idx}.md` },
-      );
-    }
-
-    triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-    ledger.append(
-      workspacePath,
-      'system',
-      'update',
-      'events/cascade-seed-0.md',
-      'event',
-      { event_type: 'cascade.seed' },
-    );
-
-    let totalCascadeFires = 0;
-    for (let cycle = 0; cycle < cascadeLength + 10; cycle += 1) {
-      const result = triggerEngine.runTriggerEngineCycle(workspacePath, { actor: 'system' });
-      totalCascadeFires += result.fired;
-      if (result.fired === 0) break;
-    }
-    expect(totalCascadeFires).toBe(cascadeLength);
-
-    for (let idx = 1; idx <= cascadeLength; idx += 1) {
-      const fact = store.read(workspacePath, `facts/cascade-${idx}.md`);
-      expect(fact?.fields.object).toBe(`fired-${idx - 1}`);
-    }
-
-    safety.updateSafetyConfig(workspacePath, 'safety-admin', {
-      rateLimit: { enabled: false },
-      circuitBreaker: {
-        enabled: true,
-        failureThreshold: 3,
-        cooldownSeconds: 30,
-        halfOpenMaxOperations: 1,
-      },
-    });
-    const breakerStart = new Date('2026-03-06T12:00:00.000Z');
-    for (let idx = 0; idx < 3; idx += 1) {
-      const now = new Date(breakerStart.getTime() + idx * 1000);
-      const decision = safety.evaluateSafety(workspacePath, {
-        actor: 'system-trigger',
-        operation: 'trigger.evaluate',
-        now,
-        consume: true,
-      });
-      expect(decision.allowed).toBe(true);
-      safety.recordOperationOutcome(workspacePath, {
-        actor: 'system-trigger',
-        operation: 'trigger.evaluate',
-        success: false,
-        error: `synthetic failure ${idx}`,
-        now,
-      });
-    }
-    const breakerBlocked = safety.evaluateSafety(workspacePath, {
-      actor: 'system-trigger',
-      operation: 'trigger.evaluate',
-      now: new Date(breakerStart.getTime() + 4_000),
-      consume: true,
-    });
-    expect(breakerBlocked.allowed).toBe(false);
-    expect(breakerBlocked.reasons.join(' ')).toContain('Circuit breaker open');
-
-    safety.resetSafetyRails(workspacePath, { actor: 'safety-admin', clearKillSwitch: true });
-    safety.updateSafetyConfig(workspacePath, 'safety-admin', {
-      rateLimit: {
-        enabled: true,
-        windowSeconds: 60,
-        maxOperations: 5,
-      },
-      circuitBreaker: { enabled: false },
-    });
-    const rateLimitNow = new Date('2026-03-06T12:10:00.000Z');
-    const decisions = Array.from({ length: 6 }, () =>
-      safety.evaluateSafety(workspacePath, {
-        actor: 'system-trigger',
-        operation: 'trigger.evaluate',
-        now: rateLimitNow,
-        consume: true,
-      }));
-    expect(decisions.slice(0, 5).every((entry) => entry.allowed)).toBe(true);
-    expect(decisions[5]?.allowed).toBe(false);
-    expect(decisions[5]?.reasons.join(' ')).toContain('Rate limit exceeded');
-
-    safety.resetSafetyRails(workspacePath, { actor: 'safety-admin', clearKillSwitch: true });
-    safety.updateSafetyConfig(workspacePath, 'safety-admin', {
-      rateLimit: {
-        enabled: false,
-      },
-      circuitBreaker: { enabled: false },
-    });
-
-    const bulkCount = 120;
-    const bulkTriggerPaths: string[] = [];
-    for (let idx = 0; idx < bulkCount; idx += 1) {
-      store.create(
-        workspacePath,
-        'fact',
-        {
-          title: `Bulk fact ${idx}`,
-          subject: 'bulk',
-          predicate: 'fanout',
-          object: 'pending',
-          tags: ['stress', 'bulk'],
-        },
-        '# Bulk Fact\n',
-        'system',
-        { pathOverride: `facts/bulk-${idx}.md` },
-      );
-      const trigger = store.create(
-        workspacePath,
-        'trigger',
-        {
-          title: `Bulk trigger ${idx}`,
-          status: 'active',
-          condition: { type: 'event', pattern: 'event.update:events/bulk-seed.md' },
-          action: {
-            type: 'update-primitive',
-            path: `facts/bulk-${idx}.md`,
-            fields: { object: `bulk-fired-${idx}` },
-          },
-          cooldown: 0,
-          tags: ['stress', 'bulk'],
-        },
-        '# Trigger\n',
-        'system',
-        { pathOverride: `triggers/bulk-${idx}.md` },
-      );
-      bulkTriggerPaths.push(trigger.path);
-    }
-
-    triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-      triggerPaths: bulkTriggerPaths,
-    });
-    ledger.append(
-      workspacePath,
-      'system',
-      'update',
-      'events/bulk-seed.md',
-      'event',
-      { event_type: 'bulk.seed' },
-    );
-    const bulkResult = triggerEngine.runTriggerEngineCycle(workspacePath, {
-      actor: 'system',
-      triggerPaths: bulkTriggerPaths,
-    });
-    expect(bulkResult.fired).toBe(bulkCount);
-    expect(bulkResult.errors).toBe(0);
-  });
-});
diff --git a/tests/stress/webhook-flood.test.ts b/tests/stress/webhook-flood.test.ts
deleted file mode 100644
index cc85812..0000000
--- a/tests/stress/webhook-flood.test.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  ledger as ledgerModule,
-  workspace as workspaceModule,
-} from '@versatly/workgraph-kernel';
-import {
-  listWebhookGatewayLogs,
-  registerWebhookGatewaySource,
-  startWorkgraphServer,
-} from '@versatly/workgraph-control-api';
-
-const ledger = ledgerModule;
-const workspace = workspaceModule;
-
-let workspacePath: string;
-
-beforeEach(() => {
-  workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), 'wg-stress-webhook-flood-'));
-  workspace.initWorkspace(workspacePath, {
-    createReadme: false,
-    createBases: false,
-  });
-});
-
-afterEach(() => {
-  fs.rmSync(workspacePath, { recursive: true, force: true });
-});
-
-describe('stress: webhook gateway flood', () => {
-  it('processes 500 mixed webhook requests without dropping events', { timeout: 30_000 }, async () => {
-    const sourceKey = 'github-flood';
-    const sharedSecret = 'flood-secret';
-    const totalRequests = 500;
-    const malformedEvery = 10;
-
-    registerWebhookGatewaySource(workspacePath, {
-      key: sourceKey,
-      provider: 'github',
-      secret: sharedSecret,
-      actor: 'github-flood-bot',
-    });
-
-    const server = await startWorkgraphServer({
-      workspacePath,
-      host: '127.0.0.1',
-      port: 0,
-    });
-
-    try {
-      const validCount = totalRequests - Math.floor(totalRequests / malformedEvery);
-      const responses: number[] = [];
-
-      const tasks = Array.from({ length: totalRequests }, (_value, idx) => async () => {
-        const malformed = idx % malformedEvery === 0;
-        const payload = JSON.stringify({
-          index: idx,
-          action: malformed ? 'broken' : 'opened',
-          pull_request: { number: idx },
-        });
-        const signature = signGithubPayload(
-          payload,
-          malformed ? `${sharedSecret}-invalid` : sharedSecret,
-        );
-        const response = await fetch(`${server.baseUrl}/webhook-gateway/${sourceKey}`, {
-          method: 'POST',
-          headers: {
-            'content-type': 'application/json',
-            'x-github-event': 'pull_request',
-            'x-github-delivery': `flood-${idx}`,
-            'x-hub-signature-256': signature,
-          },
-          body: payload,
-        });
-        responses.push(response.status);
-      });
-
-      await runBatched(tasks, 50);
-
-      const accepted = responses.filter((statusCode) => statusCode === 202).length;
-      const rejected = responses.filter((statusCode) => statusCode === 401).length;
-      expect(accepted).toBe(validCount);
-      expect(rejected).toBe(totalRequests - validCount);
-
-      const logs = listWebhookGatewayLogs(workspacePath, { limit: 1_000, sourceKey });
-      expect(logs.length).toBe(totalRequests);
-      expect(logs.filter((entry) => entry.status === 'accepted').length).toBe(validCount);
-      expect(logs.filter((entry) => entry.status === 'rejected').length).toBe(totalRequests - validCount);
-      expect(logs.filter((entry) => entry.signatureVerified).length).toBe(validCount);
-
-      const eventEntries = ledger.query(workspacePath, {
-        type: 'event',
-        targetIncludes: `.workgraph/webhook-gateway/${sourceKey}/`,
-      });
-      expect(eventEntries.length).toBe(validCount);
-
-      const uniqueDeliveries = new Set(
-        eventEntries.map((entry) => String(entry.data?.delivery_id ?? '')),
-      );
-      expect(uniqueDeliveries.size).toBe(validCount);
-    } finally {
-      await server.close();
-    }
-  });
-});
-
-function signGithubPayload(rawBody: string, secret: string): string {
-  const digest = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
-  return `sha256=${digest}`;
-}
-
-async function runBatched(tasks: Array<() => Promise<void>>, batchSize: number): Promise<void> {
-  for (let idx = 0; idx < tasks.length; idx += batchSize) {
-    const batch = tasks.slice(idx, idx + batchSize).map((task) => task());
-    await Promise.all(batch);
-  }
-}
diff --git a/tsconfig.json b/tsconfig.json
index f356df2..03ba054 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -9,5 +9,40 @@
     "tests/**/*",
     "vitest.config.ts"
   ],
-  "exclude": ["node_modules", "dist"]
+  "exclude": [
+    "node_modules",
+    "dist",
+    "packages/kernel/src/autonomy*.ts",
+    "packages/kernel/src/board*.ts",
+    "packages/kernel/src/capability*.ts",
+    "packages/kernel/src/clawdapus*.ts",
+    "packages/kernel/src/cron*.ts",
+    "packages/kernel/src/cursor-bridge*.ts",
+    "packages/kernel/src/dispatch*.ts",
+    "packages/kernel/src/diagnostics*.ts",
+    "packages/kernel/src/diagnostics/**/*",
+    "packages/kernel/src/federation*.ts",
+    "packages/kernel/src/gate.test.ts",
+    "packages/kernel/src/integration*.ts",
+    "packages/kernel/src/mission*.ts",
+    "packages/kernel/src/onboard*.ts",
+    "packages/kernel/src/projections/**/*",
+    "packages/kernel/src/reconciler*.ts",
+    "packages/kernel/src/runtime-adapter-*.ts",
+    "packages/kernel/src/search-qmd-adapter*.ts",
+    "packages/kernel/src/swarm*.ts",
+    "packages/kernel/src/transport/**/*",
+    "packages/kernel/src/trigger*.ts",
+    "packages/kernel/src/agent-self-assembly*.ts",
+    "tests/integration/cli-compat.test.ts",
+    "tests/integration/multi-agent-showcase.test.ts",
+    "tests/integration/portability-cli.test.ts",
+    "tests/integration/remote-cli.test.ts",
+    "tests/integration/trigger-cli.test.ts",
+    "tests/stress/capability-matching.test.ts",
+    "tests/stress/federation-scale.test.ts",
+    "tests/stress/full-lifecycle.test.ts",
+    "tests/stress/trigger-cascade.test.ts",
+    "tests/stress/webhook-flood.test.ts"
+  ]
 }
diff --git a/tsup.config.ts b/tsup.config.ts
index e565924..cf24d5d 100644
--- a/tsup.config.ts
+++ b/tsup.config.ts
@@ -6,8 +6,6 @@ export default defineConfig({
     cli: 'packages/cli/src/cli.ts',
     'mcp-server': 'packages/mcp-server/src/mcp-server.ts',
     'mcp-http-server': 'packages/mcp-server/src/mcp-http-server.ts',
-    server: 'packages/control-api/src/server.ts',
-    'server-entry': 'packages/control-api/src/server-entry.ts',
   },
   format: ['esm'],
   clean: true,
@@ -16,15 +14,6 @@ export default defineConfig({
     '@versatly/workgraph-kernel',
     '@versatly/workgraph-cli',
     '@versatly/workgraph-mcp-server',
-    '@versatly/workgraph-control-api',
-    '@versatly/workgraph-adapter-claude-code',
-    '@versatly/workgraph-adapter-cursor-cloud',
-    '@versatly/workgraph-adapter-http-webhook',
-    '@versatly/workgraph-adapter-shell-worker',
-    '@versatly/workgraph-obsidian-integration',
-    '@versatly/workgraph-runtime-adapter-core',
-    '@versatly/workgraph-search-qmd-adapter',
-    '@versatly/workgraph-skills',
     '@versatly/workgraph-sdk',
   ],
 });
diff --git a/vitest.config.ts b/vitest.config.ts
index 029f3bc..628529c 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -7,5 +7,27 @@ export default defineConfig({
       'packages/*/tests/**/*.{test,spec}.ts',
       'tests/**/*.{test,spec}.ts',
     ],
+    exclude: [
+      'packages/kernel/src/agent-self-assembly.test.ts',
+      'packages/kernel/src/dispatch*.test.ts',
+      'packages/kernel/src/diagnostics.test.ts',
+      'packages/kernel/src/gate.test.ts',
+      'packages/kernel/src/mission-orchestrator.test.ts',
+      'packages/kernel/src/projections/**/*.test.ts',
+      'packages/kernel/src/reconciler.test.ts',
+      'packages/kernel/src/schema-drift-regression.test.ts',
+      'packages/kernel/src/trigger*.test.ts',
+      'packages/kernel/src/workspace-structure.test.ts',
+      'tests/integration/cli-compat.test.ts',
+      'tests/integration/multi-agent-showcase.test.ts',
+      'tests/integration/portability-cli.test.ts',
+      'tests/integration/remote-cli.test.ts',
+      'tests/integration/trigger-cli.test.ts',
+      'tests/stress/capability-matching.test.ts',
+      'tests/stress/federation-scale.test.ts',
+      'tests/stress/full-lifecycle.test.ts',
+      'tests/stress/trigger-cascade.test.ts',
+      'tests/stress/webhook-flood.test.ts',
+    ],
   },
 });