cool-workflow 0.2.1 → 0.2.3

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

@@ -0,0 +1,292 @@
+"use strict";
+// wiring/capability-table/pipeline.ts — MILESTONE 6+7 (plan, run.drive*,
+// dispatch, result, commit, commit.summary) + MILESTONE 11's run.export/
+// import/verify-import/inspect-archive/restore CLI bindings. 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");
+const io_1 = require("../../cli/io");
+const io_2 = require("../../cli/io");
+// MILESTONE 6+7 (combined; see docs/rebuild/PLAN.md Open risk 10) CLI bindings:
+// plan, quickstart, run --drive, run drive (preview), dispatch, result,
+// commit. Handler BODIES live in shell/pipeline-cli.ts (impure — they
+// plan/drive/dispatch/commit real run state on disk); this table only
+// wires argv shape -> handler call, per cli/dispatch.ts's generic
+// executor contract.
+// ---------------------------------------------------------------------
+// This file is required unconditionally at startup for every command, so
+// a top-level import of pipeline-cli/commit-summary would cost every
+// invocation, not just plan/run/dispatch/result/commit/commit.summary ones.
+function loadPipelineCli() {
+    return require("../../shell/pipeline-cli");
+}
+function loadCommitSummary() {
+    return require("../../shell/commit-summary");
+}
+(0, registry_core_1.attachCliBinding)("plan", {
+    path: ["plan"],
+    jsonMode: "default",
+    handler: (args) => {
+        const workflowId = (0, io_2.optionalArg)(args.positionals[0]);
+        if (!workflowId) {
+            throw new Error('Missing workflow id.\n  Tip: plan an architecture review with "cw plan architecture-review"');
+        }
+        return { json: loadPipelineCli().planRun({ ...args.options, workflowId }) };
+    },
+});
+// `cw run <app> --drive [--once]` and `cw run drive <run-id> [--step]`
+// share the single `run` dispatch path (byte-exact to the old build's
+// handleRun: a run-REGISTRY subcommand keyword is never hijacked by the
+// bare `--drive` intercept just because it carries its own --drive/--step
+// flag). Both rows below dispatch on `["run"]`; the FIRST one registered
+// (run.drive.step) is found first by findCapabilityByCliPath's linear
+// scan, so its handler carries the full branch — the second row exists
+// only so `cw help run` lists both capabilities.
+(0, registry_core_1.attachCliBinding)("run.drive.step", {
+    path: ["run"],
+    helpPath: ["run", "drive"],
+    jsonMode: "default",
+    handler: async (args) => {
+        const registrySubcommands = new Set(["drive", "search", "list", "show", "resume", "archive", "rerun", "export", "import", "verify-import", "inspect-archive", "restore"]);
+        const target = args.positionals[0];
+        if (args.options.drive && !registrySubcommands.has(String(target || ""))) {
+            const runId = (0, io_2.optionalArg)(args.options.run) || (0, io_2.optionalArg)(args.options.runId);
+            if (args.options.preview)
+                return { json: loadPipelineCli().runDrivePreview({ ...args.options, runId: runId || target }) };
+            const driveArgs = { ...args.options };
+            if (runId)
+                driveArgs.runId = runId;
+            else
+                driveArgs.appId = target;
+            return { json: await loadPipelineCli().runDriveStep(driveArgs) };
+        }
+        const [subcommand, id] = args.positionals;
+        if (subcommand === "drive") {
+            if (args.options.step) {
+                const driveArgs = { ...args.options };
+                if (id)
+                    driveArgs.runId = id;
+                return { json: await loadPipelineCli().runDriveStep(driveArgs) };
+            }
+            return { json: loadPipelineCli().runDrivePreview({ ...args.options, runId: (0, io_1.required)(id, "run id") }) };
+        }
+        // MILESTONE 11 (reporting/run-export) — the archive family. Handler
+        // bodies live in shell/run-export-cli.ts; this arm only wires argv
+        // shape -> handler call.
+        if (subcommand === "export") {
+            const result = loadRunExportCli().runExportCli((0, io_1.required)(id, "run id"), args.options);
+            return { json: result };
+        }
+        if (subcommand === "import") {
+            const result = loadRunExportCli().runImportCli((0, io_1.required)(id, "archive path"), args.options);
+            return { json: result };
+        }
+        if (subcommand === "verify-import") {
+            const result = loadRunExportCli().runVerifyImportCli((0, io_1.required)(id, "run id"), args.options);
+            return { json: result, exitCode: args.options.strict && !result.ok ? 1 : undefined };
+        }
+        if (subcommand === "inspect-archive") {
+            const result = loadRunExportCli().runInspectArchiveCli((0, io_1.required)(id, "archive path"), args.options);
+            return { json: result, exitCode: result.ok ? undefined : 1 };
+        }
+        if (subcommand === "restore") {
+            const result = loadRunExportCli().runRestoreCli((0, io_1.required)(id, "archive path"), args.options);
+            return { json: result, exitCode: result.ok ? undefined : 1 };
+        }
+        throw new Error("Usage: cw run search|list|show|resume|archive|rerun|drive|export|import|verify-import|inspect-archive|restore [run-id|archive] [--scope repo|home] [--json]  |  cw run <app> --drive [--once] [--incremental] [--repo R --question Q]");
+    },
+});
+// PARITY: `run.drive` (the read-only MCP preview tool) now ALSO carries
+// its own two-token `cli.path` ["run","drive"], same as the old build's
+// registry row (cli.path ["run","drive"]) and the same reversed-
+// candidate-order pattern already used for run.search/run.list/etc.
+// (see those rows' own comment below): findCapabilityByCliPath tries the
+// 2-token candidate BEFORE the 1-token ["run"] row, so this row — not
+// run.drive.step's combined switch — now serves `cw run drive <run-id>`
+// [--step]. Behavior is unchanged (same runDrivePreview/runDriveStep
+// calls, same --step branch run.drive.step's switch already used); only
+// WHICH row answers the dispatch changes, so run.drive becomes a real
+// both-surface, dual-bound capability for the payload-identity probe.
+(0, registry_core_1.attachCliBinding)("run.drive", {
+    path: ["run", "drive"],
+    jsonMode: "default",
+    handler: async (args) => {
+        const id = args.positionals[0];
+        if (args.options.step) {
+            const driveArgs = { ...args.options };
+            if (id)
+                driveArgs.runId = id;
+            return { json: await loadPipelineCli().runDriveStep(driveArgs) };
+        }
+        return { json: loadPipelineCli().runDrivePreview({ ...args.options, runId: (0, io_1.required)(id, "run id") }) };
+    },
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.drive").mcp.handler = (args) => loadPipelineCli().runDrivePreview(args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.drive.step").mcp.handler = (args) => loadPipelineCli().runDriveStep(args);
+// PARITY: `run.drive.step` advances the run by spawning the external
+// agent per worker and recording attested output — not a read probe.
+// CLI (--drive/--step) and MCP route through the same drive() core; the
+// opt-out is the documented divergence, not undocumented drift.
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.drive.step").payloadIdentical = false;
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.drive.step").reason =
+    "Mutating: advances the run by spawning the external agent per worker and recording attested output — not a read probe. CLI (--drive/--step) and MCP route through the same drive() core.";
+registry_core_1.REGISTRY_BY_CAPABILITY.get("plan").mcp.handler = (args) => loadPipelineCli().planRun(args);
+// GAP #24: dispatchRun reads the sandbox profile from `args.sandbox` only
+// (the CLI's --sandbox flag). The cw_dispatch MCP tool also accepts the
+// `sandboxProfile`/`sandboxProfileId` aliases (its declared properties), so
+// normalize them onto `sandbox` here — mirrors the old build's
+// sandboxProfileIdFrom() alias set — before handing off.
+registry_core_1.REGISTRY_BY_CAPABILITY.get("dispatch").mcp.handler = (args) => loadPipelineCli().dispatchRun({ ...args, sandbox: args.sandbox ?? args.sandboxProfile ?? args.sandboxProfileId });
+registry_core_1.REGISTRY_BY_CAPABILITY.get("result").mcp.handler = (args) => loadPipelineCli().recordResultRun(args);
+// `cw_commit` returns the FLAT commit envelope (verifierGated/checkpoint/
+// selectionId/… at the top level, plus a nested `commit`), matching the old
+// build's commitEnvelope. `commitRun` (CLI shape) returns `{ runId, commit }`;
+// lift the commit's key fields to the top for the MCP surface.
+registry_core_1.REGISTRY_BY_CAPABILITY.get("commit").mcp.handler = (args) => {
+    const result = loadPipelineCli().commitRun(args);
+    const commit = result.commit || {};
+    return {
+        runId: result.runId,
+        commitId: commit.id,
+        verifierGated: commit.verifierGated,
+        checkpoint: commit.checkpoint,
+        verifierNodeId: commit.verifierNodeId,
+        candidateId: commit.candidateId,
+        selectionId: commit.selectionId,
+        evidenceCount: Array.isArray(commit.evidence) ? commit.evidence.length : 0,
+        snapshotPath: commit.snapshotPath,
+        commit,
+    };
+};
+// PARITY: `commit` is the one declared payload projection (byte-compat
+// item 5 above). Both surfaces route through the single core entry
+// runner.commit (commitRun); the CLI keeps the raw StateCommitResult for
+// scripting while cw_commit lifts an operator-facing envelope on top (see
+// the mcp.handler just above). Marked here, not silently let drift, so
+// the parity payload probe (core/capability-table.ts's
+// payloadIdenticalCapabilities) skips it with a paper trail instead of
+// tripping on an undocumented divergence.
+registry_core_1.REGISTRY_BY_CAPABILITY.get("commit").payloadIdentical = false;
+registry_core_1.REGISTRY_BY_CAPABILITY.get("commit").reason =
+    "Both surfaces route through the single core entry runner.commit. The CLI emits the raw StateCommitResult for scripting (commit.id, commit.evidence, commit.gate); cw_commit emits the operator commit envelope (commitId, verifierGated, checkpoint, evidenceCount, snapshotPath, nextActions, plus the raw result under `commit`). Declared projection, not drift.";
+// MILESTONE 11 — run.export/import/verify-import/inspect-archive/restore
+// MCP handlers (the CLI side is served by run.drive.step's combined
+// handler above; these tools are called directly by name over MCP, so
+// each needs its own mcp.handler per byte-compat item 5's two-field
+// row shape).
+// Same lazy-load reasoning as loadPipelineCli/loadCommitSummary above, for
+// the run.export/import/verify-import/inspect-archive/restore family.
+function loadRunExportCli() {
+    return require("../../shell/run-export-cli");
+}
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.export").mcp.handler = (args) => loadRunExportCli().runExportCli((0, io_1.required)((0, io_2.optionalArg)(args.runId), "run id"), args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.import").mcp.handler = (args) => loadRunExportCli().runImportCli((0, io_1.required)((0, io_2.optionalArg)(args.archive || args.path || args.file), "archive path"), args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.verify-import").mcp.handler = (args) => loadRunExportCli().runVerifyImportCli((0, io_1.required)((0, io_2.optionalArg)(args.runId), "run id"), args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.inspect-archive").mcp.handler = (args) => loadRunExportCli().runInspectArchiveCli((0, io_1.required)((0, io_2.optionalArg)(args.archive || args.path || args.file), "archive path"), args);
+registry_core_1.REGISTRY_BY_CAPABILITY.get("run.restore").mcp.handler = (args) => loadRunExportCli().runRestoreCli((0, io_1.required)((0, io_2.optionalArg)(args.archive || args.path || args.file), "archive path"), args);
+// `run export|import|verify-import|inspect-archive|restore` each carry their
+// own two-token cli.path (found before the ["run"] run.drive.step catch-all
+// per the reversed candidate order), calling the same shell fns with the
+// same [subcommand, id] positional mapping and exit-code shape the catch-all
+// switch already used. `hiddenFromHelp` keeps the byte-pinned `cw help run`
+// fixture's rows coming from the single literal COMMAND_HELP_ROWS.run block.
+(0, registry_core_1.attachCliBinding)("run.export", {
+    path: ["run", "export"],
+    jsonMode: "default",
+    hiddenFromHelp: true,
+    handler: (args) => ({ json: loadRunExportCli().runExportCli((0, io_1.required)(args.positionals[0], "run id"), args.options) }),
+});
+(0, registry_core_1.attachCliBinding)("run.import", {
+    path: ["run", "import"],
+    jsonMode: "default",
+    hiddenFromHelp: true,
+    handler: (args) => ({ json: loadRunExportCli().runImportCli((0, io_1.required)(args.positionals[0], "archive path"), args.options) }),
+});
+(0, registry_core_1.attachCliBinding)("run.verify-import", {
+    path: ["run", "verify-import"],
+    jsonMode: "default",
+    hiddenFromHelp: true,
+    handler: (args) => {
+        const result = loadRunExportCli().runVerifyImportCli((0, io_1.required)(args.positionals[0], "run id"), args.options);
+        return { json: result, exitCode: args.options.strict && !result.ok ? 1 : undefined };
+    },
+});
+(0, registry_core_1.attachCliBinding)("run.inspect-archive", {
+    path: ["run", "inspect-archive"],
+    jsonMode: "default",
+    hiddenFromHelp: true,
+    handler: (args) => {
+        const result = loadRunExportCli().runInspectArchiveCli((0, io_1.required)(args.positionals[0], "archive path"), args.options);
+        return { json: result, exitCode: result.ok ? undefined : 1 };
+    },
+});
+(0, registry_core_1.attachCliBinding)("run.restore", {
+    path: ["run", "restore"],
+    jsonMode: "default",
+    hiddenFromHelp: true,
+    handler: (args) => {
+        const result = loadRunExportCli().runRestoreCli((0, io_1.required)(args.positionals[0], "archive path"), args.options);
+        return { json: result, exitCode: result.ok ? undefined : 1 };
+    },
+});
+(0, registry_core_1.addCliOnlyCapability)("quickstart", "ONE-COMMAND quickstart: --check preflights without writes; otherwise plan(app, default architecture-review) -> run --drive -> report in a single invocation (--preview for a read-only dry run; --bundle [--with-trust-key K] seals a completed run into a self-verified portable bundle).", {
+    path: ["quickstart"],
+    // `audit-run` is a CLI-only alias that dispatches to the same quickstart
+    // wrapper (byte-behavior port of the old build's caseTokens).
+    caseTokens: ["quickstart", "audit-run"],
+    jsonMode: "default",
+    handler: async (args) => {
+        const appId = (0, io_2.optionalArg)(args.positionals[0]);
+        const result = (await loadPipelineCli().quickstartRun({ ...args.options, appId }));
+        // Fail closed on both known bad outcomes: a --check preflight that
+        // found a blocking gap, OR a --bundle that did not self-verify.
+        const bundle = result.bundle;
+        const bundleFailed = Boolean(bundle && bundle.ok === false);
+        const exitCode = (result.mode === "check" && result.ok === false) || bundleFailed ? 1 : undefined;
+        return { json: result, exitCode };
+    },
+}, "quickstart composes plan/runDrive/report; SPEC/mcp.md's declared cli-only list names it explicitly (no MCP peer). `audit-run` is a CLI-only alias of the same wrapper.", "quickstart");
+(0, registry_core_1.attachCliBinding)("dispatch", {
+    path: ["dispatch"],
+    jsonMode: "default",
+    handler: (args) => {
+        const runId = (0, io_1.required)((0, io_2.optionalArg)(args.positionals[0]), "run id");
+        return { json: loadPipelineCli().dispatchRun({ ...args.options, runId }) };
+    },
+});
+(0, registry_core_1.attachCliBinding)("result", {
+    path: ["result"],
+    jsonMode: "default",
+    handler: (args) => {
+        const runId = (0, io_1.required)((0, io_2.optionalArg)(args.positionals[0]), "run id");
+        const taskId = (0, io_1.required)((0, io_2.optionalArg)(args.positionals[1]), "task id");
+        const resultPath = (0, io_1.required)((0, io_2.optionalArg)(args.positionals[2]), "result file path");
+        return { json: loadPipelineCli().recordResultRun({ ...args.options, runId, taskId, resultPath }) };
+    },
+});
+(0, registry_core_1.attachCliBinding)("commit", {
+    path: ["commit"],
+    jsonMode: "default",
+    handler: (args) => {
+        const runId = (0, io_1.required)((0, io_2.optionalArg)(args.positionals[0]), "run id");
+        return { json: loadPipelineCli().commitRun({ ...args.options, runId }) };
+    },
+});
+// GAP #26: restore `cw commit summary <run-id>` (CLI + help row). The old
+// build had commit.summary with cli path ["commit","summary"] surface "both"
+// (capability-registry.ts:260-266); v2 kept only the cw_commit_summary MCP
+// tool and dropped both the CLI binding and the COMMAND_HELP_ROWS entry, so
+// `cw commit summary` mis-read "summary" as the run id. Path ["commit","summary"]
+// is 2 tokens; dispatch consumes 1, so positionals[0] is the run id.
+(0, registry_core_1.attachCliBinding)("commit.summary", {
+    path: ["commit", "summary"],
+    jsonMode: "flag",
+    handler: (args) => {
+        const commitSummary = loadCommitSummary();
+        const summary = commitSummary.commitSummaryCli({ ...args.options, runId: (0, io_1.required)(args.positionals[0], "run id") });
+        return { json: summary, text: `${commitSummary.formatCommitSummaryText(summary)}\n` };
+    },
+});
+registry_core_1.REGISTRY_BY_CAPABILITY.get("commit.summary").mcp.handler = (args) => loadCommitSummary().commitSummaryCli(args);
+// ---------------------------------------------------------------------

package/dist/wiring/capability-table/registry-core.js

@@ -0,0 +1,208 @@
+"use strict";
+// wiring/capability-table/registry-core.ts — the shared machinery every
+// domain slice registers into: REGISTRY, REGISTRY_BY_CAPABILITY,
+// attachCliBinding, addCliOnlyCapability, and the read-only query
+// functions (findCapability*, cliCapabilities, mcpToolDefinitions,
+// declaredMcpTools). Also owns the small set of capability BODIES that
+// must be in scope when MCP_TOOL_DATA.map() builds REGISTRY at module
+// load (MCP_REAL_HANDLERS below) — kept here, not in a domain slice, to
+// avoid a circular import (a slice needing attachCliBinding from this
+// file, while this file would need a handler body FROM that slice).
+//
+// No slice file imports another slice file; every slice imports ONLY
+// from this file, core/capability-data.ts, and shell/core as needed.
+// index.ts imports this file plus every slice and composes them in the
+// exact original source order (REGISTRY order is a pinned behavior —
+// tools/list order, gen-parity-doc's byte-diff gate, cw help line order).
+//
+// Split out of core/capability-table.ts's "Public table-derived API"
+// section, byte-for-byte (this file's body is the ORIGINAL file's own
+// text, extracted with sed line ranges, not retyped).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY_BY_CAPABILITY = exports.REGISTRY = void 0;
+exports.listBundledWorkflows = listBundledWorkflows;
+exports.listBundledSandboxProfiles = listBundledSandboxProfiles;
+exports.statusPayload = statusPayload;
+exports.attachCliBinding = attachCliBinding;
+exports.addCliOnlyCapability = addCliOnlyCapability;
+exports.findCapability = findCapability;
+exports.findCapabilityByCliPath = findCapabilityByCliPath;
+exports.cliCapabilities = cliCapabilities;
+exports.mcpToolDefinitions = mcpToolDefinitions;
+exports.declaredMcpTools = declaredMcpTools;
+exports.findCapabilityByMcpTool = findCapabilityByMcpTool;
+const capability_data_1 = require("../../core/capability-data");
+const io_1 = require("../../cli/io");
+// Every capability-table module (this file plus each domain slice) is
+// required unconditionally at CLI/MCP startup, for every single command
+// (index.ts's whole point is to populate REGISTRY before dispatch can
+// look anything up) — so a top-level `import` of a shell module here
+// means EVERY invocation pays that module's full load cost, even the
+// 99% of commands that never touch `status`/`summary.refresh`/`list`.
+// Requiring these 4 lazily (inside the handler that actually uses them)
+// measured live: this file alone was ~30-45ms of a ~75-100ms `cw --version`
+// require chain, the single largest slice. The 8 domain slices have the
+// same shape and are a natural follow-up, not attempted here.
+function loadRunStore() {
+    return require("../../shell/run-store");
+}
+function loadOperatorUx() {
+    return require("../../shell/operator-ux");
+}
+function loadWorkflowAppLoader() {
+    return require("../../shell/workflow-app-loader");
+}
+function loadStateExplosionCli() {
+    return require("../../shell/state-explosion-cli");
+}
+/** Real handlers implemented at THIS milestone, keyed by capability id.
+ *  Every tool row not listed here gets `notYetImplemented`. Kept as a
+ *  small side table (rather than inlined into MCP_TOOL_DATA above) so the
+ *  196-row literal above stays a pure, mechanically-checkable transcript
+ *  of the spec table — handler wiring is a separate, obviously-later-
+ *  editable concern. */
+const MCP_REAL_HANDLERS = {
+    list: () => listBundledWorkflows(),
+    "sandbox.list": () => listBundledSandboxProfiles(),
+    status: (args) => statusPayload(optionalString(args.runId)),
+    "summary.refresh": (args) => loadStateExplosionCli().summaryRefreshCli((0, io_1.required)(optionalString(args.runId), "run id"), args),
+    "summary.show": (args) => loadStateExplosionCli().summaryShowCli((0, io_1.required)(optionalString(args.runId), "run id"), args),
+};
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+/** `cw list` / `cw_list` (MILESTONE 12) — the real discovery over every
+ *  `apps/*\/app.json` + legacy `workflows/*.workflow.js` on disk, per
+ *  `listWorkflowsShallow` (shell/workflow-app-loader.ts). */
+function listBundledWorkflows() {
+    return loadWorkflowAppLoader().listWorkflowsShallow();
+}
+/** PLACEHOLDER (milestone 5, execution-backend/sandbox) — the real
+ *  `sandbox.list` resolves and stamps each of the 4 bundled profiles
+ *  (default/readonly/workspace-write/locked-down) with real path lists
+ *  via `resolveSandboxProfile` (SPEC/execution-backend.md). This
+ *  milestone reproduces only the id/title/schemaVersion subset that
+ *  mcp-basic.case.js checks. */
+function listBundledSandboxProfiles() {
+    return [
+        { schemaVersion: 1, id: "default", title: "Default Worker Boundary" },
+        { schemaVersion: 1, id: "readonly", title: "Readonly Workspace" },
+        { schemaVersion: 1, id: "workspace-write", title: "Workspace Write" },
+        { schemaVersion: 1, id: "locked-down", title: "Locked Down" },
+    ];
+}
+/** `cw status` / `cw_status` — SPEC/cli-surface.md pins the no-id JSON
+ *  shape exactly (`{runId:null, nextActions}`); a real run id resolves to
+ *  `summarizeRun`'s payload (MILESTONE 11, reporting/observability). */
+function statusPayload(runId, cwd) {
+    const operatorUx = loadOperatorUx();
+    if (!runId) {
+        return { runId: null, nextActions: operatorUx.adviseNoRun() };
+    }
+    const run = loadRunStore().loadRunFromCwd(runId, cwd || process.cwd());
+    return operatorUx.summarizeRun(run);
+}
+// ---------------------------------------------------------------------
+// Public table-derived API
+// ---------------------------------------------------------------------
+function buildMcpBinding(row) {
+    const handler = MCP_REAL_HANDLERS[row.capability] ?? (0, capability_data_1.notYetImplemented)(row.capability);
+    // A transcript entry like "runId, workerId" is TWO AND-required args (the
+    // spec table's comma form), while "topicId|id" is one OR-group. mcp/dispatch's
+    // validator only splits on `|`, so expand each comma-joined transcript entry
+    // into its separate AND-groups here (the one place the row shape is turned
+    // into the runtime McpBinding.requiredArgs contract).
+    const requiredArgs = row.requiredArgs.flatMap((group) => group.split(",").map((entry) => entry.trim()).filter(Boolean));
+    return {
+        tool: row.tool,
+        requiredArgs: requiredArgs.length ? requiredArgs : undefined,
+        properties: row.properties,
+        description: row.description,
+        handler,
+    };
+}
+/** The full capability table: one row per MCP tool (196, per SPEC/mcp.md),
+ *  in the exact source order `tools/list` must report. CLI bindings are
+ *  layered on top for the small set of capabilities this milestone also
+ *  exposes on the CLI front door (see `CLI_ROWS` below); every other row
+ *  is MCP-only AT THIS MILESTONE (not a permanent `mcp-only` declaration —
+ *  just not yet CLI-wired; later milestones add the `cli` binding without
+ *  touching this array's mcp side). */
+exports.REGISTRY = capability_data_1.MCP_TOOL_DATA.map((row) => ({
+    capability: row.capability,
+    summary: row.description,
+    surface: "both",
+    mcp: buildMcpBinding(row),
+}));
+exports.REGISTRY_BY_CAPABILITY = new Map(exports.REGISTRY.map((row) => [row.capability, row]));
+/** Attach (or replace) a CLI binding for an already-declared MCP capability.
+ *  Used once below to wire `list`/`status`/`sandbox.list` onto the CLI
+ *  front door too, without duplicating their row data. */
+function attachCliBinding(capability, cli) {
+    const row = exports.REGISTRY_BY_CAPABILITY.get(capability);
+    if (!row)
+        throw new Error(`capability-table: cannot attach cli binding to undeclared capability ${capability}`);
+    row.cli = cli;
+}
+/** Declare a capability that is CLI-only at this milestone (`help`,
+ *  `version` — both are permanently `cli-only` per SPEC/mcp.md's
+ *  declared one-surface list, so no mcp row is created for them). */
+function addCliOnlyCapability(capability, summary, cli, reason, entry) {
+    const row = { capability, summary, surface: "cli-only", cli, reason, ...(entry ? { entry } : {}) };
+    exports.REGISTRY.push(row);
+    exports.REGISTRY_BY_CAPABILITY.set(capability, row);
+}
+/** Returns the declared row for a capability id, or undefined. */
+function findCapability(capability) {
+    return exports.REGISTRY_BY_CAPABILITY.get(capability);
+}
+/** Returns the declared row whose `cli.path` matches `path` exactly
+ *  (path[0] is the verb). Used by cli/dispatch.ts's generic executor.
+ *  A single-token command also matches a row's `caseTokens` alias list, so
+ *  an alias (e.g. `audit-run`) dispatches to the same handler as its verb. */
+function findCapabilityByCliPath(path) {
+    for (const row of exports.REGISTRY) {
+        if (row.cli && row.cli.path.length === path.length && row.cli.path.every((p, i) => p === path[i])) {
+            return row;
+        }
+    }
+    if (path.length === 1) {
+        for (const row of exports.REGISTRY) {
+            if (row.cli && row.cli.caseTokens && row.cli.caseTokens.includes(path[0]))
+                return row;
+        }
+    }
+    return undefined;
+}
+/** Every capability row that declares a `cli` binding, in registry order.
+ *  Used to derive `formatCommandHelp`'s per-verb subcommand rows. */
+function cliCapabilities() {
+    return exports.REGISTRY.filter((row) => Boolean(row.cli));
+}
+/** `tools/list`'s exact array, in the pinned source order. */
+function mcpToolDefinitions() {
+    const definitions = [];
+    for (const row of exports.REGISTRY) {
+        if (!row.mcp)
+            continue;
+        const overrides = capability_data_1.PROPERTY_OVERRIDES[row.mcp.tool] ?? {};
+        const properties = {};
+        for (const propName of row.mcp.properties) {
+            properties[propName] = overrides[propName] ?? (0, capability_data_1.stringProperty)(propName);
+        }
+        definitions.push({
+            name: row.mcp.tool,
+            description: row.mcp.description,
+            inputSchema: { type: "object", properties, additionalProperties: true },
+        });
+    }
+    return definitions;
+}
+/** Every declared MCP tool name, in `tools/list` order. */
+function declaredMcpTools() {
+    return exports.REGISTRY.filter((row) => row.mcp).map((row) => row.mcp.tool);
+}
+/** Look up a capability row by its MCP tool name. */
+function findCapabilityByMcpTool(tool) {
+    return exports.REGISTRY.find((row) => row.mcp && row.mcp.tool === tool);
+}