diff --git a/README.md b/README.md
index 138324a..54c59b2 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ ak setup --opencode # …and wire ruflo + ruvnet-brain into opencode (third host
 **What you get:**
 
 - **One command** installs + heals + *proves* ruflo & agentic-qe — native SQLite, memory, security, statusline (past npm's `allow-scripts` gate).
-- **Dual-host (optional):** Claude *and* Codex at once, per-activity model routing, **$0 on your subscriptions** — `ak setup --codex`.
+- **Multi-host execution (optional):** Claude, Codex, and opt-in OpenCode can share one activity policy; `ak run` is the canonical executor, while `ak setup --codex` enables the subscription-backed Claude/Codex defaults.
 - **Self-healing:** `ak sync` re-converges after every upgrade; `ak status` and a local dashboard show what's *actually* on — never assumed.
 - **Honest by construction:** every guard traces to a filed upstream issue, and `ak x verify` proves the paths end-to-end against real CLIs.
 - Cross-platform, **zero runtime dependencies** (SQLite embedded).
@@ -36,9 +36,9 @@ or catalogue evidence. A **binding** connects a host to a provider through a sup
 and transport.
 
 Those axes do not imply one another. OpenRouter is a provider behind a host, not another host.
-Ollama can have independent bindings through Claude and Codex. OpenCode is a managed host but is
-not currently a primary or activity-routing target. Existing `providers.dualRouting` and
-`ak dual` remain Claude+Codex host-routing interfaces. Provider, model, and billing claims state
+Ollama can have independent bindings through Claude and Codex. OpenCode is an opt-in, explicitly
+routable host through `ak run`, but it is never a primary host or AQE provider. Existing
+`ak dual` is a deprecated Claude+Codex compatibility interface. Provider, model, and billing claims state
 whether they are observed, configured, inferred, or unknown. See
 [ADR-0016](docs/adr/0016-capability-driven-integration-adapters.md).
 
@@ -69,7 +69,9 @@ ak dashboard    open the local web dashboard (auto-opens your browser)
                 [--port N] [--no-open] [--live-source 'surface=path']
 ak host         manage execution hosts, routing, and provider bindings
                 status | pick | refresh | off
-ak dual         run a Claude+Codex collaboration swarm (dual-host)   run <template> "<task>"  [--dry-run] [--escalate] [--route ...]
+ak run          execute a host-neutral activity pipeline (including explicit OpenCode routes)
+                <template> "<task>"  [--dry-run] [--route ...] [--max-concurrent N] [--timeout ms]
+ak dual         deprecated Claude+Codex compatibility wrapper; use ak run for new work
 ak x statusline manage Codex's native user-wide status line          status | codex native|extended|off
 ak uninstall    leave cleanly                [--dry-run] [--this-project] [--remove-ruflo] [--remove-aqe] [--purge] [--yes]
 ```
@@ -87,11 +89,12 @@ What the verbs cover:
 | Verb | What it does |
 | ------ | -------------- |
 | **setup** | Installs/updates ruflo + agentic-qe + the **agentdb** CLI globally (handling npm ≥11.17's `allow-scripts` so natives build; agentdb is pinned to ruflo's bundled version so the shared learning store stays coherent), installs the **RuvNet Brain** (an offline knowledge base over the rUv stack, powering the `search_ruvnet` MCP — a ~2 GB one-time download, prompted; skip with `--no-ruvnet-brain`), deploys the token-audit skill, merges the managed guidance blocks into the machine-wide guidance files (`~/.claude/CLAUDE.md`, plus `~/.codex/AGENTS.md` on codex machines), offers one-time MCP registration (user scope, with a tool-family picker), and — inside a repo — initializes the project: sanitized `ruflo init`, absolute memory-path pin, a **verified** store→disk write, statusline footer, and a background daemon with **local-only ($0) workers** (token-spending AI workers stay opt-in behind upstream's machine-wide budget). Project scope triggers on a `.git` directory in the current folder; without one it's skipped with a note. `--project` forces it anyway (e.g. a not-yet-`git init`-ed folder), `--minimal` skips it, `--yes` accepts all prompts (non-interactive), `--no-aqe` / `--no-ruvnet-brain` / `--no-security` disable those subsystems, and `--reconfigure` re-offers MCP registration. `--codex` enables + installs the Codex host during setup (dual-mode; both hosts then run at once), and `--primary-host claude\|codex` picks which host leads (codex implies `--codex`). |
-| **status** | Per-subsystem ✓/⚠/✗ (versions, the kit's own version, **ruvnet-brain** (present + release drift, or "not installed"), natives (agentdb copies **and** ruflo's own memory runtime — the one `npx ruflo memory` loads — load-tested for a native better-sqlite3, not just the agentdb dirs), **memory-pin** (warns when `CLAUDE_FLOW_DB_PATH` points off the live DB), security, learning, aqe/RVF, **agentdb** (CLI present + coherent with ruflo's bundled version, or a store-skew warning), MCP, **hosts** (claude/codex — version + install method + **auth mode** (subscription $0 vs metered api-key), with the **primary** host marked and a *fail* when the primary host is absent), **providers** (host wiring + aqe fallback chain, or "drifted"/claude-only default), **routing** (per-activity Claude/Codex host+model policy, when dual-host — with drift vs the on-disk `agentOverrides`), daemons, guidance-file blocks (`~/.claude/CLAUDE.md`, project `AGENTS.md`, and `~/.codex/AGENTS.md` on codex machines), statusline), each drift row naming what `sync` would do about it — plus a **health-history** line that flags regressions since the last sync (learning shrank, native slots dropped, drift/security backslid). |
-| **sync** | The one convergence verb: upgrades first when a new release exists, then re-heals everything an upgrade wipes, then re-checks and reports. Included in that heal: it **installs any enabled frontier host** (claude/codex) that's entirely absent — never touching an external (mise/brew/native) install — and **re-applies provider wiring** (the `ENABLE_*` host env, the aqe fallback chain, and ruflo API providers) whenever it has drifted — and, on a dual-host project, **seeds/heals the per-activity routing policy** (materializing it into agentic-qe's `agentOverrides`, e.g. after an aqe upgrade first makes it eligible). It also **installs/repins the standalone `agentdb` CLI** to ruflo's bundled version (keeping the shared cognitive store coherent) and appends a **health-history snapshot** so `status` can flag regressions across syncs. It also **re-runs the RuvNet Brain installer** to pull the latest release when the on-disk KB has drifted (or installs it if absent, when enabled). It also **self-updates the kit**: when a newer `@pacphi/agentic-kit` exists it installs it as the *last* step (the new code applies from the next `ak` run, never mid-sync). Prerelease installs (`4.0.0-alpha.*`) track the `next` npm dist-tag as well as `latest`, so alphas see their successors; stable installs only ever follow `latest`. `--no-upgrade` skips the self-update along with the package upgrades. |
+| **status** | Per-subsystem ✓/⚠/✗ (versions, the kit's own version, **ruvnet-brain** (present + release drift, or "not installed"), natives (agentdb copies **and** ruflo's own memory runtime — the one `npx ruflo memory` loads — load-tested for a native better-sqlite3, not just the agentdb dirs), **memory-pin** (warns when `CLAUDE_FLOW_DB_PATH` points off the live DB), security, learning, aqe/RVF, **agentdb** (CLI present + coherent with ruflo's bundled version, or a store-skew warning), MCP, **hosts** (claude/codex/opencode version + install method; the Claude/Codex **primary** marked and failed when absent), **providers** (host wiring + aqe fallback chain, or "drifted"/claude-only default), **routing** (the persisted activity host+model policy; only Claude/Codex routes project into AQE), daemons, guidance-file blocks (`~/.claude/CLAUDE.md`, project `AGENTS.md`, and `~/.codex/AGENTS.md` on codex machines), statusline), each drift row naming what `sync` would do about it — plus a **health-history** line that flags regressions since the last sync (learning shrank, native slots dropped, drift/security backslid). |
+| **sync** | The one convergence verb: upgrades first when a new release exists, then re-heals everything an upgrade wipes, then re-checks and reports. Included in that heal: it **installs any enabled frontier host** (claude/codex/opencode) that's entirely absent — never touching an external (mise/brew/native) install — and **re-applies provider wiring** (the `ENABLE_*` host env, OpenCode's native configuration, the aqe fallback chain, and ruflo API providers) whenever it has drifted — and, on a dual-host project, **seeds/heals the Claude/Codex default routing policy** (materializing eligible routes into agentic-qe's `agentOverrides`, e.g. after an aqe upgrade first makes it eligible). It also **installs/repins the standalone `agentdb` CLI** to ruflo's bundled version (keeping the shared cognitive store coherent) and appends a **health-history snapshot** so `status` can flag regressions across syncs. It also **re-runs the RuvNet Brain installer** to pull the latest release when the on-disk KB has drifted (or installs it if absent, when enabled). It also **self-updates the kit**: when a newer `@pacphi/agentic-kit` exists it installs it as the *last* step (the new code applies from the next `ak` run, never mid-sync). Prerelease installs (`4.0.0-alpha.*`) track the `next` npm dist-tag as well as `latest`, so alphas see their successors; stable installs only ever follow `latest`. `--no-upgrade` skips the self-update along with the package upgrades. |
 | **dashboard** | Opens a read-only local web dashboard (`127.0.0.1:7431`, localhost-only, never detaches) with seven tabs: **Overview · Hosts & Routing · Providers · Runtime · Intelligence · Usage · Live**. The first five render `ak status` health and routing; Usage indexes local Claude/Codex transcripts on demand. Live groups work by project, then host-branded root sessions with nested agent/worker threads and independently evidenced provider/model metadata, and pairs an interactive agent/tool execution canvas with a rich, server-masked transcript stream. Active sessions can be followed live or reviewed with synchronized play/pause/seek; completed sessions remain available for bounded playback. Live contains no chat or control plane. Ruflo, agentic-qe, and dual-run stores are not auto-discovered; register each trusted structured JSONL file with repeatable `--live-source 'surface=path'` (`surface` is `ruflo`, `aqe`, or `dual-run`). The page is self-contained and offline-first (no internet fetches; local files and loopback subprocesses/endpoints only). A fresh **per-session token** is minted at startup and required by every `/api/*` route (`x-dash-token` header; the launch URL carries it in the `#` fragment, same contract as `ak admin` — ADR-0007, ADR-0014) — this page serves full transcript text, so it is gated the same way admin already gated GitHub/npm stats. See [Live Sessions](docs/LIVE-SESSIONS.md) for coverage, syntax, and privacy limits. **Auto-opens your browser** (`--no-open` for headless/SSH); `--port N` changes the port; tabs deep-link (`#live`) and persist. Stop with Ctrl-C. (Also available as `ak x dashboard`.) |
 | **admin** | Opens the **maintainer admin** (`127.0.0.1:7432`, localhost-only, foreground) — the project-telemetry sibling of `dashboard`, with the same dark/light visual theme and persisted theme preference: unique repo visitors and cloners (GitHub traffic API, needs a push-access token via `GITHUB_TOKEN`/`GH_TOKEN`/`gh auth token` — panels degrade honestly without one), contributors and watchers, npm download momentum (last 7d vs prior 7d, sparklines — shown as trend only, never an absolute reach number, since mirrors/CI inflate the raw count), latest CI run status and open Dependabot alerts, a **"since you last looked"** delta strip over a local baseline, open issues/PRs from others (oldest first), and external humans ranked by recency (bots excluded). Access is gated by a **per-session token** carried in the URL fragment and sent header-only; the page makes **zero external fetches** (the server proxies GitHub/npm; your credential never reaches the page or the payload — ADR-0007, ADR-0013). Where `dashboard` is offline-first, `admin` does deliberate GitHub/npm egress — that contract split is why they're siblings, not tabs. `--port N`, `--no-open`; Ctrl-C stops. (Also available as `ak x admin`.) |
-| **dual** | Runs a **Claude + Codex collaboration swarm** using your per-activity routing policy: `ak dual run <template> "<task>"` materializes a dual-run config (each pipeline step assigned to the host + model your policy chose) and drives it via `claude-flow-codex`. Templates: `feature`, `security`, `refactor`, `packaging`, `release`. `--dry-run` prints the plan + config without running; `--route 'activity:host[:model]'` overrides one step for that run; `--escalate` retries once up the cross-vendor ladder on failure. Requires dual-host enabled (`ak setup --codex`, or `ak host pick --host claude,codex`). **Pre-flight refusal:** before spawning a worker, `dual run` refuses to start when ruflo's memory runtime lacks a native better-sqlite3 binding **and** the shared DB has an active native WAL (`-wal`/`-shm` sidecars) — the native WAL writer and the WASM `ruflo memory store` cannot share that DB without corrupting it; the fix is `ak sync` (builds the native binding), then retry. |
+| **run** | **Canonical execution surface.** Executes the template vocabulary through host-neutral supervised adapters. It accepts an explicit OpenCode route (persisted or `--route`) alongside Claude/Codex; `--dry-run` prints the exact plan. An OpenCode worker runs an isolated loopback server with ephemeral basic authentication, returns only normalized observed facts, and aborts instead of approving a permission request. `ak run` does not turn OpenCode into an AQE provider or primary host. |
+| **dual** | **Deprecated compatibility wrapper** for existing Claude+Codex `claude-flow-codex` scripts, including its legacy escalation behavior. New execution work should use `ak run`; `ak dual` warns on stderr and will be removed before the stable release. |
 | **host** | Canonical alpha namespace for execution-host status, selection, primary-host choice, activity routing, and reversible teardown: `ak host status\|pick\|refresh\|off`. The plumbing spelling is `ak x host`. `ak provider` and `ak x provider` are deprecated compatibility aliases that warn on stderr and will be removed before the stable release. |
 | **uninstall** | Removes the kit's footprint (and any legacy shell-kit install); project data is never touched; `--purge` also offers to remove the global packages. |
 
@@ -162,8 +165,15 @@ you opt in. Two independent axes:
   dashboard matrix, and **tunable per activity** (`ak host pick --route 'testing:claude:claude-sonnet-5'`)
   with your edits preserved across syncs. **`--primary-host claude|codex`** chooses which host leads:
   codex-primary *mirrors* the default table so Codex drives and Claude is the alternate — symmetric
-  either way. `ak dual run <template> "<task>"` then drives a Claude+Codex collaboration swarm off that
-  policy. Nothing is seeded for claude-only projects.
+  either way. `ak run <template> "<task>"` executes a materialized plan from that policy. Nothing is
+  seeded for claude-only projects.
+
+  **OpenCode is explicit, not seeded.** Enable it with `ak host pick --host claude,opencode`,
+  then route a compatible activity through `ak run`, for example
+  `ak run security "src/auth/" --route 'security-scan:opencode:provider/model'`.
+  OpenCode routes are not projected to AQE, do not affect vendor-diversity claims, cannot be a
+  primary host, and the deprecated `ak dual` rejects them rather than silently changing its two-host
+  compatibility contract.
 
 `ak host status` shows what's detected, wired, and routed; `ak host pick` chooses and
 applies (reversibly); `ak host off` restores the claude-only default. Full guide:
@@ -198,6 +208,14 @@ in `kit.json`) converges, on every `ak sync`:
 
 Everything is ownership-recorded (`providers.opencodeMcp`) and stripped surgically by
 `ak host off` / `ak uninstall` — your own opencode.json entries are never touched.
+
+**Execution routing.** `ak run` is the host-neutral runner for explicit OpenCode routes. For
+each worker it starts an owned `opencode serve` instance on loopback with an ephemeral basic-auth
+password, creates an isolated session, and returns normalized terminal evidence. A timeout or
+cancellation aborts the session before the owned server is terminated. A permission request is
+reported as blocked and aborted — `ak` never supplies `--auto` or changes your OpenCode permission
+policy. The configured `provider/model` selector is not provider or billing evidence; those facts
+remain unknown unless OpenCode reports them in the terminal session data.
 Design record: [docs/adr/0017-opencode-host.md](docs/adr/0017-opencode-host.md).
 
 ## Troubleshooting
diff --git a/bin/agentic-kit.mjs b/bin/agentic-kit.mjs
index 4ff068f..9e0e6c6 100755
--- a/bin/agentic-kit.mjs
+++ b/bin/agentic-kit.mjs
@@ -51,7 +51,7 @@ Usage (ak = alias of agentic-kit):
   ak dashboard       open the local web dashboard (localhost; auto-opens browser)  [--port N] [--no-open]
   ak admin           maintainer-only telemetry admin (localhost; GitHub/npm egress)  [--port N] [--no-open]
   ak run             execute a host-neutral activity pipeline  [template "task"] [--dry-run]
-  ak dual            run a Claude+Codex collaboration swarm (dual-host)  [run <template> "task"] [--dry-run]
+  ak dual            deprecated compatibility wrapper; use ak run for new work
   ak host            manage agent hosts, routing, and provider bindings  [status|pick|refresh|off]
   ak provider        deprecated alias for ak host; removed before the stable release
   ak uninstall       leave cleanly                                      [--this-project] [--purge]
@@ -89,6 +89,7 @@ async function main() {
   let cmd = argv[0];
   let rest = argv.slice(1);
   let deprecatedProvider = cmd === 'provider';
+  const deprecatedDual = cmd === 'dual';
 
   if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
     console.log(argv.includes('--all') ? HELP_ALL : HELP);
@@ -135,6 +136,9 @@ async function main() {
     const canonical = argv[0] === 'x' ? 'ak x host' : 'ak host';
     console.error(`${legacy} is deprecated; use \`${canonical}\`. It will be removed before the stable release.`);
   }
+  if (deprecatedDual) {
+    console.error('ak dual is deprecated; use `ak run` for new execution work. It will be removed before the stable release.');
+  }
   const mod = await table[cmd]();
 
   // Per-command help — intercepted BEFORE run() so mutating commands
diff --git a/claude/dual-mode-reference.md b/claude/dual-mode-reference.md
index 943a162..689c53a 100644
--- a/claude/dual-mode-reference.md
+++ b/claude/dual-mode-reference.md
@@ -14,18 +14,17 @@ and quality gates are available whichever agent is in the driver's seat, and eac
 reach the other. Work flows complementarily — Claude and Codex are peers, not primary and
 fallback.
 
-### `ak dual run` — Claude+Codex collaboration pipelines
+### `ak run` — canonical activity pipelines
 
-`ak dual run <template> "<task>"` materializes a multi-worker pipeline from your
-per-activity routing policy (set via `ak host`) and runs it through the
-`claude-flow-codex` adapter. Each worker is assigned a host + model by the policy, so a
-single run can span both vendors.
+`ak run <template> "<task>"` materializes a multi-worker pipeline from your per-activity routing
+policy (set via `ak host`) and runs it through supervised host adapters. Each worker is assigned a
+host + model by the policy, so a single run can span Claude, Codex, and an explicitly routed
+OpenCode worker.
 
 ```bash
-ak dual run feature  "add token-bucket rate limiting"
-ak dual run security "src/auth/" --escalate
-ak dual run refactor "extract the payment module" --dry-run
-ak dual templates                     # list the pipelines
+ak run feature  "add token-bucket rate limiting"
+ak run security "src/auth/" --route 'security-scan:opencode:provider/model'
+ak run refactor "extract the payment module" --dry-run
 ```
 
 - **Templates** — `feature` (architect → coder → tester → reviewer), `security`
@@ -33,9 +32,11 @@ ak dual templates                     # list the pipelines
   `packaging` (packager → reviewer), `release` (preparer → reviewer). Each step's
   host/model comes from your routing policy, not the template.
 - **`--route 'act:host[:model]'`** — per-run routing override (repeatable, not persisted).
-- **`--parallel`** — run independent workers concurrently instead of sequentially.
-- **`--escalate`** — on failure, retry once **up the escalation ladder** (see below).
-- **`--dry-run` / `--json`** — print the materialized config + command, spawn nothing.
+- **`--max-concurrent <n>` / `--timeout <ms>`** — bound parallel work and each worker.
+- **`--dry-run` / `--json`** — print the materialized plan, spawn nothing.
+
+`ak dual` is a deprecated Claude/Codex `claude-flow-codex` compatibility wrapper. It retains its
+own `--parallel` and `--escalate` behavior for existing scripts, but new work must use `ak run`.
 
 ### The Claude ↔ Codex bridge (bidirectional MCP)
 
diff --git a/claude/providers-reference.md b/claude/providers-reference.md
index 20fe0c2..3243d7e 100644
--- a/claude/providers-reference.md
+++ b/claude/providers-reference.md
@@ -72,7 +72,8 @@ is unchanged until you opt in.
 When **both** hosts are enabled, `ak` also seeds a **per-activity routing policy** and wires a
 **two-way Claude↔Codex MCP bridge** (Claude reaches Codex via `mcp__codex__codex`; Codex reaches
 ruflo via `[mcp_servers.ruflo]`). `--primary-host claude|codex` chooses which host leads. See the
-dual-mode reference block and `docs/PROVIDERS.md` §3.5 for the routing table and `ak dual run`.
+dual-mode reference block and `docs/PROVIDERS.md` §3.5 for the routing table and canonical `ak run`
+execution.
 
 ### Install & update (install-method-aware)
 
diff --git a/docs/MANAGED-TOOLS.md b/docs/MANAGED-TOOLS.md
index ebaddb4..e5f5e9c 100644
--- a/docs/MANAGED-TOOLS.md
+++ b/docs/MANAGED-TOOLS.md
@@ -52,7 +52,7 @@ them.
 | --- | --- | --- | --- | --- | --- |
 | **ruflo** | npm `ruflo@latest` | `ak sync` | disk: global `package.json` | npm `view latest` (TTL-cached) | row ✓ / upstream's own `RuFlo V<x>` header ✓ / card + banner ✓ |
 | **agentic-qe** | npm `agentic-qe@latest` | `ak sync` | disk: global `package.json` (project-local fallback) | npm `view latest` (TTL-cached) | row ✓ / `Agentic QE V<x>` chip ✓ / card + banner ✓ |
-| **hosts** (Claude, Codex, OpenCode; routing remains Claude/Codex-only) | npm `@latest` — only when npm-managed | `ak sync` if npm-installed; **explicitly disowned** if brew/mise/native | disk: global `package.json`, else `--version` probe | npm latest for npm-managed only; external → `outdated:false` | row ✓ (version + method) / n/a / card + banner (npm-managed only) ✓ |
+| **hosts** (Claude, Codex, OpenCode; OpenCode routes explicitly through `ak run`) | npm `@latest` — only when npm-managed | `ak sync` if npm-installed; **explicitly disowned** if brew/mise/native | disk: global `package.json`, else `--version` probe | npm latest for npm-managed only; external → `outdated:false` | row ✓ (version + method) / n/a / card + banner (npm-managed only) ✓ |
 | **agentdb** | npm, **pinned to ruflo's bundled version** — deliberately not latest | `ak sync` (repins on core skew) | disk: global `package.json` | ruflo's **bundled** copy (coherence), not npm latest — by design | row ✓ / n/a / card ✓; banner excluded (its authority isn't "latest") |
 | **ruvnet-brain** | npm `ruvnet-brain@latest` + `--version v<tag>` pin (never `github:` HEAD) | `ak sync`; the installer's own nightly self-updater is suppressed at install (`--no-nightly-prompt`) and disabled by sync if found (`ruvnet-brain-nightly` subsystem) | disk: KB `SOURCE.json → releaseTag`, falling back to ak's kit.json stamp for pre-stamping bundles | GitHub `releases/latest` tag (TTL-cached) | row ✓ / `V<tag>` chip ✓ / card + banner ✓ |
 | **kit (self)** | npm, **pinned to the exact version drift saw** (`@pacphi/agentic-kit@<v>`) | `ak sync` (runs last — npm replaces the running code) | disk: running copy's `package.json` | npm `latest` (+ `next` for prereleases, TTL-cached) | row ✓ / n/a / header version + card + banner ✓ |
diff --git a/docs/PROVIDERS.md b/docs/PROVIDERS.md
index 0a107e3..809da61 100644
--- a/docs/PROVIDERS.md
+++ b/docs/PROVIDERS.md
@@ -23,8 +23,9 @@ The full model has four separate axes:
 
 A **binding** connects a host to a provider through a projection and transport. One Ollama
 provider can therefore have independent `ollama-via-claude` and `ollama-via-codex` bindings.
-OpenRouter is a provider behind a host, never automatically a third host. OpenCode may support
-managed lifecycle surfaces while remaining ineligible as a primary or per-activity routing host.
+OpenRouter is a provider behind a host, never automatically a third host. OpenCode is an opt-in
+activity-routing host through `ak run`, while remaining ineligible as a primary host or AQE
+provider. Its configured selector does not establish provider, billing, or vendor-diversity facts.
 This Proposed capability model is
 [ADR-0016](adr/0016-capability-driven-integration-adapters.md); current controls below remain
 backward compatible while its implementation proceeds.
@@ -169,7 +170,7 @@ tool-use, long-horizon agent work) and `z-ai/glm-5` (value — 205K context, che
 the 5.x line). Both are **metered** — GLM is never an auto-seed target (seeding only ever
 routes to subscription/local providers).
 
-## Level 3.5 — per-activity routing across Claude + Codex
+## Level 3.5 — seeded Claude + Codex defaults, explicit OpenCode routes
 
 When **both** hosts are enabled and `agentic-qe ≥ 3.13.1` is installed, `ak` seeds a
 **per-activity routing policy**: each kind of work (architecture, implementation, testing,
@@ -191,6 +192,22 @@ and claude becomes the alternate/escalation target — so the experience is ambi
 regardless of which CLI drives. `ak status` marks the primary and fails (not warns) if the
 primary host is missing.
 
+**OpenCode is explicit, not seeded or AQE-projected.** Enable it, then use `ak run` with either
+a persisted route or a run-local override:
+
+```bash
+ak host pick --host claude,opencode \
+  --route 'security-scan:opencode:provider/model'  # persisted intent
+ak run security "src/auth/"                         # canonical execution command
+ak run security "src/auth/" --route 'security-scan:opencode:provider/model'  # run-local
+```
+
+Each OpenCode worker is an isolated, loopback-only supervised server session. A permission request
+is aborted and reported as `permission_required`; `ak` never auto-approves it. OpenCode routes are
+not written to AQE `agentOverrides`, cannot become `primaryHost`, and do not count as a separate
+AQE vendor. `ak dual` is deprecated and rejects OpenCode routes because it retains a Claude/Codex
+compatibility adapter; use `ak run` instead.
+
 Defaults (all overridable; your edits are marked `custom` and never re-seeded):
 
 | Activity | Host | Default model |
@@ -244,8 +261,9 @@ converges those bridges again.
 
 `dualRouting` intentionally names a host and model, not an inference provider. Provider resolution
 is a separate binding lookup; absent grounded evidence remains unknown or explicitly inferred.
-Likewise, `ak dual run` continues to mean the Claude+Codex collaboration substrate. Multiple
-providers behind those hosts do not turn it into three-host-or-more orchestration.
+`ak run` is the canonical host-neutral executor. The deprecated `ak dual run` remains a
+Claude+Codex compatibility wrapper only; multiple providers behind those hosts do not turn its
+legacy adapter into three-host-or-more orchestration.
 
 ## Level 4 — drop down to raw ruflo / agentic-qe
 
diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.md
index 650e3d0..ccd70c6 100644
--- a/docs/TROUBLESHOOTING.md
+++ b/docs/TROUBLESHOOTING.md
@@ -33,7 +33,7 @@ ak sync             # apply it
 | opencode: `status` says `no ruflo catalog source` | the agent/skill catalog resolves override → `$RUFLO_REPO` → claude marketplace clone → `@claude-flow/cli` (direct, then nested under ruflo) — all missing | install ruflo (`ak setup` does), or point `providers.opencodeCatalogDir` / `$RUFLO_REPO` at a ruflo checkout |
 | `ruflo memory store` says OK but reads return nothing | Absolute-DB-path pin missing, or WAL not checkpointed, or the WASM fallback above | `ak setup` in the project re-pins + verifies a real write lands on disk |
 | `status` shows a `memory-pin` warning | `CLAUDE_FLOW_DB_PATH` is pinned to a dead or foreign path, so every memory op targets the wrong DB ("Database not initialized" beside a healthy in-repo DB). The pin may be deliberate, so `sync` never touches it | repoint (or remove) the pin in `.claude/settings.local.json` `env` |
-| `ak dual run` refuses to start ("ruflo's memory runtime lacks a native better-sqlite3 binding AND … active native WAL") | Pre-flight guard: the orchestrator's native WAL writer and the WASM `ruflo memory store` would share one DB and corrupt it. It refuses **before** spawning a worker rather than crashing mid-run | `ak sync` builds the native binding for ruflo's memory runtime, then retry the `dual run` |
+| Deprecated `ak dual run` refuses to start ("ruflo's memory runtime lacks a native better-sqlite3 binding AND … active native WAL") | Pre-flight guard: the legacy orchestrator's native WAL writer and the WASM `ruflo memory store` would share one DB and corrupt it. It refuses **before** spawning a worker rather than crashing mid-run | Prefer `ak run` for new work. If an existing dual-run workflow must continue, `ak sync` builds the native binding, then retry it. |
 | `ak provider` or `ak x provider` prints a deprecation warning | Alpha namespace correction: execution-host lifecycle and selection now belong to `host`; inference providers and bindings remain separate concepts | Use `ak host` (or `ak x host` for plumbing). The provider aliases will be removed before stable |
 | Suspicious token burn | Background automation vs interactive usage | ask Claude to run the **ruflo-token-audit** skill (deployed by `setup`) |
 | Live dashboard is empty or has no ruflo/AQE nodes | Live tails new Claude/Codex records by default; existing files start at EOF, while ruflo/AQE stores are not auto-discovered | open Live before producing activity; register a trusted JSONL file with repeatable `--live-source 'surface=path'`; see [Live Sessions](LIVE-SESSIONS.md) |
diff --git a/docs/USAGE-SCORECARD-METRICS.md b/docs/USAGE-SCORECARD-METRICS.md
index 99f0210..eac670b 100644
--- a/docs/USAGE-SCORECARD-METRICS.md
+++ b/docs/USAGE-SCORECARD-METRICS.md
@@ -477,8 +477,8 @@ of exactly that kind, both in `parseCodex`.
 **What this does not model:** the by-host cards do not yet carry a separate
 inference-provider dimension. The legacy session record has exactly one `provider`
 field, currently used as host/parser identity. A
-workflow that hands off between Claude and Codex mid-task (e.g. `ak dual
-run`) produces two separate session records, one per host, each correctly
+workflow that hands off between Claude and Codex mid-task (e.g. `ak run`) produces two separate
+session records, one per host, each correctly
 aggregated under the current transcript-host schedule rather than one blended record. That
 API-equivalent estimate is not proof of the provider that actually served either execution.
 
@@ -990,7 +990,7 @@ describes.
   by synthetic regression tests, but has not yet been validated against a
   genuine `thread_source: "subagent"` file on real hardware.** Any
   maintainer whose machine accumulates such a file (most likely from heavy
-  `ak dual run` / hierarchical-mesh swarm usage routing through Codex) should
+  `ak run` / hierarchical-mesh swarm usage routing through Codex) should
   re-run this verification and update this note.
 
 **Independent, third-party verification.**
diff --git a/docs/adr/0004-escalation-per-projection.md b/docs/adr/0004-escalation-per-projection.md
index c424f8e..ea7622c 100644
--- a/docs/adr/0004-escalation-per-projection.md
+++ b/docs/adr/0004-escalation-per-projection.md
@@ -20,8 +20,8 @@ escalation as universally available would be dishonest.
 Escalation lives in the policy but its **availability is stated per projection path**:
 
 - **aqe projection** — honored **natively** by the shipped `auto-escalation-tracker` / `QEModelRoutingAdapter`.
-- **`ak dual run` wrapper** — ak implements **retry-with-next-rung** on a worker's non-zero exit (wrapper
-  logic ak owns, added in Slice 3).
+- **deprecated `ak dual run` wrapper** — ak implements **retry-with-next-rung** on a worker's
+  non-zero exit (wrapper logic ak owns, added in Slice 3).
 - **raw `claude-flow-codex dual run`** — **no escalation** (materialize-only users). Stated plainly in docs
   and `--help`, never implied.
 
@@ -33,7 +33,8 @@ vendor both improves the odds of recovery and preserves the qe-court vendor-dive
 
 - Honest capability boundaries — no hidden magic; each surface's behavior is documented.
 - Cross-vendor ladders double as diversity insurance.
-- The `ak dual run` wrapper carries retry/escalation state; the raw path stays a thin pass-through.
+- The deprecated `ak dual run` wrapper carries retry/escalation state; the raw path stays a thin
+  pass-through. New execution work uses `ak run`.
 - Escalation config validated the same way as primary routes (constructible provider, enabled host).
 
 ## References
diff --git a/docs/adr/0016-capability-driven-integration-adapters.md b/docs/adr/0016-capability-driven-integration-adapters.md
index 919f1e3..d21287f 100644
--- a/docs/adr/0016-capability-driven-integration-adapters.md
+++ b/docs/adr/0016-capability-driven-integration-adapters.md
@@ -128,8 +128,10 @@ Commands ask the registry what an adapter can do instead of comparing its ID:
 - verification selects host, provider, binding, projection, and observation proof contracts by
   capability.
 
-Consequently, adding OpenCode to the host registry does not make it primary or routable. Adding
-OpenRouter to the provider registry does not make it a host.
+Consequently, adding OpenCode to the host registry alone does not make it primary or routable.
+ADR-0018 subsequently enables explicit `ak run` routes after adding a supervised execution adapter;
+it remains non-primary and outside AQE projection. Adding OpenRouter to the provider registry does
+not make it a host.
 
 ### 3. Use one lifecycle contract for managed projections
 
@@ -363,13 +365,13 @@ model. The two evidence streams describe one execution only when correlation is
 normalized fact/resolution seam is the integration point for issue #59; this ADR does not absorb
 that issue's full parser, ingestion, pricing, or scorecard delivery.
 
-#### OpenCode as a non-routable host
+#### OpenCode at initial adoption
 
 OpenCode uses the same host lifecycle, normalized facts, projections, and observability contracts
-for its supported surfaces. Its initial adapter declares `primary: false` and
-`activityRouting: false`. Tests prove that it appears in applicable management/status choices but
-not in primary-host or activity-routing choices. A later change may enable those capabilities only
-after a separate grounded routing design.
+for its supported surfaces. Its initial adapter declared `primary: false` and
+`activityRouting: false`. ADR-0018 is the subsequent grounded routing design: it enables explicit
+`ak run` activity routes while retaining `primary: false`, no AQE-provider projection, and no
+provider inference from the configured model selector.
 
 ### 9. Deliver in compatibility-preserving slices
 
@@ -394,10 +396,10 @@ not write real home/global configuration.
 
 ## Compatibility and non-goals
 
-- Existing Claude/Codex behavior, `kit.json`, routing defaults, primary-host mirroring, and
-  `ak dual` projections remain valid.
-- This decision does not rename `ak dual`; provider count does not change the number of routed
-  execution hosts.
+- Existing Claude/Codex behavior, `kit.json`, routing defaults, and primary-host mirroring remain
+  valid. ADR-0018 keeps `ak dual` as a deprecated compatibility projection and makes `ak run` the
+  canonical executor.
+- Provider count does not change host identity or create an inference-provider execution host.
 - It does not implement every provider, a public adapter SDK, or arbitrary third-party code
   loading.
 - It does not persist credentials.
diff --git a/docs/adr/0017-opencode-host.md b/docs/adr/0017-opencode-host.md
index 9646e95..13f577a 100644
--- a/docs/adr/0017-opencode-host.md
+++ b/docs/adr/0017-opencode-host.md
@@ -1,4 +1,4 @@
-# ADR-0017 — OpenCode as a managed, observable, non-routable host
+# ADR-0017 — OpenCode as a managed, observable host through native surfaces
 
 - **Status:** Accepted
 - **Date:** 2026-07-28
@@ -7,8 +7,8 @@
 ## Context
 
 ADR-0016 separates execution hosts, inference providers, projections, observability,
-ownership, and lifecycle capabilities. Claude and Codex are routable hosts; OpenCode is
-already registered as a managed, non-primary, non-routable host. This ADR applies that
+ownership, and lifecycle capabilities. At this ADR's adoption, OpenCode was registered as a
+managed, non-primary, non-routable host. This ADR applies that
 architecture to OpenCode's native surfaces — ak's standing rule is "write the host's
 own config, never a parallel config layer." **OpenCode** is a third agent
 CLI in the same class, and its native surfaces are different again:
@@ -37,12 +37,14 @@ the plugin, the config entries, and the guidance file are static artifacts with
 
 ### 1. A managed host adapter — opt-in, `hosts.opencode: false` by default
 
-The ADR-0016 host registry declares `canDriveSession:true`, `canBePrimary:false`, and
-`canRouteActivities:false`, plus the `opencode-ai` npm package and native OpenCode
+The ADR-0016 host registry declares `canDriveSession:true`, `canBePrimary:false`, and now
+`canRouteActivities:true`, plus the `opencode-ai` npm package and native OpenCode
 projection. Brew/mise/native installs report `external` and are never touched.
 `providers.hosts.opencode` remains the compatibility intent field and `--opencode` opts in.
 No `ENABLE_*` env exists for opencode (ruflo's ADR-034 backend flags don't cover it), so
 wiring is entirely config-file based — the `MANAGED_ENV_KEYS` surface is unchanged.
+ADR-0018 supplies the subsequent execution proof and limits this capability to explicit `ak run`
+routes; it does not make OpenCode primary or an AQE provider.
 
 ### 2. One owner module: `src/lib/opencode.mjs`
 
@@ -128,10 +130,11 @@ reconcile) — while `ruflo-preamble` (host-agnostic operating rules) is shared:
 
 ### 4. Sync/status/setup/pick/teardown wiring — the two-tier host model
 
-`ak` manages **three managed host integrations** (claude, codex, opencode) with **two
-routing hosts** (claude, codex): opencode participates in install/config/guidance/
-status/sync/teardown exactly like the others, and is deliberately never a routing
-target, never `primaryHost`, never an aqe provider. Managed, primary, and routing sets are
+`ak` manages **three managed host integrations** (claude, codex, opencode). All three can be
+explicit activity-routing targets through `ak run`; the Claude/Codex pair remains the only
+primary-host, AQE-projection, and deprecated `ak dual` compatibility set. OpenCode participates
+in install/config/guidance/status/sync/teardown exactly like the others, and is never
+`primaryHost` or an AQE provider. Managed, primary, and routing sets are
 derived from ADR-0016's `canDriveSession`, `canBePrimary`, and `canRouteActivities`
 capabilities rather than parallel descriptor flags or hardcoded id lists.
 
@@ -180,10 +183,10 @@ switches from its hardcoded two-target block list to the shared `guidanceTargets
 `ak status`", which a frozen subset silently breaks whenever a guidance target is added
 (this also closes a pre-existing gap: codex's `agents-user` drift never surfaced there
 either). The `pick` rework in §4 replaces the first revision's behavior (opencode was
-excluded and merely preserved) with full two-tier management — the routing set stays
-claude/codex-only throughout.
-Out of scope (matching Codex's own asymmetry): routing-table integration
-(`routing.mjs` untouched), aqe provider wiring (no opencode provider type exists),
+excluded and merely preserved) with full two-tier management. ADR-0018 subsequently adds
+explicit OpenCode routing through `ak run`.
+Out of scope (matching Codex's own asymmetry): AQE provider wiring (no opencode provider type
+exists),
 statusline (no upstream surface), `drivingHost` session detection (opencode sets no
 session env marker), and usage/cost attribution (`usage-index.mjs` reads claude/codex
 transcripts only — the pricing surface has no opencode input and shows nothing for it,
@@ -230,7 +233,7 @@ which is the honest shape).
 ## References
 
 - ADR-0016 defines the registry, lifecycle, ownership, and normalized-fact contracts
-  implemented here. Generalized routable OpenCode execution is tracked separately in #76.
+  implemented here. ADR-0018 records the generalized execution contract implemented by #82.
 - `src/lib/opencode.mjs` (the owner module: `opencodeStack`, `retireOpencode`,
   `reconcileOpencodeGuidance`), `src/lib/hosts.mjs` (adapter),
   `src/lib/providers.mjs` (registry-derived managed host projection,
diff --git a/docs/adr/0018-generalized-host-worker-execution.md b/docs/adr/0018-generalized-host-worker-execution.md
index 1e9d832..874e775 100644
--- a/docs/adr/0018-generalized-host-worker-execution.md
+++ b/docs/adr/0018-generalized-host-worker-execution.md
@@ -1,16 +1,15 @@
-# ADR-0018 — Generalized host-worker execution, preserving `ak dual`
+# ADR-0018 — Generalized host-worker execution; `ak run` canonical
 
-- **Status:** Proposed
+- **Status:** Accepted
 - **Date:** 2026-07-29
 - **Deciders:** agentic-kit maintainers
 
 ## Context
 
-`ak` now manages Claude, Codex, and OpenCode, but only Claude and Codex are routing
-hosts. The existing `ak dual run` implementation materializes a Claude/Codex-specific
-configuration and delegates execution to `claude-flow-codex`. It has no execution
-adapter, result normalization, cancellation contract, or permission policy for OpenCode.
-Changing OpenCode's routing capability alone would therefore create an invalid plan.
+`ak` manages Claude, Codex, and OpenCode. The earlier `ak dual run` implementation
+materialized a Claude/Codex-specific configuration and delegated execution to
+`claude-flow-codex`; it could not safely execute an OpenCode worker. A host-neutral command and
+adapter contract are required before OpenCode can become an activity-routing host.
 
 OpenCode does provide a headless HTTP server intended for programmatic use, with an
 OpenAPI endpoint, health/version endpoint, sessions, asynchronous prompts, SSE events,
@@ -41,13 +40,13 @@ permission-response contract required for a routable worker. [OpenCode CLI docum
    facts. A host or its `provider/model` selector never proves inference-provider,
    billing, cost, or QE vendor diversity.
 
-3. Preserve `ak dual` as the Claude/Codex compatibility projection throughout this
-   migration. A later explicit generalized command will own a host-neutral plan; it
-   must not silently reinterpret existing `dual` configuration, templates, primary-host
-   mirroring, or escalation behavior.
+3. Make `ak run` the explicit, host-neutral execution command. Preserve `ak dual` only as a
+   deprecated Claude/Codex compatibility projection: it warns on stderr, retains its existing
+   `claude-flow-codex` escalation behavior for scripts, and must not silently reinterpret
+   existing configuration, templates, primary-host mirroring, or escalation behavior.
 
 4. Select OpenCode's short-lived, loopback-only `opencode serve` HTTP/OpenAPI surface
-   as the candidate execution transport. Each owned server uses an allocated loopback
+   as the execution transport. Each owned server uses an allocated loopback
    port and an ephemeral `OPENCODE_SERVER_PASSWORD`, neither logged nor persisted. The
    adapter uses Node's built-in `fetch`, keeping the package free of runtime dependencies.
    ACP is not selected: it is an editor-oriented JSON-RPC transport and adds a client
@@ -65,14 +64,14 @@ permission-response contract required for a routable worker. [OpenCode CLI docum
    would take precedence over global user policy) and makes the template side-effect
    free, inspectable, and testable.
 
-6. OpenCode remains `canRouteActivities:false` until the adapter has conformance,
-   sandbox-mutation, cancellation, timeout, permission, malformed-event, and cleanup
-   evidence. The capability flip happens in the same change as the runnable adapter.
+6. OpenCode declares `canRouteActivities:true` only with the runnable adapter and its
+   conformance evidence. Its routes are accepted by `ak run`, but are never auto-seeded,
+   AQE-projected, primary-host eligible, or accepted by deprecated `ak dual`.
 
 ## Consequences
 
-- A host-neutral plan and result schema can be added without changing existing command
-  behavior; Claude/Codex parity is proved before OpenCode routing is enabled.
+- `ak run` executes the host-neutral plan and result schema while preserving the legacy
+  Claude/Codex adapter behind the deprecated `ak dual` command.
 - Managed installation is testable independently of execution readiness: a missing CLI
   is installable, but wiring and routing never claim it is runnable until post-install
   detection succeeds.
@@ -83,13 +82,15 @@ permission-response contract required for a routable worker. [OpenCode CLI docum
 - Automatic seeding remains Claude/Codex subscription-only. No OpenCode route is seeded
   from unknown or metered provider/billing facts.
 
-## Acceptance evidence before status becomes Accepted
+## Implementation evidence
 
-- Exact-final-head fixtures and sandbox tests establish OpenCode server readiness,
-  isolated session mutation, structured terminal results, explicit deny, no-prompt-hang,
-  timeout/cancel abort, and owned-server cleanup.
-- Claude/Codex materialization remains behaviorally identical for `ak dual`.
+- Exact-final-head fixtures establish OpenCode server readiness, isolated sessions, structured
+  terminal results, explicit permission denial, malformed-event handling, no-prompt-hang,
+  timeout/cancel abort, TERM/KILL cleanup, and launch-timeout classification.
+- Claude/Codex materialization remains behaviorally identical for the deprecated `ak dual`
+  compatibility wrapper; `ak run` is the supported execution command.
 - OpenCode has parity tests for enabled-absent installation, npm-managed update drift,
   externally managed installs, post-install wiring, and marker-precise teardown.
-- Cross-host escalation, migration, routing-disable behavior, provenance, and cost safety
-  are covered; #73 remains the immediate post-#76 disable-semantics follow-on.
+- Routing-disable behavior, provenance, and cost safety are covered. OpenCode remains excluded
+  from AQE projection and vendor-diversity claims because a host/model selector is not provider
+  evidence.
diff --git a/docs/adr/README.md b/docs/adr/README.md
index 7162e90..8f81f68 100644
--- a/docs/adr/README.md
+++ b/docs/adr/README.md
@@ -25,8 +25,8 @@ Consequences**, and cites the grounded source it rests on where relevant.
 | [0014](0014-dashboard-auth-and-remediation.md) | Dashboard auth token, plus a security/quality remediation pass | Accepted |
 | [0015](0015-managed-codex-native-statusline.md) | Manage Codex's native user-wide status line without claiming rich-renderer parity | Accepted |
 | [0016](0016-capability-driven-integration-adapters.md) | Capability-driven host, provider, binding, projection, and observability adapters | Accepted |
-| [0017](0017-opencode-host.md) | OpenCode as a managed, observable, non-routable host through native surfaces | Accepted |
-| [0018](0018-generalized-host-worker-execution.md) | Generalized host-worker execution, preserving `ak dual` | Proposed |
+| [0017](0017-opencode-host.md) | OpenCode as a managed, observable host through native surfaces | Accepted |
+| [0018](0018-generalized-host-worker-execution.md) | Generalized host-worker execution; `ak run` canonical | Accepted |
 
 Theme: ADRs **0001–0006** define **dual-host LLM routing and leadership** — how `ak` lets ruflo route
 each development activity (architecture, implementation, testing, review, …) to the right host (Claude
@@ -82,13 +82,13 @@ routable by accident. Its Ollama bindings are a structural multi-host proof; ADR
 independent Proposed decision for observed local execution, catalogue-backed identity, usage
 pricing, and transcript fidelity.
 
-**0017** applies ADR-0016 to OpenCode as a managed, observable, non-routable host. It wires the rUv
+**0017** applies ADR-0016 to OpenCode as a managed, observable host. It wires the rUv
 stack through OpenCode's native JSON configuration, plugin, converted-agent, skill, and
 machine-guidance surfaces; preserves user values through ownership receipts and guarded teardown;
-and keeps primary/activity routing limited to capability-qualified Claude/Codex hosts. Generalized
-multi-host routing, including an OpenCode execution-worker contract, remains follow-on issue #76.
+and preserves primary/AQE routing boundaries. ADR-0018 adds the OpenCode execution-worker
+contract and explicit activity routes through `ak run`.
 
-**0018** defines that follow-on's execution boundary: host-neutral worker lifecycle and normalized
-terminal evidence, a compatibility-preserving `ak dual` migration, and the candidate OpenCode
-loopback HTTP/OpenAPI transport. It remains Proposed until real adapter conformance and sandbox
-evidence prove routing can be enabled safely.
+**0018** defines the host-neutral worker lifecycle and normalized terminal evidence, makes `ak run`
+the canonical execution surface, and preserves `ak dual` only as a deprecated Claude/Codex
+compatibility wrapper. It selects OpenCode's loopback HTTP/OpenAPI transport and documents its
+permission, timeout, cleanup, provenance, and AQE-boundary evidence.
diff --git a/docs/ddd/README.md b/docs/ddd/README.md
index 4414374..8bdeeb1 100644
--- a/docs/ddd/README.md
+++ b/docs/ddd/README.md
@@ -10,7 +10,7 @@ describe the current system unless a section is explicitly marked as future work
 | [Ubiquitous language](ubiquitous-language.md) | Canonical meanings used across code, CLI, ADRs, and documentation |
 | [Context map](context-map.md) | Bounded contexts, ownership, and relationships |
 | [Integration management](integration-management.md) | Hosts, inference providers, bindings, capabilities, lifecycle, facts, and ownership |
-| [Routing and orchestration](routing-and-orchestration.md) | Activities, routes, leadership, escalation, projections, and dual runs |
+| [Routing and orchestration](routing-and-orchestration.md) | Activities, routes, leadership, escalation, projections, canonical `ak run`, and legacy dual compatibility |
 | [Live Sessions](live-sessions.md) | Evidence acquisition, live-session aggregates, replay, and dashboard delivery |
 
 ## Relationship to other documentation
diff --git a/docs/ddd/integration-management.md b/docs/ddd/integration-management.md
index a1bbc11..1187ff5 100644
--- a/docs/ddd/integration-management.md
+++ b/docs/ddd/integration-management.md
@@ -56,7 +56,9 @@ protocols, and non-loopback plaintext HTTP.
 
 - Primary and activity-routing capabilities require session-driving capability.
 - Commands select adapters by capability rather than recognized ID.
-- Adding OpenCode does not make it primary or routable.
+- Adding OpenCode does not make it primary; an explicit OpenCode route is eligible only after its
+  execution adapter declares activity-routing capability, and runs through `ak run` rather than
+  AQE or `ak dual`.
 - Adding OpenRouter does not make it a host.
 - Provider claims are rendered only when the provider declares and evidence supports them.
 - Compatibility collections are derived from registries.
diff --git a/docs/ddd/live-sessions.md b/docs/ddd/live-sessions.md
index 10bdb63..efe512c 100644
--- a/docs/ddd/live-sessions.md
+++ b/docs/ddd/live-sessions.md
@@ -55,7 +55,7 @@ Source adapters are anti-corruption layers for:
 
 - Claude session and delegated-agent artifacts;
 - Codex rollouts and state-ledger spawn edges;
-- ak dual-run workflow/routing metadata;
+- legacy ak dual-run workflow/routing metadata;
 - ruflo swarm, agent, hook, and daemon state;
 - agentic-qe tasks, workers, evaluations, gates, and court verdicts;
 - explicit skill, plugin, MCP, and tool lifecycle records.
diff --git a/docs/ddd/routing-and-orchestration.md b/docs/ddd/routing-and-orchestration.md
index 906a6a3..66be8ab 100644
--- a/docs/ddd/routing-and-orchestration.md
+++ b/docs/ddd/routing-and-orchestration.md
@@ -20,8 +20,8 @@ RoutingPolicy
                 provenance
                 escalation rungs[]
 
-RoutingPolicy -> configuration projections -> AQE / dual-run / MCP surfaces
-RoutingPolicy + template + task -> materialized workers -> dual run
+RoutingPolicy -> eligible configuration projections -> AQE / legacy dual-run / MCP surfaces
+RoutingPolicy + template + task -> materialized workers -> ak run
 ```
 
 ### Activity
@@ -64,29 +64,35 @@ change the persisted base route.
 `kit.json.providers.dualRouting` is the current persisted compatibility path for routing intent.
 Pure projectors materialize that policy into:
 
-- AQE `agentOverrides`;
-- dual-run worker configuration; and
+- AQE `agentOverrides` for AQE-eligible Claude/Codex routes;
+- `ak run`'s host-neutral worker plan;
+- deprecated dual-run worker configuration for Claude/Codex-only compatibility; and
 - Codex MCP availability/configuration.
 
 These are configuration projections, not independent routing policies. Native surfaces must not
 be edited back into domain truth without an explicit import or reconciliation design.
 
-## Meaning of dual
+## Canonical execution and deprecated dual compatibility
 
-`ak dual run` names the current Claude-and-Codex peer-host collaboration substrate. Workers in a
-single pipeline may reach different inference providers through their bindings, but provider
-cardinality does not change the number of execution hosts.
+`ak run` is the canonical executor for materialized activity plans. It can select every host whose
+adapter declares `canRouteActivities`, including an explicit OpenCode route. It does not infer a
+provider from a host/model selector, make OpenCode primary, or project OpenCode into AQE.
+
+`ak dual run` is deprecated. It remains a Claude-and-Codex compatibility wrapper for existing
+`claude-flow-codex` workflows, including its legacy escalation semantics. Workers in that adapter
+may reach different inference providers through their bindings, but provider cardinality does not
+change the number of execution hosts.
 
 Therefore:
 
 - two hosts with three or more providers remain a dual run;
 - OpenRouter does not create a third orchestration host;
 - two Ollama bindings do not create two Ollama providers; and
-- OpenCode does not join routing until its host adapter explicitly gains the required capability.
+- OpenCode runs through `ak run` once its host adapter explicitly gains the required capability;
+  the deprecated `ak dual` rejects it rather than changing its compatibility contract.
 
-If agentic-kit later supports three or more routable peer hosts, that is a new generalized
-orchestration concept. It should receive explicit vocabulary, command design, migration behavior,
-and an ADR rather than silently changing `dual`.
+Generalized multi-host execution does not redefine the legacy word `dual`: only `ak run` owns that
+surface. `ak dual` remains a removable compatibility path rather than a second orchestration model.
 
 ## Cost safety
 
@@ -101,9 +107,10 @@ must distinguish per-token price from measured or expected per-task cost.
 
 1. Only capability-qualified hosts receive activity routes.
 2. Routing host and inference provider are separate axes.
-3. One canonical policy feeds all downstream configuration projections.
+3. One canonical policy feeds all eligible downstream projections; ineligible OpenCode routes are
+   never fabricated into AQE or the deprecated dual adapter.
 4. User-pinned routes are not overwritten by default refresh.
 5. Primary-host selection changes leadership defaults, not host enablement symmetry.
 6. Escalation is explicit, ordered, and per route.
 7. Automatic seeding cannot introduce a metered provider path.
-8. `dual` continues to mean two peer execution hosts.
+8. `ak run` is the canonical executor; `dual` remains a deprecated two-host compatibility wrapper.
diff --git a/docs/ddd/ubiquitous-language.md b/docs/ddd/ubiquitous-language.md
index 54982fa..718b901 100644
--- a/docs/ddd/ubiquitous-language.md
+++ b/docs/ddd/ubiquitous-language.md
@@ -52,14 +52,15 @@ missing price.
 | Routing policy | Persisted activity-to-route intent |
 | Route provenance | Whether a route is a default, seeded by `ak`, or deliberately set by the user |
 | Escalation rung | Alternate host and model tried after failure when escalation is requested |
-| Dual run | Claude-and-Codex collaboration pipeline materialized from the routing policy |
+| `ak run` | Canonical host-neutral execution of a materialized routing plan |
+| Dual run | Deprecated Claude-and-Codex compatibility pipeline materialized from the routing policy |
 | Read-model projection | Derived query or UI state, distinct from a configuration projection |
 | Transcript host | Host whose native artifact supplied a transcript |
 | Inference identity | Provider and model supported by provider-specific or out-of-band evidence |
 
-`Dual` describes the two peer execution hosts in the current collaboration substrate. The number
-of inference providers behind those hosts does not change a dual run into a three-host
-orchestration.
+`Dual` describes the two peer execution hosts in the deprecated compatibility substrate. The
+number of inference providers behind those hosts does not change that legacy pipeline into a
+three-host orchestration. Generalized execution belongs to `ak run`.
 
 ## Usage rules
 
diff --git a/src/commands/dual.mjs b/src/commands/dual.mjs
index 1c394fe..77faf71 100644
--- a/src/commands/dual.mjs
+++ b/src/commands/dual.mjs
@@ -27,10 +27,10 @@ export const options = {
   json: { type: 'boolean', default: false },
 };
 
-export const help = `ak dual — run a Claude+Codex collaboration swarm
+export const help = `ak dual — deprecated Claude+Codex compatibility wrapper
 
-Uses your per-activity routing policy (from \`ak host\`) to assign each pipeline
-step to the right host + model, then runs it via ${ADAPTER}.
+Use \`ak run <template> "<task>"\` for all new execution work. This legacy command
+retains its Claude+Codex ${ADAPTER} adapter and escalation behavior for existing scripts.
 
 Usage:
   ak dual run <template> "<task>"   run a collaboration pipeline
@@ -47,9 +47,9 @@ Options (run):
   --timeout <ms>               per-worker timeout
 
 Examples:
-  ak dual run feature "add token-bucket rate limiting"
-  ak dual run security "src/auth/" --escalate
-  ak dual run refactor "extract the payment module" --dry-run`;
+  ak run feature "add token-bucket rate limiting"
+  ak dual run security "src/auth/" --escalate  # legacy compatibility
+  ak run refactor "extract the payment module" --dry-run`;
 
 /** Build the run-local policy (persisted policy + per-run --route overrides) and
  *  project it to a dual-run config. */
diff --git a/tests/kit/dual-cli.test.mjs b/tests/kit/dual-cli.test.mjs
index b6634d1..4103b1b 100644
--- a/tests/kit/dual-cli.test.mjs
+++ b/tests/kit/dual-cli.test.mjs
@@ -38,6 +38,8 @@ test('ak dual run --dry-run materializes the feature pipeline from the policy',
   const r = ak(['dual', 'run', 'feature', 'add auth', '--dry-run'], { cwd: project, home });
   assert.equal(r.status, 0, r.stderr);
   assert.match(r.stdout, /dual run: feature/);
+  assert.match(r.stderr, /ak dual is deprecated/i);
+  assert.match(r.stderr, /use `ak run`/i);
   assert.match(r.stdout, /"platform": "claude"/);
   assert.match(r.stdout, /"platform": "codex"/);
   assert.match(r.stdout, /add auth/);