cool-workflow 0.1.83 → 0.1.85

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cool-workflow",
   "description": "A workflow control plane and run-time you are able to check: it sends out jobs in TypeScript, makes certain of work against facts before it goes through, puts state into fixed records, orders jobs by time, runs jobs again and again, gets a group of agents to do their parts together, and talks MCP. It gives the doing of the work to outside agents — it never runs the models itself.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": {
     "name": "COOLWHITE LLC"
   },

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cool-workflow",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "description": "A workflow control plane and run-time you are able to check: it sends out jobs in TypeScript, makes certain of work against facts before it goes through, puts state into fixed records, orders jobs by time, runs jobs again and again, gets a group of agents to do their parts together, and talks MCP. It gives the doing of the work to outside agents — it never runs the models itself.",
   "author": {
     "name": "COOLWHITE LLC"

package/README.md

@@ -706,3 +706,9 @@ _This documentation tracks Cool Workflow v0.1.82. See [CHANGELOG](../../CHANGELO
 ## Hardening and Onboarding (v0.1.83)
 
 Loaders fail closed on corrupt state; store writes are made safe under more than one writer; a new cw doctor checks your setup; help lists every command; and the docs are put into Basic English.
+
+## Privacy Release (v0.1.84)
+
+This release removes local user path text from saved release review input and adds a scan that keeps those words out of tracked files.
+
+v0.1.85

package/apps/architecture-review/app.json

@@ -3,7 +3,7 @@
   "id": "architecture-review",
   "title": "Architecture Review",
   "summary": "Map a repository architecture, assess risks, verify important findings, and synthesize an evidence-backed verdict.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/architecture-review-fast/app.json

@@ -3,7 +3,7 @@
   "id": "architecture-review-fast",
   "title": "Architecture Review Fast",
   "summary": "Run a shorter architecture review with parallel map and assess phases for faster first results.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/end-to-end-golden-path/app.json

@@ -3,7 +3,7 @@
   "id": "end-to-end-golden-path",
   "title": "End-to-End Golden Path",
   "summary": "Deterministic one-worker workflow app for proving the CW integration chain.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/pr-review-fix-ci/app.json

@@ -3,7 +3,7 @@
   "id": "pr-review-fix-ci",
   "title": "PR Review Fix CI",
   "summary": "Review a pull request or branch, inspect CI failures, diagnose actionable issues, optionally patch, verify, and summarize with evidence.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/release-cut/app.json

@@ -3,7 +3,7 @@
   "id": "release-cut",
   "title": "Release Cut",
   "summary": "Prepare a release with checklist discipline: version checks, changelog, tests, packaging, release notes, and final verification.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/research-synthesis/app.json

@@ -3,7 +3,7 @@
   "id": "research-synthesis",
   "title": "Research Synthesis",
   "summary": "Split a research question into claims, investigate sources, cross-check evidence, verify claims, and synthesize a concise answer.",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/dist/capability-core.js

@@ -40,6 +40,8 @@ exports.runExportArchive = runExportArchive;
 exports.runImportArchive = runImportArchive;
 exports.runInspectArchive = runInspectArchive;
 exports.runVerifyImport = runVerifyImport;
+exports.reportBundle = reportBundle;
+exports.runVerifyReportBundle = runVerifyReportBundle;
 exports.queueAdd = queueAdd;
 exports.queueList = queueList;
 exports.queueDrain = queueDrain;
@@ -69,6 +71,7 @@ exports.isRecord = isRecord;
 exports.telemetryVerify = telemetryVerify;
 exports.auditVerify = auditVerify;
 exports.demoTamper = demoTamper;
+exports.demoBundle = demoBundle;
 const drive_1 = require("./drive");
 const agent_config_1 = require("./agent-config");
 const run_registry_1 = require("./run-registry");
@@ -277,7 +280,11 @@ function runRerun(reg, runId, args) {
 function runExportArchive(runner, runId, args) {
     const base = invocationCwd(args);
     const output = optionalString(args.output || args.path || args.archive) || `${runId}.cwrun.json`;
-    return (0, run_export_1.exportRun)(runner.withBaseDir(optionalString(args.cwd)).loadRun(runId), node_path_1.default.resolve(base, output));
+    // Optionally seal in the operator's PUBLIC trust key so the bundle re-verifies
+    // offline. Default falls back to the same env the verify gate reads, so a single
+    // configured key both attests at record-time and travels with the export.
+    const trustPublicKey = optionalString(args["with-trust-key"] || args.withTrustKey || args.trustKey || args.pubkey) || process.env.CW_AGENT_ATTEST_PUBKEY;
+    return (0, run_export_1.exportRun)(runner.withBaseDir(optionalString(args.cwd)).loadRun(runId), node_path_1.default.resolve(base, output), { trustPublicKey });
 }
 function runImportArchive(runner, args) {
     const base = invocationCwd(args);
@@ -303,6 +310,48 @@ function runInspectArchive(_runner, args) {
 function runVerifyImport(runner, runId, args) {
     return (0, run_export_1.verifyImportedRun)(runner.withBaseDir(optionalString(args.cwd)).loadRun(runId));
 }
+// Produce-and-prove: export a run to a portable bundle sealed with the operator's
+// trust key (defaulting to CW_AGENT_ATTEST_PUBKEY, same as `run export`), then
+// IMMEDIATELY verify the artifact offline the way a recipient will. The producer
+// learns now — fail-closed — whether the bundle a client will check is actually
+// verifiable (e.g. an unconfigured attest key yields an unverifiable bundle). Pure
+// composition of runExportArchive + verifyReportBundle; spawns nothing, writes only
+// the archive (and, with --extract-report, the human report) that `run export` would.
+function reportBundle(runner, runId, args) {
+    const exported = runExportArchive(runner, runId, args);
+    const base = invocationCwd(args);
+    const extractReportTo = optionalString(args["extract-report"] || args.extractReport || args.extractReportTo);
+    const verification = (0, run_export_1.verifyReportBundle)(exported.path, {
+        pubkey: optionalString(args.pubkey || args.pubKey || args.publicKey),
+        extractReportTo: extractReportTo ? node_path_1.default.resolve(base, extractReportTo) : undefined,
+        strictSignatures: Boolean(args["strict-signatures"] || args.strictSignatures || args.strictSigs)
+    });
+    return {
+        schemaVersion: 1,
+        runId,
+        archivePath: exported.path,
+        trustKeyEmbedded: exported.trustKeyEmbedded,
+        reportExtractedTo: verification.reportExtractedTo,
+        verification,
+        ok: verification.ok
+    };
+}
+// Read-only: verify a portable run bundle OFFLINE and self-contained (archive bytes
+// + telemetry chain + trust-audit chain + embedded-key signatures). The runner is
+// unused — verification restores into its own throwaway tmpdir and writes nothing to
+// any registry — but kept for dispatch-signature symmetry with the other run verbs.
+function runVerifyReportBundle(_runner, args) {
+    const base = invocationCwd(args);
+    const archive = optionalString(args.archive || args.path || args.file || args.bundle);
+    if (!archive)
+        throw new Error("report verify-bundle requires a bundle path (positional, --archive, --path, --file, or --bundle)");
+    const extractReportTo = optionalString(args["extract-report"] || args.extractReport || args.extractReportTo);
+    return (0, run_export_1.verifyReportBundle)(node_path_1.default.resolve(base, archive), {
+        pubkey: optionalString(args.pubkey || args.pubKey || args.publicKey),
+        extractReportTo: extractReportTo ? node_path_1.default.resolve(base, extractReportTo) : undefined,
+        strictSignatures: Boolean(args["strict-signatures"] || args.strictSignatures || args.strictSigs)
+    });
+}
 function queueAdd(reg, args) {
     return reg.queueAdd({
         runId: optionalString(args.runId),
@@ -534,6 +583,33 @@ function quickstart(runner, args) {
     const runRepoCwd = node_path_1.default.resolve(node_path_1.default.dirname(result.statePath), "..", "..", "..");
     const reportTarget = node_fs_1.default.existsSync(runRepoCwd) ? runRepoCwd : undefined;
     const reportPath = runner.withBaseDir(reportTarget).report(result.runId).path;
+    // --bundle: after a COMPLETE drive, seal the run into a portable, self-verified
+    // bundle so the one command yields a client-verifiable artifact. Pure composition
+    // of reportBundle() (export sealed + offline self-verify); spawns nothing. Gated on
+    // completion: a partial or blocked run is NEVER sealed (you must not ship an
+    // uncommitted artifact).
+    //
+    // Run-state resolution MUST anchor to the run's OWN repo (reportTarget): the README
+    // headline runs quickstart cross-directory (caller cwd != --repo), so a caller-cwd
+    // loadRun would not find the run. But operator-supplied OUTPUT paths
+    // (--output/--extract-report) and the default archive name resolve against the
+    // CALLER's cwd — so artifacts land where the operator ran the command (and `&&
+    // send out.md` works) and never pollute the analyzed repo's working tree, matching
+    // standalone `report bundle`. Pre-resolving to absolute makes path.resolve(base, …)
+    // inside reportBundle a no-op, so the run-repo cwd cannot reclaim them.
+    let bundle;
+    const wantsBundle = flag(args.bundle) === true;
+    if (wantsBundle && result.status === "complete") {
+        const callerBase = invocationCwd(args);
+        const outArg = optionalString(args.output || args.path || args.archive);
+        const extractArg = optionalString(args["extract-report"] || args.extractReport || args.extractReportTo);
+        bundle = reportBundle(runner, result.runId, {
+            ...args,
+            cwd: reportTarget,
+            output: node_path_1.default.resolve(callerBase, outArg || `${result.runId}.cwrun.json`),
+            ...(extractArg ? { "extract-report": node_path_1.default.resolve(callerBase, extractArg) } : {})
+        });
+    }
     let hint;
     if (!agentConfigured) {
         hint =
@@ -550,6 +626,11 @@ function quickstart(runner, args) {
             ? `one step advanced — continue: cw quickstart ${appId} --run ${result.runId} --resume`
             : `one step advanced (--once) — continue: cw quickstart ${appId} --run ${result.runId} --once`;
     }
+    // --bundle on a run that didn't complete is a NO-OP, not silence: tell the operator
+    // why nothing was sealed (Rule of Silence permits a human-facing hint).
+    if (wantsBundle && result.status !== "complete") {
+        hint = `${hint ? `${hint} ` : ""}--bundle skipped: the run did not complete (status=${result.status}); no bundle was sealed.`;
+    }
     return {
         schemaVersion: 1,
         appId,
@@ -568,7 +649,10 @@ function quickstart(runner, args) {
         // Stamp resumedFrom ONLY when we continued an explicit run. Conditional spread
         // keeps the key absent on the default/fresh path (own-property absent + omitted
         // by JSON.stringify), so default output is byte-identical.
-        ...(resumeRunId ? { resumedFrom: resumeRunId } : {})
+        ...(resumeRunId ? { resumedFrom: resumeRunId } : {}),
+        // Same conditional-spread discipline: `bundle` is present only when --bundle ran
+        // on a completed drive, so the default (no --bundle) payload is byte-identical.
+        ...(bundle ? { bundle } : {})
     };
 }
 /** Read-only, deterministic projection of the effective agent config (secret-stripped). */
@@ -763,3 +847,6 @@ function auditVerify(runner, args) {
 function demoTamper(_runner, _args = {}) {
     return (0, telemetry_demo_1.runTamperDemo)();
 }
+function demoBundle(_runner, _args = {}) {
+    return (0, telemetry_demo_1.runBundleDemo)();
+}

package/dist/capability-registry.js

@@ -26,10 +26,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CAPABILITY_REGISTRY = void 0;
 exports.declaredMcpTools = declaredMcpTools;
+exports.mcpCapabilityForTool = mcpCapabilityForTool;
+exports.mcpCapabilityForId = mcpCapabilityForId;
+exports.mcpRequiredArgsForTool = mcpRequiredArgsForTool;
+exports.mcpToolDefinition = mcpToolDefinition;
 exports.declaredCliTokens = declaredCliTokens;
 exports.requiresReason = requiresReason;
 exports.isPayloadProbeOptOut = isPayloadProbeOptOut;
 exports.payloadIdenticalCapabilities = payloadIdenticalCapabilities;
+exports.payloadProbeTargets = payloadProbeTargets;
+exports.deferredPayloadProbeCapabilities = deferredPayloadProbeCapabilities;
+exports.payloadProbePlan = payloadProbePlan;
 exports.buildParityReport = buildParityReport;
 // ---------------------------------------------------------------------------
 // Builtin entries. Grouped to mirror the CLI dispatch and the MCP tool list.
@@ -338,15 +345,17 @@ const BUILTIN_CAPABILITIES = [
     { capability: "run.import", summary: "Restore a portable run archive into a target repo and verify restored file digests.", entry: "runImportArchive", surface: "both", cli: { path: ["run", "import"], jsonMode: "default" }, mcp: { tool: "cw_run_import", requiredArgs: ["archive|path|file"] } },
     { capability: "run.verify-import", summary: "Verify an imported run against its restore manifest and telemetry chain.", entry: "runVerifyImport", surface: "both", cli: { path: ["run", "verify-import"], jsonMode: "default" }, mcp: { tool: "cw_run_verify_import", requiredArgs: ["runId"] } },
     { capability: "run.inspect-archive", summary: "Read-only integrity inspection of a portable run archive without importing it.", entry: "runInspectArchive", surface: "both", cli: { path: ["run", "inspect-archive"], jsonMode: "default" }, mcp: { tool: "cw_run_inspect_archive", requiredArgs: ["archive|path|file"] } },
+    { capability: "report.verify-bundle", summary: "Offline self-contained verify of a portable run bundle: archive bytes + telemetry chain + trust-audit chain + embedded-key signatures.", entry: "runVerifyReportBundle", surface: "both", cli: { path: ["report", "verify-bundle"], caseTokens: ["report"], jsonMode: "default" }, mcp: { tool: "cw_report_verify_bundle", requiredArgs: ["archive|path|file|bundle"] } },
+    { capability: "report.bundle", summary: "Produce-and-prove: export a run to a portable bundle sealed with the trust key, then self-verify it offline (fail-closed) so the producer knows it is verifiable before shipping.", entry: "reportBundle", surface: "both", cli: { path: ["report", "bundle"], caseTokens: ["report"], jsonMode: "default" }, mcp: { tool: "cw_report_bundle", requiredArgs: ["runId"] } },
     { capability: "run.drive", summary: "Preview the next agent-delegation drive step for a run (read-only, deterministic).", entry: "runDrivePreview", surface: "both", cli: { path: ["run", "drive"], caseTokens: ["run", "drive"], jsonMode: "default" }, mcp: { tool: "cw_run_drive" } },
     { capability: "run.drive.step", summary: "Drive a run by delegating each worker to the agent backend (plan->dispatch->fulfill->accept->commit; --once for one step).", entry: "runDrive", surface: "both", cli: { path: ["run", "drive"], caseTokens: ["run", "drive"], jsonMode: "default" }, mcp: { tool: "cw_run_drive_step" }, payloadIdentical: false, 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." },
     {
         capability: "quickstart",
-        summary: "ONE-COMMAND quickstart: plan(app, default architecture-review) -> run --drive -> report in a single invocation (--preview for a read-only dry run).",
+        summary: "ONE-COMMAND quickstart: 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).",
         entry: "quickstart",
         surface: "cli-only",
         cli: { path: ["quickstart"], caseTokens: ["quickstart", "audit-run"], jsonMode: "default" },
-        reason: "CLI UX convenience layer (newcomer first value in one command) over the existing run.drive.step + report verbs; it spawns nothing new and delegates worker execution to the operator's agent backend. MCP hosts compose the same outcome from cw_run_drive_step + cw_report. `audit-run` is a CLI-only alias of the same wrapper."
+        reason: "CLI UX convenience layer (newcomer first value in one command) over the existing run.drive.step + report verbs; it spawns nothing new and delegates worker execution to the operator's agent backend. MCP hosts compose the same outcome from cw_run_drive_step + cw_report (+ cw_report_bundle for --bundle). `audit-run` is a CLI-only alias of the same wrapper."
     },
     { capability: "queue.add", summary: "Enqueue a pending/planned run with explicit ordering policy.", entry: "runRegistry.queueAdd", surface: "both", cli: { path: ["queue", "add"], jsonMode: "default" }, mcp: { tool: "cw_queue_add" } },
     { capability: "queue.list", summary: "List the durable run queue in policy order.", entry: "runRegistry.queueList", surface: "both", cli: { path: ["queue", "list"], jsonMode: "flag" }, mcp: { tool: "cw_queue_list" } },
@@ -370,6 +379,7 @@ const BUILTIN_CAPABILITIES = [
     { capability: "gc.verify", summary: "Re-prove a reclaimed run: skeleton-complete, tombstone chain untampered, artifacts reconstructable.", entry: "gcVerify", surface: "both", cli: { path: ["gc", "verify"], caseTokens: ["gc", "verify"], jsonMode: "flag" }, mcp: { tool: "cw_gc_verify", requiredArgs: ["runId"] } },
     { capability: "telemetry.verify", summary: "Re-prove a run's telemetry attestation ledger offline: chain linkage + independent hash recompute, and (with --pubkey / CW_AGENT_ATTEST_PUBKEY) re-verify each attested hop's ed25519 signature against the public key.", entry: "telemetryVerify", surface: "both", cli: { path: ["telemetry", "verify"], caseTokens: ["telemetry"], jsonMode: "flag" }, mcp: { tool: "cw_telemetry_verify", requiredArgs: ["runId"] } },
     { capability: "demo.tamper", summary: "Prove tamper-evidence: build a signed telemetry ledger, forge it, watch verification fail offline.", entry: "demoTamper", surface: "cli-only", cli: { path: ["demo", "tamper"], caseTokens: ["demo", "tamper"], jsonMode: "flag" }, reason: "Human-facing demonstration (operator/newcomer onboarding); the underlying integrity check is exposed programmatically as the both-surface telemetry.verify. No agent or MCP client needs to invoke a demo." },
+    { capability: "demo.bundle", summary: "Prove portable-bundle verification: export a sealed report bundle, forge it two ways, watch report verify-bundle catch both offline with only the embedded public key.", entry: "demoBundle", surface: "cli-only", cli: { path: ["demo", "bundle"], caseTokens: ["demo", "bundle"], jsonMode: "flag" }, reason: "Human-facing demonstration (operator/newcomer onboarding); the underlying integrity check is exposed programmatically as the both-surface report.verify-bundle. No agent or MCP client needs to invoke a demo." },
     { capability: "history", summary: "Read a cross-repo unified run timeline (newest first).", entry: "runRegistry.history", surface: "both", cli: { path: ["history"], jsonMode: "flag" }, mcp: { tool: "cw_history" } },
     // ---- web / desktop workbench (v0.1.30) ----------------------------------
     // A THIRD FRONT DOOR — a read-only renderer, not a new brain. Both verbs route
@@ -412,12 +422,238 @@ const BUILTIN_CAPABILITIES = [
  *  silently-dead duplicate the way the old snapshot-then-register design allowed. */
 exports.CAPABILITY_REGISTRY = Array.from(new Map(BUILTIN_CAPABILITIES.map((cap) => [cap.capability, cap])).values());
 // ---------------------------------------------------------------------------
+// Payload probe classification.
+// ---------------------------------------------------------------------------
+const GLOBAL_PAYLOAD_PROBE_CAPABILITIES = [
+    "list",
+    "app.list",
+    "topology.list",
+    "sandbox.list",
+    "backend.list",
+    "backend.agent.config.show",
+    "metrics.summary"
+];
+const RUN_PAYLOAD_PROBE_CAPABILITIES = [
+    "status",
+    "operator.status",
+    "operator.report",
+    "graph",
+    "report",
+    "next",
+    "state.check",
+    "contract.show",
+    "node.list",
+    "node.graph",
+    "worker.summary",
+    "candidate.summary",
+    "feedback.summary",
+    "commit.summary",
+    "audit.summary",
+    "multi-agent.summary",
+    "workbench.view",
+    "metrics.show",
+    "review.status",
+    "comment.list",
+    "run.drive",
+    "gc.plan",
+    "gc.verify"
+];
+const PAYLOAD_PROBE_DEFERRED_GROUPS = [
+    {
+        reason: "Not safe for the deterministic bootstrap parity probe yet: this capability needs extra target ids/files, mutates durable state, depends on external state, or needs a dedicated fixture beyond cwd/runId.",
+        capabilities: [
+            "init",
+            "plan",
+            "dispatch",
+            "result",
+            "app.show",
+            "app.validate",
+            "app.init",
+            "app.package",
+            "app.run",
+            "node.show",
+            "node.snapshot",
+            "node.diff",
+            "node.replay",
+            "node.replay.verify",
+            "migration.list",
+            "migration.check",
+            "migration.prove",
+            "topology.show",
+            "topology.validate",
+            "topology.apply",
+            "topology.summary",
+            "topology.graph",
+            "summary.refresh",
+            "summary.show",
+            "multi-agent.run",
+            "multi-agent.status",
+            "multi-agent.step",
+            "multi-agent.blackboard",
+            "multi-agent.score",
+            "multi-agent.select",
+            "multi-agent.summarize",
+            "multi-agent.graph",
+            "multi-agent.graph.compact",
+            "multi-agent.dependencies",
+            "multi-agent.failures",
+            "multi-agent.evidence",
+            "multi-agent.reasoning",
+            "multi-agent.reasoning.refresh",
+            "multi-agent.run.create",
+            "multi-agent.run.transition",
+            "multi-agent.run.show",
+            "multi-agent.role.create",
+            "multi-agent.role.show",
+            "multi-agent.group.create",
+            "multi-agent.group.show",
+            "multi-agent.membership.create",
+            "multi-agent.membership.show",
+            "multi-agent.fanout.create",
+            "multi-agent.fanout.show",
+            "multi-agent.fanin.collect",
+            "multi-agent.fanin.show",
+            "eval.snapshot",
+            "eval.replay",
+            "eval.compare",
+            "eval.score",
+            "eval.gate",
+            "eval.report",
+            "blackboard.summary",
+            "blackboard.summarize",
+            "blackboard.graph",
+            "blackboard.resolve",
+            "blackboard.topic.create",
+            "blackboard.message.post",
+            "blackboard.message.list",
+            "blackboard.context.put",
+            "blackboard.artifact.add",
+            "blackboard.artifact.list",
+            "blackboard.snapshot",
+            "coordinator.summary",
+            "coordinator.decision",
+            "audit.verify",
+            "audit.worker",
+            "audit.provenance",
+            "audit.multi-agent",
+            "audit.policy",
+            "audit.role",
+            "audit.blackboard",
+            "audit.judge",
+            "audit.attest",
+            "audit.decision",
+            "sandbox.show",
+            "sandbox.validate",
+            "sandbox.choose",
+            "sandbox.resolve",
+            "backend.show",
+            "backend.probe",
+            "worker.list",
+            "worker.show",
+            "worker.manifest",
+            "worker.output",
+            "worker.fail",
+            "worker.validate",
+            "candidate.list",
+            "candidate.show",
+            "candidate.register",
+            "candidate.score",
+            "candidate.rank",
+            "candidate.select",
+            "candidate.reject",
+            "feedback.list",
+            "feedback.show",
+            "feedback.collect",
+            "feedback.task",
+            "feedback.resolve",
+            "schedule.create",
+            "schedule.list",
+            "schedule.delete",
+            "schedule.due",
+            "schedule.complete",
+            "schedule.pause",
+            "schedule.resume",
+            "schedule.run-now",
+            "schedule.history",
+            "routine.create",
+            "routine.list",
+            "routine.delete",
+            "routine.fire",
+            "routine.events",
+            "registry.refresh",
+            "registry.show",
+            "run.search",
+            "run.list",
+            "run.show",
+            "run.resume",
+            "run.archive",
+            "run.rerun",
+            "run.export",
+            "run.import",
+            "run.verify-import",
+            "run.inspect-archive",
+            "report.verify-bundle",
+            "report.bundle",
+            "queue.add",
+            "queue.list",
+            "queue.drain",
+            "queue.show",
+            "sched.plan",
+            "sched.lease",
+            "sched.release",
+            "sched.complete",
+            "sched.reclaim",
+            "sched.reset",
+            "sched.policy.show",
+            "sched.policy.set",
+            "telemetry.verify",
+            "history",
+            "approve",
+            "reject",
+            "comment.add",
+            "handoff",
+            "review.policy"
+        ]
+    }
+];
+// ---------------------------------------------------------------------------
 // Derivations + the fail-closed parity report builder.
 // ---------------------------------------------------------------------------
 /** The MCP tool names this registry declares. */
 function declaredMcpTools() {
     return exports.CAPABILITY_REGISTRY.filter((cap) => cap.mcp).map((cap) => cap.mcp.tool);
 }
+/** The descriptor for a registry-declared MCP tool name. */
+function mcpCapabilityForTool(tool) {
+    return exports.CAPABILITY_REGISTRY.find((capability) => capability.mcp?.tool === tool);
+}
+/** The descriptor for a registry-declared capability id. */
+function mcpCapabilityForId(capabilityId) {
+    const descriptor = exports.CAPABILITY_REGISTRY.find((capability) => capability.capability === capabilityId);
+    return descriptor?.mcp ? descriptor : undefined;
+}
+/** Required MCP argument groups for a registry-declared tool. */
+function mcpRequiredArgsForTool(tool) {
+    return mcpCapabilityForTool(tool)?.mcp?.requiredArgs ?? [];
+}
+function mcpToolDefinition(capabilityId, descriptionOrProperties, maybeProperties) {
+    const descriptor = mcpCapabilityForId(capabilityId);
+    if (!descriptor?.mcp)
+        throw new Error(`MCP capability not declared: ${capabilityId}`);
+    const description = typeof descriptionOrProperties === "string" ? descriptionOrProperties : descriptor.summary;
+    const properties = typeof descriptionOrProperties === "string" ? maybeProperties : descriptionOrProperties;
+    if (!properties)
+        throw new Error(`MCP capability ${capabilityId} missing input schema properties.`);
+    return {
+        name: descriptor.mcp.tool,
+        description,
+        inputSchema: {
+            type: "object",
+            properties,
+            additionalProperties: true
+        }
+    };
+}
 /** The CLI `case` tokens this registry declares (deduped). */
 function declaredCliTokens() {
     const tokens = new Set();
@@ -460,6 +696,30 @@ function isPayloadProbeOptOut(cap) {
 function payloadIdenticalCapabilities() {
     return exports.CAPABILITY_REGISTRY.filter((cap) => cap.surface === "both" && cap.cli && cap.mcp && !isPayloadProbeOptOut(cap));
 }
+function payloadProbeTargets() {
+    return [
+        ...GLOBAL_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "global" })),
+        ...RUN_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "run" }))
+    ];
+}
+function deferredPayloadProbeCapabilities() {
+    return PAYLOAD_PROBE_DEFERRED_GROUPS.flatMap((group) => group.capabilities.map((capability) => ({ capability, reason: group.reason })));
+}
+function payloadProbePlan() {
+    const candidateIds = new Set(payloadIdenticalCapabilities().map((cap) => cap.capability));
+    const counts = new Map();
+    const classified = [...payloadProbeTargets().map((entry) => entry.capability), ...deferredPayloadProbeCapabilities().map((entry) => entry.capability)];
+    for (const capability of classified)
+        counts.set(capability, (counts.get(capability) || 0) + 1);
+    const classifiedIds = new Set(classified);
+    return {
+        targets: payloadProbeTargets(),
+        deferred: deferredPayloadProbeCapabilities(),
+        unclassified: [...candidateIds].filter((capability) => !classifiedIds.has(capability)).sort(),
+        duplicateClassifications: [...counts.entries()].filter(([, count]) => count > 1).map(([capability]) => capability).sort(),
+        invalidClassifications: [...classifiedIds].filter((capability) => !candidateIds.has(capability)).sort()
+    };
+}
 function lintRegistry() {
     const issues = [];
     const seenCaps = new Set();
@@ -502,12 +762,16 @@ function buildParityReport(input) {
     const reasonlessExceptions = exports.CAPABILITY_REGISTRY.filter((cap) => requiresReason(cap) && !(cap.reason && cap.reason.trim()))
         .map((cap) => cap.capability)
         .sort();
+    const payloadPlan = payloadProbePlan();
     const registryLint = lintRegistry();
     const ok = missingMcpTools.length === 0 &&
         undeclaredMcpTools.length === 0 &&
         missingCliTokens.length === 0 &&
         undeclaredCliTokens.length === 0 &&
         reasonlessExceptions.length === 0 &&
+        payloadPlan.unclassified.length === 0 &&
+        payloadPlan.duplicateClassifications.length === 0 &&
+        payloadPlan.invalidClassifications.length === 0 &&
         registryLint.length === 0;
     return {
         ok,
@@ -517,6 +781,9 @@ function buildParityReport(input) {
         missingCliTokens,
         undeclaredCliTokens,
         reasonlessExceptions,
+        payloadProbeUnclassified: payloadPlan.unclassified,
+        payloadProbeDuplicateClassifications: payloadPlan.duplicateClassifications,
+        payloadProbeInvalidClassifications: payloadPlan.invalidClassifications,
         registryLint
     };
 }