cool-workflow 0.2.1 → 0.2.3

package/dist/shell/worker-cli.js

@@ -51,6 +51,7 @@ const drive_1 = require("./drive");
 const commit_1 = require("./commit");
 const report_1 = require("./report");
 const operator_ux_1 = require("./operator-ux");
+const agent_config_1 = require("./agent-config");
 function cwdFor(args) {
     return typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
 }
@@ -60,6 +61,10 @@ function req(value, label) {
         throw new Error(`Missing ${label}`);
     return s;
 }
+/** `--allow-unattested` (CLI: dashed key; MCP: allowUnattested). */
+function allowUnattestedOption(args) {
+    return Boolean(args.allowUnattested ?? args["allow-unattested"]);
+}
 function workerListCli(args) {
     const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
     return (0, worker_isolation_1.listWorkerScopes)(run, { status: typeof args.status === "string" ? args.status : undefined });
@@ -72,13 +77,14 @@ function workerShowCli(args) {
     return scope;
 }
 function workerManifestCli(args) {
-    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
-    const scope = (0, worker_isolation_1.getWorkerScope)(run, req(args.workerId, "worker id"));
-    if (!scope)
-        throw new Error(`Unknown worker for run ${run.id}: ${args.workerId}`);
-    const manifest = (0, worker_isolation_1.writeWorkerManifest)(run, scope);
-    (0, run_store_1.saveCheckpoint)(run);
-    return manifest;
+    return (0, run_store_1.withRunStateLock)(req(args.runId, "run id"), cwdFor(args), (run) => {
+        const scope = (0, worker_isolation_1.getWorkerScope)(run, req(args.workerId, "worker id"));
+        if (!scope)
+            throw new Error(`Unknown worker for run ${run.id}: ${args.workerId}`);
+        const manifest = (0, worker_isolation_1.writeWorkerManifest)(run, scope);
+        (0, run_store_1.saveCheckpoint)(run);
+        return manifest;
+    });
 }
 /** `cw worker output <run> <worker> <result>` — records the worker's result
  *  and returns the full RunSummary, a byte-behavior port of the old build's
@@ -91,34 +97,40 @@ function workerManifestCli(args) {
  *  tasks.completed, workers.byStatus, and loopStage. The drive loop does these
  *  same steps itself around the bare accept, so it never routes through here. */
 function workerOutputCli(args) {
-    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
-    (0, worker_isolation_1.recordWorkerOutput)(run, req(args.workerId, "worker id"), req(args.resultPath, "result file"), {});
-    run.loopStage = "observe";
-    (0, dispatch_1.updatePhaseStatuses)(run);
-    (0, drive_1.maybeExpandLoop)(run);
-    (0, commit_1.commitState)(run, `worker:${req(args.workerId, "worker id")}:result`);
-    (0, report_1.writeReport)(run);
-    (0, run_store_1.saveCheckpoint)(run);
-    return (0, operator_ux_1.summarizeRun)(run);
+    return (0, run_store_1.withRunStateLock)(req(args.runId, "run id"), cwdFor(args), (run) => {
+        (0, worker_isolation_1.recordWorkerOutput)(run, req(args.workerId, "worker id"), req(args.resultPath, "result file"), {
+            requireAttestedTelemetry: (0, agent_config_1.resolveAgentConfig)(args).requireAttestedTelemetry,
+            allowUnattested: allowUnattestedOption(args),
+        });
+        run.loopStage = "observe";
+        (0, dispatch_1.updatePhaseStatuses)(run);
+        (0, drive_1.maybeExpandLoop)(run);
+        (0, commit_1.commitState)(run, `worker:${req(args.workerId, "worker id")}:result`);
+        (0, report_1.writeReport)(run);
+        (0, run_store_1.saveCheckpoint)(run);
+        return (0, operator_ux_1.summarizeRun)(run);
+    });
 }
 function workerFailCli(args) {
-    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
-    const message = String(args.message || req(args.resultPath, "failure message"));
-    const scope = (0, worker_isolation_1.recordWorkerFailure)(run, req(args.workerId, "worker id"), message, {
-        code: typeof args.code === "string" ? args.code : undefined,
-        path: typeof args.path === "string" ? args.path : undefined,
-        retryable: args.retryable !== undefined ? Boolean(args.retryable) : undefined,
+    return (0, run_store_1.withRunStateLock)(req(args.runId, "run id"), cwdFor(args), (run) => {
+        const message = String(args.message || req(args.resultPath, "failure message"));
+        const scope = (0, worker_isolation_1.recordWorkerFailure)(run, req(args.workerId, "worker id"), message, {
+            code: typeof args.code === "string" ? args.code : undefined,
+            path: typeof args.path === "string" ? args.path : undefined,
+            retryable: args.retryable !== undefined ? Boolean(args.retryable) : undefined,
+        });
+        (0, run_store_1.saveCheckpoint)(run);
+        return scope;
     });
-    (0, run_store_1.saveCheckpoint)(run);
-    return scope;
 }
 /** validate returns the boundary violation (null when the write path is
  *  allowed) and signals a violation through a non-zero exit code, not just
  *  stdout — a validate verb must report an invalid verdict via its exit code. */
 function workerValidateCli(args) {
-    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
-    const target = args.path || args.resultPath;
-    const violation = (0, worker_isolation_1.validateWorkerBoundary)(run, req(args.workerId, "worker id"), target ? { path: String(target) } : {});
-    (0, run_store_1.saveCheckpoint)(run);
-    return { violation, exitCode: violation ? 1 : undefined };
+    return (0, run_store_1.withRunStateLock)(req(args.runId, "run id"), cwdFor(args), (run) => {
+        const target = args.path || args.resultPath;
+        const violation = (0, worker_isolation_1.validateWorkerBoundary)(run, req(args.workerId, "worker id"), target ? { path: String(target) } : {});
+        (0, run_store_1.saveCheckpoint)(run);
+        return { violation, exitCode: violation ? 1 : undefined };
+    });
 }

package/dist/shell/worker-isolation.js

@@ -106,6 +106,7 @@ function workerBlackboardManifest(run, task) {
 const verifier_1 = require("./verifier");
 const runner_1 = require("../core/pipeline/runner");
 const hash_1 = require("../core/hash");
+const collate_1 = require("../core/util/collate");
 const telemetry_attestation_1 = require("../core/trust/telemetry-attestation");
 const telemetry_ledger_io_1 = require("./telemetry-ledger-io");
 exports.WORKER_ISOLATION_SCHEMA_VERSION = 1;
@@ -531,13 +532,37 @@ function recordWorkerOutput(run, workerId, resultPath, options = {}) {
         })
         : undefined;
     // Opt-in fail-closed gate (default off): when the operator requires
-    // attested telemetry, a delegated hop whose verdict is not `attested`
-    // is REJECTED here — BEFORE any accept-side state mutation — so the
-    // drive parks it instead of recording unverifiable usage.
-    if (options.requireAttestedTelemetry && telemetry && telemetry.status !== "attested") {
-        const message = `Worker ${workerId} telemetry is ${telemetry.status} (${telemetry.reason || "unverified"}) and require-attested-telemetry is enabled — refusing to accept a hop whose usage cannot be cryptographically verified`;
-        recordWorkerFailure(run, workerId, message, { code: "telemetry-unattested-blocked", path: absoluteResultPath, retryable: false });
-        throw new Error(message);
+    // attested telemetry, an accept whose usage cannot be verified is
+    // REJECTED here — BEFORE any accept-side state mutation — so the drive
+    // parks it instead of recording unverifiable usage. This fires on BOTH
+    // shapes: a delegation present but not attested (telemetry.status !==
+    // "attested"), and NO delegation metadata at all. The second shape is
+    // the gap a manual `cw worker output` / `cw result` accept used to slip
+    // through silently: options.agentDelegation was simply absent, so
+    // `telemetry` was undefined and the old `telemetry &&` condition
+    // short-circuited false — an unattested result could be laundered
+    // through the manual accept path even with the require flag on.
+    // --allow-unattested is the operator's explicit way past this: it never
+    // skips the gate silently, it records a telemetry.gate-override event.
+    if (options.requireAttestedTelemetry && (!telemetry || telemetry.status !== "attested")) {
+        if (options.allowUnattested) {
+            (0, trust_audit_1.recordTrustAuditEvent)(run, {
+                kind: "telemetry.gate-override",
+                decision: "allowed",
+                source: "operator",
+                workerId,
+                taskId: task.id,
+                metadata: { reason: "--allow-unattested", telemetryStatus: telemetry ? telemetry.status : "absent" },
+            });
+        }
+        else {
+            const code = telemetry ? "telemetry-unattested-blocked" : "telemetry-missing-blocked";
+            const message = telemetry
+                ? `Worker ${workerId} telemetry is ${telemetry.status} (${telemetry.reason || "unverified"}) and require-attested-telemetry is enabled — refusing to accept a hop whose usage cannot be cryptographically verified`
+                : `Worker ${workerId} carries no agent-delegation telemetry at all and require-attested-telemetry is enabled — refusing to accept an unattested manual result (pass --allow-unattested to record an audited override)`;
+            recordWorkerFailure(run, workerId, message, { code, path: absoluteResultPath, retryable: false });
+            throw new Error(message);
+        }
     }
     const agentDelegationMeta = delegation
         ? {
@@ -797,7 +822,7 @@ function listWorkerScopes(run, options = {}) {
     // silently drops workers whenever run.workers was reset.
     const merged = mergeScopes(run.workers || [], loadWorkerScopesFromDisk(run));
     run.workers = merged;
-    const workers = merged.slice().sort((a, b) => a.id.localeCompare(b.id));
+    const workers = merged.slice().sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id));
     return options.status ? workers.filter((w) => w.status === options.status) : workers;
 }
 function countByStatus(workers) {
@@ -824,7 +849,7 @@ function countBucket(values) {
     return counts;
 }
 function formatCountBucket(counts) {
-    const entries = Object.entries(counts).sort(([a], [b]) => a.localeCompare(b));
+    const entries = Object.entries(counts).sort(([a], [b]) => (0, collate_1.stableCompare)(a, b));
     if (!entries.length)
         return "none";
     return entries.map(([k, v]) => `${k}=${v}`).join(", ");

package/dist/shell/workflow-app-loader.js

@@ -75,6 +75,7 @@ const path = __importStar(require("node:path"));
 const app_schema_1 = require("../core/workflow-apps/app-schema");
 const sandbox_profile_1 = require("./sandbox-profile");
 const version_1 = require("../core/version");
+const collate_1 = require("../core/util/collate");
 class WorkflowAppNotFoundError extends Error {
     constructor(appId) {
         super(`Workflow app not found: ${appId}`);
@@ -421,10 +422,10 @@ function listWorkflowAppRecords() {
         ...loadWorkflowFiles(workflowsDir).map((file) => loadWorkflowAppFromEntrypoint(file)),
         ...loadAppManifestFiles(appsDir).map((file) => loadWorkflowAppFromManifest(file)),
     ].sort((left, right) => {
-        const byId = left.app.id.localeCompare(right.app.id);
+        const byId = (0, collate_1.stableCompare)(left.app.id, right.app.id);
         if (byId)
             return byId;
-        return sourcePathOf(left).localeCompare(sourcePathOf(right));
+        return (0, collate_1.stableCompare)(sourcePathOf(left), sourcePathOf(right));
     });
     const seen = new Map();
     for (const record of records) {

package/dist/wiring/capability-table/basics.js

@@ -0,0 +1,91 @@
+"use strict";
+// wiring/capability-table/basics.ts — MILESTONE 2's CLI bindings (version,
+// list, status, sandbox.list). Split out of core/capability-table.ts,
+// byte-for-byte (extracted with sed, not retyped).
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_core_1 = require("./registry-core");
+// ---------------------------------------------------------------------
+// CLI bindings wired at THIS milestone (version, list, status,
+// sandbox.list). `version` is cli-only per SPEC/mcp.md's declared
+// one-surface list (`help` is handled directly by cli/entry.ts's
+// top-level flag redirect, same as milestone 1 — it is not itself a
+// dispatchable command row); `list`/`status`/`sandbox.list` reuse the mcp
+// row's capability id and get a cli binding layered on top. Every handler
+// below returns a `CliHandlerResult`; core/ never touches process.stdout
+// or process.exitCode directly (see docs/rebuild/PLAN.md's core/shell split) —
+// cli/dispatch.ts's generic executor performs the actual write.
+// ---------------------------------------------------------------------
+const version_1 = require("../../core/version");
+const help_1 = require("../../core/format/help");
+const completion_1 = require("../../core/format/completion");
+const io_1 = require("../../cli/io");
+// This whole module is required unconditionally at startup for EVERY
+// command (see wiring/capability-table/index.ts) — a top-level import of
+// `shell/workflow-app-loader` here means even `cw --version` pays its
+// load cost, though only `search`'s handler ever calls it.
+function loadWorkflowAppLoader() {
+    return require("../../shell/workflow-app-loader");
+}
+(0, registry_core_1.addCliOnlyCapability)("version", "Print the current cool-workflow version.", {
+    path: ["version"],
+    jsonMode: "default",
+    handler: () => ({ text: `${version_1.CURRENT_COOL_WORKFLOW_VERSION}\n` }),
+}, "version is a local, no-run-state print; the old build never gave it an MCP peer.");
+/** `cw completion <bash|zsh|fish>` — a static shell-completion script for
+ *  the top-level command word list (core/format/completion.ts). CLI-only:
+ *  a shell-integration script is meaningless as an MCP tool result. */
+(0, registry_core_1.addCliOnlyCapability)("completion", "Print a shell-completion script for the top-level cw commands (bash, zsh, or fish).", {
+    path: ["completion"],
+    jsonMode: "human",
+    handler: (args) => {
+        const shell = (0, io_1.optionalArg)(args.positionals[0]);
+        if (!shell)
+            throw new Error('Missing shell name.\n  Try: cw completion bash|zsh|fish');
+        return { text: (0, completion_1.formatCompletionScript)(shell) };
+    },
+}, "shell-completion output is a script for the user's OWN shell to source, not data an MCP client could use — CLI-only, same reasoning as doctor/fix.");
+/** `cw search <keyword>` — filters the SAME real app discovery `cw list`
+ *  shows, by id/title/summary (byte-behavior port of cli/dispatch.ts's
+ *  milestone-1 carry-over `search` arm, moved here so the dispatchLegacy
+ *  switch shrinks per its file header's rule). The old v0.1.98 CLI DID
+ *  have its own `cw help search` row (`docs/rebuild/SPEC/cli-help/
+ *  search.txt`: "cw search  Search workflow apps by keyword (title,
+ *  description, id)."); `hiddenFromHelp` here was a rebuild regression
+ *  that hid it, not a preserved old-build quirk — removed so the row
+ *  shows again. The summary text below is intentionally NOT byte-matched
+ *  to that old capture: the old wording says "description," but the
+ *  filter below matches `summary` (there is no `description` field) — so
+ *  the summary text stays accurate to current fields rather than
+ *  reproducing the old capture's stale terminology. */
+(0, registry_core_1.addCliOnlyCapability)("search", "Search bundled workflows by id/title/summary keyword.", {
+    path: ["search"],
+    jsonMode: "flag",
+    handler: (args) => {
+        const keyword = args.positionals.join(" ");
+        if (!keyword.trim()) {
+            throw new Error('Missing search keyword.\n  Tip: cw search architecture to find workflows about architecture.');
+        }
+        const lower = keyword.toLowerCase();
+        const results = loadWorkflowAppLoader().listWorkflowApps()
+            .filter((a) => String(a.title).toLowerCase().includes(lower) ||
+            String(a.summary).toLowerCase().includes(lower) ||
+            String(a.id).toLowerCase().includes(lower))
+            .map((a) => ({ id: String(a.id), title: String(a.title), summary: String(a.summary) }));
+        return { json: results, text: (0, help_1.formatSearchResults)(keyword, results) };
+    },
+}, "CLI-only discovery helper over the same real app data cw list shows; no MCP client needs a free-text search tool alongside cw_list's structured output.");
+(0, registry_core_1.attachCliBinding)("list", {
+    path: ["list"],
+    jsonMode: "default",
+    handler: () => ({ json: (0, registry_core_1.listBundledWorkflows)() }),
+});
+(0, registry_core_1.attachCliBinding)("status", {
+    path: ["status"],
+    jsonMode: "flag",
+    handler: (args) => ({ json: (0, registry_core_1.statusPayload)(args.positionals[0]) }),
+});
+(0, registry_core_1.attachCliBinding)("sandbox.list", {
+    path: ["sandbox", "list"],
+    jsonMode: "default",
+    handler: () => ({ json: (0, registry_core_1.listBundledSandboxProfiles)() }),
+});

package/dist/wiring/capability-table/exec-backend.js

@@ -0,0 +1,171 @@
+"use strict";
+// wiring/capability-table/exec-backend.ts — MILESTONE 5 (execution backend,
+// agent spawn, sandbox) CLI bindings: sandbox.*, backend.*, app.run. Split
+// out of core/capability-table.ts, byte-for-byte (extracted with sed, not
+// retyped).
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_core_1 = require("./registry-core");
+// MILESTONE 5 (execution backend, agent spawn, sandbox) CLI bindings:
+// sandbox.list|show|validate, backend.list|show|probe,
+// backend.agent.config.show|set, doctor, fix. Handler BODIES live in
+// shell/exec-backend-cli.ts / shell/doctor.ts (impure — env/fs reads);
+// this table only wires argv shape -> handler call, per cli/dispatch.ts's
+// generic executor contract. `sandbox.list`/`backend.list` are ALREADY
+// declared MCP-only rows from milestone 2 (MCP_TOOL_DATA above) — this
+// section layers a `cli` binding onto them (attachCliBinding) and replaces
+// their milestone-2 placeholder `mcp.handler` with the real body, exactly
+// as milestones 3/4 did for their own rows.
+// ---------------------------------------------------------------------
+const exec_backend_cli_1 = require("../../shell/exec-backend-cli");
+const io_1 = require("../../cli/io");
+// This slice is required unconditionally at startup for every command;
+// load doctor/app-run-cli lazily so only doctor/fix/sandbox.choose/
+// sandbox.resolve/app.run handlers pay their require cost.
+function loadDoctor() {
+    return require("../../shell/doctor");
+}
+function loadAppRunCli() {
+    return require("../../shell/app-run-cli");
+}
+(0, registry_core_1.attachCliBinding)("sandbox.list", {
+    path: ["sandbox", "list"],
+    jsonMode: "default",
+    handler: (args) => ({ json: (0, exec_backend_cli_1.listSandboxProfilesCli)(args.options) }),
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("sandbox.list").mcp.handler = (args) => (0, exec_backend_cli_1.listSandboxProfilesCli)(args);
+// GAP #24: cw_sandbox_choose / cw_sandbox_resolve + cw_app_run were declared
+// MCP-only rows with the notYetImplemented placeholder handler. Wire them to
+// the ported shell bodies (both are MCP-only in the old build — no CLI path).
+registry_core_1.REGISTRY_BY_CAPABILITY.get("sandbox.choose").mcp.handler = (args) => loadAppRunCli().sandboxChooseCli(args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("sandbox.resolve").mcp.handler = (args) => loadAppRunCli().sandboxChooseCli(args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("app.run").mcp.handler = (args) => loadAppRunCli().appRunCli(args);
+(0, registry_core_1.attachCliBinding)("sandbox.show", {
+    path: ["sandbox", "show"],
+    jsonMode: "default",
+    handler: (args) => ({ json: (0, exec_backend_cli_1.showSandboxProfileCli)((0, io_1.required)(args.positionals[0], "profile id"), args.options) }),
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("sandbox.show").mcp.handler = (args) => (0, exec_backend_cli_1.showSandboxProfileCli)((0, io_1.required)((0, io_1.optionalArg)(args.profileId), "profile id"), args);
+(0, registry_core_1.attachCliBinding)("sandbox.validate", {
+    path: ["sandbox", "validate"],
+    jsonMode: "default",
+    handler: (args) => {
+        const result = (0, exec_backend_cli_1.validateSandboxProfileCli)((0, io_1.required)(args.positionals[0], "profile file"), args.options);
+        return { json: result, exitCode: result.valid ? undefined : 1 };
+    },
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("sandbox.validate").mcp.handler = (args) => (0, exec_backend_cli_1.validateSandboxProfileCli)((0, io_1.required)((0, io_1.optionalArg)(args.profileFile), "profile file"), args);
+// PARITY: `sandbox.choose`/`sandbox.resolve` are BOTH-surface capabilities
+// per SPEC/mcp.md (old build cli.path ["sandbox","choose"]/["sandbox",
+// "resolve"]) — they were left MCP-only at GAP #24 (see the comment
+// above sandboxChooseCli's mcp.handler wiring). Attach the same, already-
+// working shell body as the cli.handler too, so the CLI front door and
+// the parity payload probe both reach it (no new business logic, same
+// function both surfaces already call over MCP).
+(0, registry_core_1.attachCliBinding)("sandbox.choose", {
+    path: ["sandbox", "choose"],
+    jsonMode: "default",
+    handler: (args) => ({ json: loadAppRunCli().sandboxChooseCli(args.options) }),
+});
+(0, registry_core_1.attachCliBinding)("sandbox.resolve", {
+    path: ["sandbox", "resolve"],
+    jsonMode: "default",
+    handler: (args) => ({ json: loadAppRunCli().sandboxChooseCli(args.options) }),
+});
+(0, registry_core_1.attachCliBinding)("backend.list", {
+    path: ["backend", "list"],
+    jsonMode: "default",
+    handler: () => ({ json: (0, exec_backend_cli_1.listBackendsCli)() }),
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.list").mcp.handler = () => (0, exec_backend_cli_1.listBackendsCli)();
+(0, registry_core_1.attachCliBinding)("backend.show", {
+    path: ["backend", "show"],
+    jsonMode: "default",
+    handler: (args) => ({ json: (0, exec_backend_cli_1.showBackendCli)((0, io_1.required)(args.positionals[0], "backend id")) }),
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.show").mcp.handler = (args) => (0, exec_backend_cli_1.showBackendCli)((0, io_1.required)((0, io_1.optionalArg)(args.backendId), "backend id"));
+(0, registry_core_1.attachCliBinding)("backend.probe", {
+    path: ["backend", "probe"],
+    jsonMode: "default",
+    handler: (args) => ({ json: (0, exec_backend_cli_1.probeBackendCli)(args.positionals[0], args.options) }),
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.probe").mcp.handler = (args) => (0, exec_backend_cli_1.probeBackendCli)((0, io_1.optionalArg)(args.backendId), args);
+// `backend agent config [show]` = read-only; `backend agent config set
+// ...` = mutating. CLI path is ["backend", "agent"] (2 tokens, matching
+// dispatchTable's supported path lengths); the remaining positionals
+// ("config", "show"/"set") are read inside the handler, byte-exact to the
+// old build's handleBackend "agent" case (src/cli/handlers/
+// operational.ts:52-62).
+(0, registry_core_1.attachCliBinding)("backend.agent.config.show", {
+    path: ["backend", "agent"],
+    helpPath: ["backend", "agent", "config"],
+    jsonMode: "default",
+    handler: (args) => {
+        const action = args.positionals[1];
+        if (action === "set")
+            return { json: (0, exec_backend_cli_1.backendAgentConfigSet)(args.options) };
+        return { json: (0, exec_backend_cli_1.backendAgentConfigShow)(args.options) };
+    },
+});
+// `backend.agent.config.set` shares the SAME dispatch path/handler as
+// `.show` above (dispatchTable only supports 2-token paths, and the
+// show-vs-set branch lives inside that one handler on positionals[1] —
+// byte-exact to the old build's handleBackend "agent" case). This second
+// attachCliBinding call exists ONLY so `cw help backend` lists both rows
+// (cliCommandHelpRows iterates cliCapabilities(), one row per capability),
+// matching the old registry's two declared rows sharing one caseTokens
+// group; dispatchTable itself never reaches this row a second time because
+// `backend.agent.config.show`'s row is found first by
+// findCapabilityByCliPath's linear scan and its handler already covers
+// both actions.
+(0, registry_core_1.attachCliBinding)("backend.agent.config.set", {
+    path: ["backend", "agent"],
+    helpPath: ["backend", "agent", "config"],
+    jsonMode: "default",
+    handler: (args) => {
+        const action = args.positionals[1];
+        if (action === "set")
+            return { json: (0, exec_backend_cli_1.backendAgentConfigSet)(args.options) };
+        return { json: (0, exec_backend_cli_1.backendAgentConfigShow)(args.options) };
+    },
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.agent.config.show").mcp.handler = (args) => (0, exec_backend_cli_1.backendAgentConfigShow)(args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.agent.config.set").mcp.handler = (args) => (0, exec_backend_cli_1.backendAgentConfigSet)(args);
+// PARITY: `backend.agent.config.set` mutates $CW_HOME/agent-config.json
+// (secret-stripped) before returning the effective config; both surfaces
+// perform the same write, so it is a documented opt-out from the
+// read-payload probe, not an undocumented divergence.
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.agent.config.set").payloadIdentical = false;
+registry_core_1.REGISTRY_BY_CAPABILITY.get("backend.agent.config.set").reason =
+    "Mutating: persists $CW_HOME/agent-config.json (secret-stripped) before returning the effective config; both surfaces perform the same write — it is a surface-mutating verb, not a read probe.";
+(0, registry_core_1.addCliOnlyCapability)("doctor", "Diagnose the host for setup problems (Node version, agent backend, agent binary on PATH, git, writable home/repo state) and print an actionable fix per check.", {
+    path: ["doctor"],
+    jsonMode: "flag",
+    handler: (args) => {
+        const doctor = loadDoctor();
+        const report = doctor.runDoctor(args.options, process.env, String(args.options.cwd || process.cwd()));
+        // Byte-exact port of src/cli/command-surface.ts:170-176: both text
+        // branches are written as `${formatX(report)}\n` UNCONDITIONALLY —
+        // formatDoctorFixes already ends in its own "\n" (its last joined
+        // element is ""), so its case needs one MORE explicit "\n" here to
+        // reproduce that unconditional append; cli/dispatch.ts's generic
+        // renderer only appends "\n" when the text does NOT already end in
+        // one, so a bare `formatDoctorFixes(report)` here would silently
+        // drop the old build's trailing blank line.
+        const text = (0, io_1.wantsJson)(args.options) ? undefined : args.options.fix ? `${doctor.formatDoctorFixes(report)}\n` : doctor.formatDoctorReport(report);
+        return { json: report, text, exitCode: report.ok ? undefined : 1 };
+    },
+}, "Environment diagnostics are inherently local to the CLI host — Node version, $PATH, $CW_HOME/cwd writability. An MCP client diagnosing the server process's environment is not meaningful; agents already receive the same readiness facts in their typed results (e.g. status: blocked, agentConfigured). Inspired by `brew doctor`.");
+(0, registry_core_1.addCliOnlyCapability)("fix", "Print consolidated fix commands for CW setup issues.", {
+    path: ["fix"],
+    jsonMode: "human",
+    handler: (args) => {
+        const doctor = loadDoctor();
+        const report = doctor.runDoctor(args.options, process.env, String(args.options.cwd || process.cwd()));
+        // See the "doctor" handler's comment above: formatDoctorFixes
+        // already ends in "\n", so one more explicit "\n" here reproduces
+        // src/cli/command-surface.ts:126-130's unconditional
+        // `${formatDoctorFixes(report)}\n` write.
+        return { text: `${doctor.formatDoctorFixes(report)}\n`, exitCode: report.ok ? undefined : 1 };
+    },
+}, "Environment fix commands are local diagnostics, same reasoning as doctor.");
+// ---------------------------------------------------------------------

package/dist/wiring/capability-table/index.js

@@ -0,0 +1,42 @@
+"use strict";
+// wiring/capability-table/index.ts — composes the capability table from
+// registry-core (the shared machinery) plus every domain slice, in the
+// EXACT original source order (REGISTRY array order is a pinned
+// behavior: tools/list order, gen-parity-doc's byte-diff gate, cw help
+// line order). Each slice is a plain module whose top-level
+// attachCliBinding/addCliOnlyCapability/REGISTRY_BY_CAPABILITY calls run
+// once, at first import — Node's module system guarantees that happens
+// in exactly the order these imports are written below, the same
+// guarantee the single original file relied on for its own top-to-bottom
+// statement order.
+//
+// No slice imports another slice; every slice imports only from
+// registry-core.ts, core/capability-data.ts, and shell/core as needed —
+// so this file is the only place the full domain list is assembled, and
+// there is no cross-slice circular dependency to reason about.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./registry-core"), exports);
+require("./basics");
+require("./state");
+require("./exec-backend");
+require("./pipeline");
+require("./trust-ledger");
+require("./multi-agent");
+require("./scheduling-registry");
+require("./reporting");
+require("./workflow-apps");
+__exportStar(require("./parity"), exports);