cool-workflow 0.2.0 → 0.2.2

package/dist/shell/scheduling-io.js

@@ -3,7 +3,7 @@
 // lease-plan mechanism over the run-registry-io.ts queue store, plus the
 // policy file IO.
 //
-// MILESTONE 10 (v2/PLAN.md build order, step 10). Byte-exact port of the
+// MILESTONE 10 (docs/rebuild/PLAN.md build order, step 10). Byte-exact port of the
 // old build's src/scheduling.ts + the sched-specific slice of
 // src/capability-core.ts. `sched` is a DIFFERENT system from `schedule`
 // (see scheduler-io.ts's file header) — this operates on
@@ -251,43 +251,53 @@ function schedLeaseCli(options = {}) {
     const now = nowIso(options);
     const policy = loadSchedulingPolicy(registry).policy;
     const limit = options.limit === undefined ? undefined : Number(options.limit);
-    const { entries, leases } = applyLease(registry.loadQueueEntries(), policy, now, limit);
-    registry.saveQueueEntries(entries);
-    return { schemaVersion: 1, now, granted: leases.length, leases };
+    return (0, fs_atomic_1.withFileLock)(registry.queueFilePath(), () => {
+        const { entries, leases } = applyLease(registry.loadQueueEntries(), policy, now, limit);
+        registry.saveQueueEntries(entries);
+        return { schemaVersion: 1, now, granted: leases.length, leases };
+    });
 }
 function schedReleaseCli(leaseId, options = {}) {
     const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
     const now = nowIso(options);
     const failed = isTrue(options.failed);
     const reason = typeof options.reason === "string" ? options.reason : undefined;
-    const { entries, matched } = leaseRelease(registry.loadQueueEntries(), leaseId, loadSchedulingPolicy(registry).policy, now, { failed, reason });
-    if (!matched)
-        throw new Error(`No active lease to release: ${leaseId}`);
-    registry.saveQueueEntries(entries);
-    return { schemaVersion: 1, released: leaseId, failed };
+    return (0, fs_atomic_1.withFileLock)(registry.queueFilePath(), () => {
+        const { entries, matched } = leaseRelease(registry.loadQueueEntries(), leaseId, loadSchedulingPolicy(registry).policy, now, { failed, reason });
+        if (!matched)
+            throw new Error(`No active lease to release: ${leaseId}`);
+        registry.saveQueueEntries(entries);
+        return { schemaVersion: 1, released: leaseId, failed };
+    });
 }
 function schedCompleteCli(leaseId, options = {}) {
     const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
-    const { entries, matched } = leaseComplete(registry.loadQueueEntries(), leaseId, nowIso(options));
-    if (!matched)
-        throw new Error(`No active lease to complete: ${leaseId}`);
-    registry.saveQueueEntries(entries);
-    return { schemaVersion: 1, completed: leaseId };
+    return (0, fs_atomic_1.withFileLock)(registry.queueFilePath(), () => {
+        const { entries, matched } = leaseComplete(registry.loadQueueEntries(), leaseId, nowIso(options));
+        if (!matched)
+            throw new Error(`No active lease to complete: ${leaseId}`);
+        registry.saveQueueEntries(entries);
+        return { schemaVersion: 1, completed: leaseId };
+    });
 }
 function schedReclaimCli(options = {}) {
     const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
     const now = nowIso(options);
-    const { entries, reclaimed } = reclaimExpired(registry.loadQueueEntries(), loadSchedulingPolicy(registry).policy, now);
-    registry.saveQueueEntries(entries);
-    return { schemaVersion: 1, now, reclaimed };
+    return (0, fs_atomic_1.withFileLock)(registry.queueFilePath(), () => {
+        const { entries, reclaimed } = reclaimExpired(registry.loadQueueEntries(), loadSchedulingPolicy(registry).policy, now);
+        registry.saveQueueEntries(entries);
+        return { schemaVersion: 1, now, reclaimed };
+    });
 }
 function schedResetCli(id, options = {}) {
     const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));
-    const { entries, matched } = resetEntry(registry.loadQueueEntries(), id);
-    if (!matched)
-        throw new Error(`No parked entry to reset: ${id}`);
-    registry.saveQueueEntries(entries);
-    return { schemaVersion: 1, reset: id };
+    return (0, fs_atomic_1.withFileLock)(registry.queueFilePath(), () => {
+        const { entries, matched } = resetEntry(registry.loadQueueEntries(), id);
+        if (!matched)
+            throw new Error(`No parked entry to reset: ${id}`);
+        registry.saveQueueEntries(entries);
+        return { schemaVersion: 1, reset: id };
+    });
 }
 function schedPolicyShowCli(options = {}) {
     const registry = new run_registry_io_1.RunRegistry(resolveCwd(options));

package/dist/shell/state-explosion-cli.js

@@ -66,6 +66,7 @@ const report_1 = require("../core/state/state-explosion/report");
 Object.defineProperty(exports, "buildStateExplosionReport", { enumerable: true, get: function () { return report_1.buildStateExplosionReport; } });
 const size_2 = require("../core/state/state-explosion/size");
 const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
+const collate_1 = require("../core/util/collate");
 function summariesDir(run) {
     return path.join(run.paths.runDir, "summaries");
 }
@@ -134,7 +135,7 @@ function refreshStateExplosionSummaries(run, options = {}) {
         status: "valid",
         deterministic: true,
         nextAction: `node scripts/cw.js summary show ${run.id}`,
-        entries: entries.sort((a, b) => a.id.localeCompare(b.id)),
+        entries: entries.sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id)),
         views,
         paths: { summariesDir: dir, indexPath: path.join(dir, "index.json"), reportPath },
     };

package/dist/shell/telemetry-ledger-io.js

@@ -4,7 +4,7 @@
 // math lives in core/trust/telemetry-ledger.ts.
 //
 // MILESTONE 8. Byte-exact port of the old build's src/telemetry-ledger.ts
-// IO-touching half. CRITICAL invariant (v2/PLAN.md byte-compat item 12):
+// IO-touching half. CRITICAL invariant (docs/rebuild/PLAN.md byte-compat item 12):
 // an ABSENT telemetry.json is an empty, clean-verifying chain
 // (`present:false`); a PRESENT but unparseable one is CORRUPT — reads
 // report `telemetry-ledger-corrupt`, and append THROWS

package/dist/shell/term.js

@@ -1,7 +1,7 @@
 "use strict";
 // shell/term.ts — zero-dependency terminal styling.
 //
-// MILESTONE 5 (v2/PLAN.md build order, step 5, doctor/fix): TTY-gated
+// MILESTONE 5 (docs/rebuild/PLAN.md build order, step 5, doctor/fix): TTY-gated
 // ANSI formatting, so a piped run (every conformance case pipes with
 // NO_COLOR=1) prints plain text. EXTENDED at MILESTONE 11 (reporting/
 // observability) with the rest of the old build's src/term.ts: indent,

package/dist/shell/topology-io.js

@@ -63,6 +63,7 @@ const hash_2 = require("../core/hash");
 const topo = __importStar(require("../core/multi-agent/topology"));
 const multi_agent_io_1 = require("./multi-agent-io");
 const coordinator_io_1 = require("./coordinator-io");
+const collate_1 = require("../core/util/collate");
 function topologyRoot(run) {
     return run.paths.topologiesDir || path.join(run.paths.runDir, "topologies");
 }
@@ -307,7 +308,7 @@ function buildTopologyGraph(run) {
     return topo.buildTopologyGraphFromRuns(run.id, state.runs, (id) => topologyRunPath(run, id));
 }
 function formatTopologyCounts(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/trust-audit.js

@@ -13,7 +13,7 @@
 // the era-rule check + trustAuditGenesis on top, and switches
 // computeEventHash to use core/hash.ts's named `eventHashInput` export
 // (byte-identical behavior to the pre-existing inline JSON-round-trip,
-// now shared with the rest of the hash-dedup story per v2/PLAN.md byte-
+// now shared with the rest of the hash-dedup story per docs/rebuild/PLAN.md byte-
 // compat item 2).
 //
 // Evidence: SPEC/ledger-trust.md "Trust-audit chain", invariant 10 (era
@@ -58,6 +58,7 @@ exports.TRUST_AUDIT_SCHEMA_VERSION = void 0;
 exports.ensureTrustAudit = ensureTrustAudit;
 exports.trustAuditGenesis = trustAuditGenesis;
 exports.listTrustAuditEvents = listTrustAuditEvents;
+exports.trustAuditHead = trustAuditHead;
 exports.verifyTrustAudit = verifyTrustAudit;
 exports.recordTrustAuditEvent = recordTrustAuditEvent;
 exports.recordSandboxPathDecision = recordSandboxPathDecision;
@@ -97,7 +98,7 @@ function trustAuditGenesis(runId) {
  *  itself, via core/hash.ts's `eventHashInput` (the JSON round-trip
  *  pre-pass that drops nested `undefined`-valued keys BEFORE the
  *  sort-and-stringify step — not a formatting flag on the same shape,
- *  see v2/PLAN.md byte-compat item 2). Hashing the PERSISTED form this
+ *  see docs/rebuild/PLAN.md byte-compat item 2). Hashing the PERSISTED form this
  *  way makes record-time hashes equal verify-time (parsed-from-disk)
  *  hashes. */
 function computeEventHash(event) {
@@ -136,19 +137,40 @@ function readEventsRaw(eventLogPath) {
 function listTrustAuditEvents(run) {
     return readEventsRaw(ensureTrustAudit(run).eventLogPath);
 }
+/** The current head of a run's trust-audit chain: the hash the NEXT
+ *  appended event will link from (genesis when the log is empty), plus
+ *  the event count. Read-only projection over existing data. Capture it
+ *  (e.g. right after a run, or at export time) and later hand it to
+ *  `verifyTrustAudit`'s anchor / `cw audit verify --expect-head` to
+ *  re-prove the log was not shortened since the capture. */
+function trustAuditHead(run) {
+    const audit = ensureTrustAudit(run);
+    const events = readEventsRaw(audit.eventLogPath);
+    let head = trustAuditGenesis(run.id);
+    for (const event of events) {
+        head = event.eventHash !== undefined ? event.eventHash : computeEventHash(event);
+    }
+    return { eventCount: events.length, headHash: head };
+}
 /** Re-prove the run's trust-audit chain: prevEventHash linkage (append
  *  order) + per-event hash recompute. A corrupt line, an edited event,
  *  or a removed event flips verified=false. Legacy events without a
  *  hash are reported as `unchained` (skipped), NOT treated as a forgery
  *  — they predate the chain.
  *
- *  ERA RULE (v2/PLAN.md, SPEC/ledger-trust.md invariant 10): a single
+ *  ERA RULE (docs/rebuild/PLAN.md, SPEC/ledger-trust.md invariant 10): a single
  *  run is written by one code version, so a log is all-chained (chain
  *  era) or all-legacy (pre-chain). An unchained (eventHash-less) line
  *  mixed into an otherwise-chained log is a forgery attempt — dropping
  *  the hash to be waved through as "legacy" — so it fails with
- *  `trust-audit-unchained-event`, never silently accepted. */
-function verifyTrustAudit(run) {
+ *  `trust-audit-unchained-event`, never silently accepted.
+ *
+ *  ANCHOR (optional): the walk alone cannot see tail truncation — see
+ *  TrustAuditAnchor. With an anchor, the head-hash trail (genesis plus
+ *  the hash after each event) must contain `expectHead`, and the log
+ *  must reach `expectCount` events; a shortfall fails closed with
+ *  `trust-audit-truncated`. Without an anchor, behavior is unchanged. */
+function verifyTrustAudit(run, anchor) {
     const audit = ensureTrustAudit(run);
     const { events, corruptLines } = readEventsRawCounted(audit.eventLogPath);
     const checks = [];
@@ -158,12 +180,14 @@ function verifyTrustAudit(run) {
     let chained = 0;
     let unchained = 0;
     let expectedPrev = trustAuditGenesis(run.id);
+    const headTrail = new Set([expectedPrev]);
     for (let i = 0; i < events.length; i++) {
         const event = events[i];
         const recomputed = computeEventHash(event);
         if (event.eventHash === undefined) {
             unchained += 1;
             expectedPrev = recomputed; // advance the chain over legacy events
+            headTrail.add(expectedPrev);
             continue;
         }
         chained += 1;
@@ -176,12 +200,27 @@ function verifyTrustAudit(run) {
             checks.push({ name: `chain-link[${i}]`, pass: false, code: "trust-audit-chain-broken" });
         }
         expectedPrev = event.eventHash;
+        headTrail.add(expectedPrev);
     }
     // Era rule: a log with ANY chained event must have EVERY event chained.
     if (chained > 0 && unchained > 0) {
         verified = false;
         checks.push({ name: "unchained-events", pass: false, code: "trust-audit-unchained-event" });
     }
+    // Anchor rule: the captured head must still be ON the chain, and the log
+    // must be at least as long as it was at capture time. A truncated-then-
+    // appended log fails the head check (new events link from an earlier
+    // point, so the old head is no longer in the trail).
+    if (anchor) {
+        if (anchor.expectCount !== undefined && events.length < anchor.expectCount) {
+            verified = false;
+            checks.push({ name: "anchor-count", pass: false, code: "trust-audit-truncated" });
+        }
+        if (anchor.expectHead !== undefined && !headTrail.has(anchor.expectHead)) {
+            verified = false;
+            checks.push({ name: "anchor-head", pass: false, code: "trust-audit-truncated" });
+        }
+    }
     return { present: events.length > 0, verified, eventCount: events.length, chained, unchained, corruptLines, checks };
 }
 function unique(values) {
@@ -277,6 +316,7 @@ function recordTrustAuditEvent(run, input) {
         normalizedPath: input.normalizedPath ? path.resolve(input.normalizedPath) : undefined,
         command: input.command,
         networkTarget: input.networkTarget,
+        envVars: input.envVars?.filter(Boolean).sort(),
         evidence: normalizeEvidence(run, input.evidence || [], { source: input.source, workerId: input.workerId, taskId: input.taskId, resultNodeId: input.nodeId }),
         evidenceRefs: unique(input.evidenceRefs || []).sort(),
         parentEventIds: unique(input.parentEventIds || []).sort(),

package/dist/shell/workbench-host.js

@@ -233,8 +233,16 @@ class WorkbenchHost {
     /** `cw workbench serve` entry point: `--once`/`--json` prints ONLY the
      *  descriptor (compact JSON) and starts nothing; the default binds and
      *  blocks, printing one compact line (`{...descriptor, boundPort}`)
-     *  once listening. */
+     *  once listening. `--require-token` is a strict opt-in: default behavior
+     *  (unauthenticated local reads when no token is configured) is
+     *  unchanged unless the caller explicitly asks to fail closed. */
     async run() {
+        const requireToken = Boolean(this.args.requireToken || this.args["require-token"]);
+        if (requireToken && !this.token) {
+            process.stderr.write("workbench serve --require-token: CW_WORKBENCH_TOKEN is not set; refusing to start.\n");
+            process.exitCode = 1;
+            return;
+        }
         const once = Boolean(this.args.once || this.args.json);
         if (once) {
             process.stdout.write(`${JSON.stringify(this.descriptor(true))}\n`);

package/dist/shell/workbench.js

@@ -116,18 +116,13 @@ function buildWorkbenchRunView(runId, args = {}) {
     }
     return { schemaVersion: 1, surface: "workbench", runId, resolved, ...(resolveError ? { error: resolveError } : {}), panels };
 }
+/** Package-relative resolution only — never falls back to the invocation
+ *  cwd. `ui/` ships as a sibling of `dist/` in the published package
+ *  (package.json's `files`), so from `dist/shell/workbench.js` the fixed
+ *  path is two levels up. Matches the existing precedent in
+ *  execution-backend/agent.ts's BATCH_DELEGATE_CHILD_SCRIPT resolution. */
 function workbenchUiRoot() {
-    let dir = __dirname;
-    for (let i = 0; i < 8; i++) {
-        const candidate = path.join(dir, "plugins", "cool-workflow", exports.WORKBENCH_UI_RELATIVE);
-        if (require("node:fs").existsSync(candidate))
-            return candidate;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return path.join(process.cwd(), exports.WORKBENCH_UI_RELATIVE);
+    return path.resolve(__dirname, "..", "..", exports.WORKBENCH_UI_RELATIVE);
 }
 const WORKBENCH_ROUTES = [
     { method: "GET", path: "/", description: "Index page (or the UI's index.html, when installed)." },

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 });
@@ -92,7 +97,10 @@ function workerManifestCli(args) {
  *  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"), {});
+    (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);

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,66 @@
+"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 workflow_app_loader_1 = require("../../shell/workflow-app-loader");
+const help_1 = require("../../core/format/help");
+(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 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). `hiddenFromHelp` keeps it
+ *  out of the per-verb help listing exactly as before (it never had one —
+ *  `search` only ever appeared in formatHelp's hard-coded "More commands"
+ *  index line, which this row does not touch), so `cw help search` keeps
+ *  its existing "Unknown command: search" text. */
+(0, registry_core_1.addCliOnlyCapability)("search", "Search bundled workflows by id/title/summary keyword.", {
+    path: ["search"],
+    jsonMode: "flag",
+    hiddenFromHelp: true,
+    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 = (0, workflow_app_loader_1.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)() }),
+});