cool-workflow 0.1.78 → 0.1.80

package/dist/drive.js

@@ -31,12 +31,14 @@ exports.driveConcurrentRound = driveConcurrentRound;
 exports.drive = drive;
 exports.drivePreview = drivePreview;
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const dispatch_1 = require("./dispatch");
 const execution_backend_1 = require("./execution-backend");
 const worker_isolation_1 = require("./worker-isolation");
 const agent_config_1 = require("./agent-config");
 const scheduling_1 = require("./scheduling");
 const observability_1 = require("./observability");
+const state_1 = require("./state");
 exports.DRIVE_SCHEMA_VERSION = 1;
 /** The task the next drive step would advance: a RUNNING (already-dispatched,
  *  awaiting fulfillment / retry) task first, else the next PENDING task in the
@@ -198,8 +200,26 @@ function processSelectedTask(ctx, selected, preparedOutcome) {
     // Progress BEFORE the (possibly multi-minute) agent spawn, so a live drive shows
     // immediate activity instead of a long silence on the first worker. task.label
     // is the human-facing display name; the id stays the stable reference.
-    emitProgress(`→ ${selected.label || selected.id} (${selected.phase}) — ${dispatched ? "dispatched, " : ""}spawning agent, may take minutes…`);
     const promptDigest = node_fs_1.default.existsSync(manifest.inputPath) ? (0, execution_backend_1.sha256)(node_fs_1.default.readFileSync(manifest.inputPath, "utf8")) : (0, execution_backend_1.sha256)(manifest.prompt || "");
+    const cachePath = resultCachePath(run, selected, (0, execution_backend_1.sha256)(selected.prompt));
+    if (cachePath && node_fs_1.default.existsSync(cachePath)) {
+        emitProgress(`↺ ${selected.label || selected.id} (${selected.phase}) — accepting cached result`);
+        try {
+            node_fs_1.default.writeFileSync(manifest.resultPath, node_fs_1.default.readFileSync(cachePath, "utf8"), "utf8");
+            runner.recordWorkerOutput(runId, workerId, manifest.resultPath, {});
+        }
+        catch (error) {
+            return handleHop(ctx, selected, workerId, `result cache rejected: ${error instanceof Error ? error.message : String(error)}`, dispatched);
+        }
+        return step("accept", "ok", {
+            runId,
+            taskId: selected.id,
+            phase: selected.phase,
+            handleKind: "result-cache",
+            reason: "result cache hit"
+        });
+    }
+    emitProgress(`→ ${selected.label || selected.id} (${selected.phase}) — ${dispatched ? "dispatched, " : ""}spawning agent, may take minutes…`);
     const envelope = (0, execution_backend_1.runBackend)(buildAgentRequest(ctx, run, selected, manifest, preparedOutcome));
     const handle = envelope.provenance.handle;
     const reportedModel = handle?.metadata?.reportedModel || "unreported";
@@ -236,6 +256,9 @@ function processSelectedTask(ctx, selected, preparedOutcome) {
     catch (error) {
         return handleHop(ctx, selected, workerId, `result.md rejected: ${error instanceof Error ? error.message : String(error)}`, dispatched);
     }
+    if (cachePath && manifest.resultPath && node_fs_1.default.existsSync(manifest.resultPath)) {
+        writeResultCache(cachePath, node_fs_1.default.readFileSync(manifest.resultPath, "utf8"));
+    }
     return step("accept", "ok", {
         runId,
         taskId: selected.id,
@@ -245,6 +268,53 @@ function processSelectedTask(ctx, selected, preparedOutcome) {
         reportedModel
     });
 }
+function resultCachePath(run, task, promptDigest) {
+    const policy = task.resultCache;
+    if (!policy || policy.mode !== "read-write")
+        return undefined;
+    const keyInput = policy.keyInput;
+    const keyValue = keyInput ? String(run.inputs[keyInput] || "").trim() : "";
+    if (!keyInput || !keyValue)
+        return undefined;
+    const completedResultsDigest = completedResultsCacheDigest(run, task);
+    if (completedResultsDigest === undefined)
+        return undefined;
+    const digest = (0, execution_backend_1.sha256)(JSON.stringify({
+        schemaVersion: 1,
+        workflowId: run.workflow.id,
+        taskId: task.id,
+        keyInput,
+        keyValue,
+        promptDigest,
+        completedResultsDigest
+    })).replace(/^sha256:/, "");
+    return node_path_1.default.join(run.cwd, ".cw", "cache", "worker-results", (0, state_1.safeFileName)(run.workflow.id), `${(0, state_1.safeFileName)(task.id)}-${digest.slice(0, 32)}.md`);
+}
+function completedResultsCacheDigest(run, task) {
+    if (task.resultCache?.includeCompletedResults !== "previous-phases")
+        return "";
+    const phaseIndex = run.phases.findIndex((phase) => phase.name === task.phase || phase.id === task.phase);
+    if (phaseIndex < 0)
+        return undefined;
+    const previousTaskIds = new Set(run.phases.slice(0, phaseIndex).flatMap((phase) => phase.taskIds));
+    const records = run.tasks
+        .filter((candidate) => previousTaskIds.has(candidate.id))
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map((candidate) => {
+        if (candidate.status !== "completed" || !candidate.resultPath || !node_fs_1.default.existsSync(candidate.resultPath))
+            return undefined;
+        return [candidate.id, (0, execution_backend_1.sha256)(node_fs_1.default.readFileSync(candidate.resultPath, "utf8"))];
+    });
+    if (records.some((record) => record === undefined))
+        return undefined;
+    return (0, execution_backend_1.sha256)(JSON.stringify(records));
+}
+function writeResultCache(file, content) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    node_fs_1.default.writeFileSync(tmp, content, "utf8");
+    node_fs_1.default.renameSync(tmp, file);
+}
 /** Advance ONE concurrent ROUND: fulfill up to `limit` ready tasks in the first
  *  runnable phase as a single batch, recording results in DETERMINISTIC task
  *  order (the existing phase/dispatch order) regardless of completion order — so
@@ -322,6 +392,9 @@ function prepareConcurrentOutcomes(ctx, batch) {
             continue;
         }
         const manifest = runner.showWorkerManifest(runId, workerId);
+        const cachePath = resultCachePath(run, task, (0, execution_backend_1.sha256)(task.prompt));
+        if (cachePath && node_fs_1.default.existsSync(cachePath))
+            continue;
         const job = (0, execution_backend_1.prepareAgentSpawn)(buildAgentRequest(ctx, run, task, manifest));
         if (job) {
             jobs.push(job);

package/dist/evidence-reasoning.js

@@ -389,11 +389,11 @@ function deriveCounterfactuals(run, scores) {
 // node. This returns the operator-graph node ids backing every decision-bearing
 // reasoning step of an adopted chain, so state-explosion can protect them.
 // ---------------------------------------------------------------------------
-function reasoningCriticalNodeIds(run) {
+function reasoningCriticalNodeIds(run, operator = (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run)) {
     const ids = new Set();
     const faninIds = new Set((run.multiAgent?.fanins || []).map((entry) => entry.id));
     const commitById = new Map((run.commits || []).map((commit) => [commit.id, commit]));
-    for (const evidence of (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run).evidence) {
+    for (const evidence of operator.evidence) {
         if (evidence.status !== "adopted")
             continue;
         for (const id of evidence.candidateIds)

package/dist/execution-backend.js

@@ -887,13 +887,18 @@ function runAgentProcess(descriptor, policy, request, label, handle, attestation
             outcome = request.preparedAgentOutcome;
         }
         else {
+            // Live output is opt-in (POLA): stdout is always captured as data, while
+            // stderr is forwarded only when the operator explicitly asks for a stream
+            // and this process is attached to a terminal. CI/pipes stay silent.
+            const streamStderr = process.env.CW_AGENT_STREAM === "1" && Boolean(process.stderr.isTTY) && process.env.CW_NO_STREAM !== "1";
             const child = (0, node_child_process_1.spawnSync)(resolved.binary, realArgs, {
                 cwd: request.cwd,
                 env: { ...process.env },
                 encoding: "utf8",
                 timeout: resolved.timeoutMs || 600000,
                 maxBuffer: 32 * 1024 * 1024,
-                shell: false
+                shell: false,
+                stdio: ["ignore", "pipe", streamStderr ? "inherit" : "pipe"]
             });
             outcome = {
                 ...(child.error ? { spawnError: messageOf(child.error) } : {}),

package/dist/mcp-server.js

@@ -391,6 +391,12 @@ function callTool(name, args) {
                 return (0, capability_core_1.runArchive)((0, capability_core_1.runRegistryFor)(args, runner), (0, capability_core_1.optionalString)(args.runId), args);
             case "cw_run_rerun":
                 return (0, capability_core_1.runRerun)((0, capability_core_1.runRegistryFor)(args, runner), String(args.runId || ""), args);
+            case "cw_run_export":
+                return (0, capability_core_1.runExportArchive)(runner, String(args.runId || ""), args);
+            case "cw_run_import":
+                return (0, capability_core_1.runImportArchive)(runner, args);
+            case "cw_run_verify_import":
+                return (0, capability_core_1.runVerifyImport)(runner, String(args.runId || ""), args);
             case "cw_run_drive":
                 return (0, capability_core_1.runDrivePreview)(runner, args);
             case "cw_run_drive_step":
@@ -425,6 +431,8 @@ function callTool(name, args) {
                 return (0, capability_core_1.gcRun)((0, capability_core_1.runRegistryFor)(args, runner), (0, capability_core_1.optionalString)(args.runId), args);
             case "cw_gc_verify":
                 return (0, capability_core_1.gcVerify)((0, capability_core_1.runRegistryFor)(args, runner), String(args.runId || ""), args);
+            case "cw_telemetry_verify":
+                return (0, capability_core_1.telemetryVerify)(runner, args);
             case "cw_history":
                 return (0, capability_core_1.runHistory)((0, capability_core_1.runRegistryFor)(args, runner), args);
             case "cw_workbench_view":
@@ -510,12 +518,16 @@ function requiredArgsForTool(name) {
         return ["runId", "targetKind|kind", "targetId|target", "body|message|text"];
     if (name === "cw_handoff")
         return ["runId", "targetKind|kind", "targetId|target", "to|toActor"];
-    if (name === "cw_run_show" || name === "cw_run_resume" || name === "cw_run_rerun")
+    if (name === "cw_run_show" || name === "cw_run_resume" || name === "cw_run_rerun" || name === "cw_run_export" || name === "cw_run_verify_import")
         return ["runId"];
+    if (name === "cw_run_import")
+        return ["archive|path|file"];
     if (name === "cw_run_archive")
         return ["runId|olderThanDays"];
     if (name === "cw_gc_verify")
         return ["runId"];
+    if (name === "cw_telemetry_verify")
+        return ["runId"];
     if (name === "cw_queue_show")
         return ["id"];
     if (name.endsWith("_show")) {
@@ -700,24 +712,23 @@ function toolDefinitions() {
             contract: stringSchema("run-state | workflow-app (default run-state)"),
             cwd: stringSchema("Run workspace")
         }),
-        tool("cw_operator_status", "Read the structured Operator UX run status.", runIdSchema()),
-        tool("cw_operator_graph", "Read the structured Operator UX run graph.", runIdSchema()),
-        tool("cw_operator_report", "Refresh and read the structured Operator UX report summary.", runIdSchema()),
-        tool("cw_worker_summary", "Read the structured worker summary for a run.", runIdSchema()),
+        ...runIdCapabilityTools(["operator.status", "graph", "operator.report", "worker.summary"]),
         tool("cw_workbench_view", "Read the read-only five-panel Workbench view (graph, blackboard, worker, candidate, audit) for one run. Each panel embeds the verbatim `cw <cmd> --json` payload of one existing capability; absent panels are surfaced honestly. Peer of `cw workbench view`.", runIdSchema()),
         tool("cw_workbench_serve", "Describe the optional localhost-only, read-only Workbench host (bind, scope, routes). Returns the serve descriptor identical to `cw workbench serve --json`; MCP never starts the blocking server.", {
             cwd: stringSchema("Run workspace"),
             port: numberSchema("Optional loopback port, defaults to 7717"),
             scope: stringSchema("Registry scope: repo|home")
         }),
-        tool("cw_candidate_summary", "Read the structured candidate summary for a run.", runIdSchema()),
-        tool("cw_feedback_summary", "Read the structured feedback summary for a run.", runIdSchema()),
-        tool("cw_commit_summary", "Read the structured commit summary for a run.", runIdSchema()),
-        tool("cw_multi_agent_summary", "Read the structured multi-agent runtime summary for a run.", runIdSchema()),
-        tool("cw_multi_agent_graph", "Read the structured multi-agent operator graph for a run.", runIdSchema()),
-        tool("cw_multi_agent_dependencies", "Read derived multi-agent dependency edges for operator inspection.", runIdSchema()),
-        tool("cw_multi_agent_failures", "Read failed, blocked, rejected, and ambiguous multi-agent records.", runIdSchema()),
-        tool("cw_multi_agent_evidence", "Read evidence adoption status from worker output through selection and commit. Each row carries a derived rationaleStatus (explained|unexplained|not-applicable).", runIdSchema()),
+        ...runIdCapabilityTools([
+            "candidate.summary",
+            "feedback.summary",
+            "commit.summary",
+            "multi-agent.summary",
+            "multi-agent.graph",
+            "multi-agent.dependencies",
+            "multi-agent.failures",
+            "multi-agent.evidence"
+        ]),
         tool("cw_evidence_reasoning", "Explain WHY each evidence item was adopted/rejected/superseded/conflicting: a derived, fingerprinted reasoning chain with decision, basis, authority, rationale, and counterfactual per gate (fanin, candidate-score, selection, verifier, commit). Fails closed to `unexplained` when a rationale cannot be traced. Reads valid|stale|absent freshness against current source state.", {
             ...runIdSchema(),
             evidence: stringSchema("Optional evidence id/ref to explain a single adoption"),
@@ -1436,6 +1447,25 @@ function toolDefinitions() {
             scope: stringSchema("home (default, cross-repo) or repo"),
             reason: stringSchema("Rerun reason")
         }),
+        tool("cw_run_export", "Export a run to a portable, digest-checked archive containing run-local artifacts, audit overlays, telemetry, reports, workers, and commit snapshots.", {
+            runId: stringSchema("Run id to export"),
+            cwd: stringSchema("Repo workspace containing .cw/runs/<run-id>"),
+            output: stringSchema("Archive output path"),
+            path: stringSchema("Alias for output"),
+            archive: stringSchema("Alias for output")
+        }),
+        tool("cw_run_import", "Restore a portable run archive into a target repo and immediately verify restored file digests.", {
+            archive: stringSchema("Archive path"),
+            path: stringSchema("Alias for archive"),
+            file: stringSchema("Alias for archive"),
+            target: stringSchema("Restore target repo directory"),
+            repo: stringSchema("Alias for target"),
+            cwd: stringSchema("Invocation workspace")
+        }),
+        tool("cw_run_verify_import", "Verify an imported run against its restore manifest and telemetry chain; detects missing or tampered restored files.", {
+            runId: stringSchema("Imported run id to verify"),
+            cwd: stringSchema("Restored repo workspace")
+        }),
         tool("cw_run_drive", "Preview the next agent-delegation drive step for a run (read-only, deterministic). Counts come from state; no spawn, no mutation.", {
             runId: stringSchema("Run id to preview"),
             cwd: stringSchema("Run workspace")
@@ -1531,6 +1561,10 @@ function toolDefinitions() {
             scope: stringSchema("home (default, cross-repo) or repo"),
             runId: stringSchema("Run id to verify")
         }),
+        tool("cw_telemetry_verify", "Re-prove a run's telemetry attestation ledger offline: prevHash chain linkage + independent per-record hash recompute (never trusts the stored hash). A forged or edited record fails it. Peer of `cw telemetry verify`.", {
+            cwd: stringSchema("Repo workspace"),
+            runId: stringSchema("Run id to verify")
+        }),
         tool("cw_history", "Read a cross-repo unified run timeline (newest first), deterministic and paginated, with provenance links.", {
             cwd: stringSchema("Repo workspace"),
             scope: stringSchema("home (default, cross-repo) or repo"),
@@ -1552,6 +1586,15 @@ function tool(name, description, properties) {
         }
     };
 }
+function runIdCapabilityTools(capabilityIds) {
+    return capabilityIds.map((capabilityId) => capabilityTool(capabilityId, runIdSchema()));
+}
+function capabilityTool(capabilityId, properties) {
+    const descriptor = capability_registry_1.CAPABILITY_REGISTRY.find((capability) => capability.capability === capabilityId);
+    if (!descriptor?.mcp)
+        throw new Error(`MCP capability not declared: ${capabilityId}`);
+    return tool(descriptor.mcp.tool, descriptor.summary, properties);
+}
 function stringSchema(description) {
     return { type: "string", description };
 }

package/dist/orchestrator/lifecycle-operations.js

@@ -435,7 +435,8 @@ function flattenTasks(workflow, inputs) {
                 // model (per-task delegation override), agentType (dispatch backend).
                 ...(task.label ? { label: task.label } : {}),
                 ...(task.model ? { model: task.model } : {}),
-                ...(task.agentType ? { agentType: task.agentType } : {})
+                ...(task.agentType ? { agentType: task.agentType } : {}),
+                ...(task.resultCache ? { resultCache: task.resultCache } : {})
             });
         }
     }

package/dist/orchestrator.js

@@ -838,7 +838,7 @@ function formatHelp() {
         "  schedule create|list|due|complete|pause|resume|run-now|history|daemon|delete",
         "  routine create|fire|list|events|delete",
         "  registry refresh|show [--scope repo|home] [--json]",
-        "  run search|list|show|resume|archive|rerun [run-id] [--scope repo|home] [--json]",
+        "  run search|list|show|resume|archive|rerun|export|import|verify-import [run-id|archive] [--scope repo|home] [--json]",
         "  queue add|list|drain|show [queue-id] [--repo PATH] [--priority N]",
         "  history [--scope repo|home] [--app ID] [--status STATE] [--json]",
         "  workbench view <run-id> [--json]",