cool-workflow 0.1.83 → 0.1.85

package/dist/run-export.js

@@ -16,19 +16,26 @@ exports.importRun = importRun;
 exports.verifyImportedRun = verifyImportedRun;
 exports.inspectArchive = inspectArchive;
 exports.importManifestPath = importManifestPath;
+exports.verifyReportBundle = verifyReportBundle;
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const state_1 = require("./state");
 const version_1 = require("./version");
 const telemetry_ledger_1 = require("./telemetry-ledger");
+const telemetry_attestation_1 = require("./telemetry-attestation");
 const trust_audit_1 = require("./trust-audit");
 const compare_1 = require("./compare");
 /** Export a run to a portable JSON archive with run-local bytes and digests. */
-function exportRun(run, outputPath) {
+function exportRun(run, outputPath, options = {}) {
     const exportedAt = new Date().toISOString();
     const files = collectArchiveFiles(run);
     const manifestSha256 = digestManifest(files);
+    // Embed ONLY a public key. resolveTrustPublicKey normalizes an inline PEM or a
+    // file path down to inline PEM bytes so the archive is self-contained; a value
+    // that resolves to nothing (bad path) yields no trust block rather than a throw.
+    const trustPublicKeyPem = (0, telemetry_attestation_1.resolveTrustPublicKey)(options.trustPublicKey);
     const exported = {
         schemaVersion: 1,
         exportedAt,
@@ -39,6 +46,7 @@ function exportRun(run, outputPath) {
             fileCount: files.length,
             manifestSha256
         },
+        ...(trustPublicKeyPem ? { trust: { publicKeyPem: trustPublicKeyPem, algorithm: "ed25519" } } : {}),
         // Legacy field retained so old readers still find an artifact-ish list.
         artifacts: files
             .filter((file) => file.role === "artifact")
@@ -62,6 +70,7 @@ function exportRun(run, outputPath) {
         artifactCount: files.filter((file) => file.role === "artifact").length,
         auditFileCount: files.filter((file) => file.role === "audit").length,
         telemetryIncluded: files.some((file) => file.role === "telemetry"),
+        trustKeyEmbedded: Boolean(trustPublicKeyPem),
         manifestSha256,
         archiveSha256
     };
@@ -276,6 +285,135 @@ function inspectArchive(archivePath) {
 function importManifestPath(run) {
     return node_path_1.default.join(run.paths.runDir, "import-manifest.json");
 }
+/** Verify a portable run bundle OFFLINE and SELF-CONTAINED: prove the archive bytes,
+ *  the telemetry hash chain, the trust-audit chain, and (with the bundle's embedded
+ *  public key) the ed25519 signatures — WITHOUT a source repo, a pre-existing .cw
+ *  tree, or an out-of-band key. Reuses the existing import + restore-verify path: it
+ *  restores into an auto-cleaned tmpdir so a stranger's machine is left untouched.
+ *  Never throws — every failure is a structured check and a false `ok` (exit-1 worthy).
+ *
+ *  Key precedence is bundle > argument > environment, so the artifact verifies the
+ *  same on any machine; only when the bundle omits a key do the override/env apply. */
+function verifyReportBundle(archivePath, options = {}) {
+    const inspect = inspectArchive(archivePath);
+    const failedChecks = inspect.checks
+        .filter((check) => !check.pass)
+        .map((check) => ({ name: check.name, code: check.code }));
+    const base = {
+        schemaVersion: 1,
+        archivePath,
+        runId: inspect.runId,
+        ok: false,
+        archiveOk: inspect.ok,
+        telemetryVerified: false,
+        trustAuditVerified: false,
+        trustKeySource: "none",
+        signatureKeyProvided: false,
+        signaturesChecked: 0,
+        signaturesReverified: 0,
+        signaturesFailed: 0,
+        failedChecks
+    };
+    // A bundle that is not even a supported archive cannot be restored — report the
+    // inspection failure and stop (fail-closed, no tmpdir, nothing written).
+    if (!inspect.schemaSupported)
+        return base;
+    // Read the embedded trust key (and, if requested, the report bytes) straight from
+    // the archive JSON. inspectArchive already proved the bytes parse + digest-match.
+    let bundleKey;
+    let reportContent;
+    try {
+        const raw = JSON.parse(node_fs_1.default.readFileSync(archivePath, "utf8"));
+        bundleKey = raw.trust?.publicKeyPem;
+        if (options.extractReportTo) {
+            const reportFile = (raw.files || []).find((file) => file.relativePath === "report.md");
+            if (reportFile)
+                reportContent = Buffer.from(reportFile.contentBase64, "base64").toString("utf8");
+        }
+    }
+    catch {
+        /* inspect already recorded the parse failure; treat key as absent */
+    }
+    const trustKeySource = bundleKey
+        ? "bundle"
+        : options.pubkey
+            ? "argument"
+            : process.env.CW_AGENT_ATTEST_PUBKEY
+                ? "environment"
+                : "none";
+    const trustKey = (0, telemetry_attestation_1.resolveTrustPublicKey)(bundleKey || options.pubkey || process.env.CW_AGENT_ATTEST_PUBKEY);
+    const tmpDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), "cw-verify-bundle-"));
+    let telemetryVerified = false;
+    let trustAuditVerified = false;
+    let signaturesChecked = 0;
+    let signaturesReverified = 0;
+    let signaturesFailed = 0;
+    let reportExtractedTo;
+    try {
+        // Restore into the throwaway tree. importRun digest-checks every file and throws
+        // on the first mismatch (or on a stripped integrity block under
+        // CW_REQUIRE_ARCHIVE_INTEGRITY=1) — caught below as a failed "restore" check.
+        const imported = importRun(archivePath, tmpDir);
+        for (const check of imported.verification.checks) {
+            if (check.name === "telemetry-ledger")
+                telemetryVerified = check.pass;
+            if (check.name === "trust-audit")
+                trustAuditVerified = check.pass;
+            if (!check.pass)
+                failedChecks.push({ name: check.name, code: check.code });
+        }
+        // Independent ed25519 re-verification over the restored ledger using the bundle's
+        // own key (or override/env). With no key, attested records degrade to
+        // informational (signaturesFailed stays 0); the chain check above still gates ok.
+        const ledger = (0, telemetry_ledger_1.verifyTelemetryLedger)(imported.run);
+        const sig = (0, telemetry_attestation_1.verifyTelemetrySignatures)(ledger.records, trustKey);
+        signaturesChecked = sig.checked;
+        signaturesReverified = sig.reverified;
+        signaturesFailed = sig.failed;
+        for (const check of sig.checks)
+            if (!check.pass)
+                failedChecks.push({ name: check.name, code: check.code });
+        if (options.extractReportTo && reportContent !== undefined) {
+            reportExtractedTo = node_path_1.default.resolve(options.extractReportTo);
+            node_fs_1.default.writeFileSync(reportExtractedTo, reportContent);
+        }
+    }
+    catch (error) {
+        failedChecks.push({ name: "restore", code: messageOf(error) });
+    }
+    finally {
+        node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    // Strict mode: a bundle that claims attested telemetry but offers no key to check
+    // it is unverifiable — refuse rather than green it.
+    const strictShortfall = Boolean(options.strictSignatures) && signaturesChecked > 0 && !trustKey;
+    if (strictShortfall)
+        failedChecks.push({ name: "signatures", code: "signature-key-required" });
+    // Extraction was requested but could not be fulfilled (no report.md in the bundle,
+    // or the write failed): fail closed rather than silently green a missing artifact —
+    // otherwise `report bundle <run> --extract-report r.md && send r.md` would ship
+    // nothing (or a stale file) with exit 0. A requested-but-absent output is a failure,
+    // not a no-op (distinct from extraction never being requested).
+    const extractShortfall = Boolean(options.extractReportTo) && !reportExtractedTo;
+    if (extractShortfall)
+        failedChecks.push({ name: "extract-report", code: "report-md-unavailable" });
+    return {
+        schemaVersion: 1,
+        archivePath,
+        runId: inspect.runId,
+        ok: inspect.ok && telemetryVerified && trustAuditVerified && signaturesFailed === 0 && !strictShortfall && !extractShortfall,
+        archiveOk: inspect.ok,
+        telemetryVerified,
+        trustAuditVerified,
+        trustKeySource,
+        signatureKeyProvided: Boolean(trustKey),
+        signaturesChecked,
+        signaturesReverified,
+        signaturesFailed,
+        reportExtractedTo,
+        failedChecks
+    };
+}
 function collectArchiveFiles(run) {
     const entries = new Map();
     for (const file of walkFiles(run.paths.runDir)) {

package/dist/telemetry-demo.js

@@ -22,12 +22,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatTelemetryVerify = formatTelemetryVerify;
 exports.formatTamperDemo = formatTamperDemo;
 exports.runTamperDemo = runTamperDemo;
+exports.runBundleDemo = runBundleDemo;
+exports.formatBundleDemo = formatBundleDemo;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const telemetry_ledger_1 = require("./telemetry-ledger");
 const telemetry_attestation_1 = require("./telemetry-attestation");
+const run_export_1 = require("./run-export");
+const state_1 = require("./state");
 const execution_backend_1 = require("./execution-backend");
 /** Human-facing render of `telemetry verify <run>`. */
 function formatTelemetryVerify(r) {
@@ -164,3 +168,118 @@ function runTamperDemo(options = {}) {
         layers.every((l) => l.before.verified && !l.after.verified && l.failures.length > 0);
     return { schemaVersion: 1, runId, workers: HOPS.length, trustKey: "ephemeral-ed25519", baseline, layers, proven };
 }
+function runBundleDemo(options = {}) {
+    const workdir = options.dir || node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), "cw-bundle-demo-"));
+    node_fs_1.default.mkdirSync(workdir, { recursive: true });
+    const runId = "demo-bundle-run";
+    const runDir = node_path_1.default.join(workdir, ".cw", "runs", runId);
+    const paths = (0, state_1.createRunPaths)(runDir);
+    (0, state_1.ensureRunDirs)(paths);
+    const { publicKey, privateKey } = node_crypto_1.default.generateKeyPairSync("ed25519");
+    const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
+    const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+    // Build a real signed ledger + a cited report, the way an attested run would.
+    const ledgerRun = { id: runId, paths };
+    for (const hop of HOPS) {
+        const ctx = { runId, taskId: hop.taskId, promptDigest: hop.promptDigest };
+        (0, telemetry_ledger_1.appendTelemetryAttestation)(ledgerRun, {
+            workerId: hop.workerId,
+            taskId: hop.taskId,
+            promptDigest: hop.promptDigest,
+            reportedUsage: hop.usage,
+            usageSignature: hop.attestation === "attested" ? (0, telemetry_attestation_1.signTelemetry)(hop.usage, privateKeyPem, ctx) : undefined,
+            attestation: hop.attestation,
+            now: DEMO_NOW
+        });
+    }
+    node_fs_1.default.writeFileSync(node_path_1.default.join(runDir, "report.md"), "# Architecture review\n\nRisk: src/server.js:18 — unauthenticated route.\n", "utf8");
+    const attestedCount = HOPS.filter((h) => h.attestation === "attested").length;
+    const fullRun = {
+        schemaVersion: 1, id: runId, createdAt: DEMO_NOW, updatedAt: DEMO_NOW, cwd: workdir,
+        workflow: { id: "demo", title: "Demo", summary: "", limits: { maxAgents: 1, maxConcurrentAgents: 1 } },
+        inputs: { question: "what are the risks?" }, loopStage: "interpret",
+        phases: [], tasks: [], dispatches: [], commits: [], paths, nodes: [], contracts: []
+    };
+    (0, state_1.saveCheckpoint)(fullRun);
+    const ledgerFile = (0, telemetry_ledger_1.telemetryLedgerPath)(ledgerRun);
+    const cleanLedger = node_fs_1.default.readFileSync(ledgerFile, "utf8");
+    const exportSealed = (out) => { (0, run_export_1.exportRun)(fullRun, out, { trustPublicKey: publicKeyPem }); };
+    // Baseline: a clean sealed bundle verifies offline; the embedded key reverifies
+    // every signed hop.
+    const cleanBundle = node_path_1.default.join(workdir, "clean.cwrun.json");
+    exportSealed(cleanBundle);
+    const clean = (0, run_export_1.verifyReportBundle)(cleanBundle);
+    const baseline = { ok: clean.ok, telemetryVerified: clean.telemetryVerified, signaturesReverified: clean.signaturesReverified };
+    const layers = [];
+    // CHAIN forgery: flip record[1]'s verdict and reseal its recordHash; record[2]'s
+    // prevHash still points at the original hash, so the chain breaks — even though
+    // every archive file digest (computed at export over the tampered bytes) is valid.
+    // This is exactly what inspect-archive alone cannot catch.
+    {
+        const j = JSON.parse(cleanLedger);
+        j.records[1].attestation = "attested";
+        const { recordHash: _drop, ...rest } = j.records[1];
+        j.records[1].recordHash = (0, telemetry_ledger_1.computeRecordHash)(rest);
+        node_fs_1.default.writeFileSync(ledgerFile, JSON.stringify(j, null, 2));
+        const forged = node_path_1.default.join(workdir, "forged-chain.cwrun.json");
+        exportSealed(forged);
+        const after = (0, run_export_1.verifyReportBundle)(forged);
+        node_fs_1.default.writeFileSync(ledgerFile, cleanLedger);
+        layers.push({
+            layer: "chain",
+            tamper: `forged record[1] verdict "unattested" -> "attested" and resealed its recordHash; the archive's own file digests stay valid`,
+            before: { ok: clean.ok, detail: `${clean.signaturesReverified} signed hop(s) reverify; chain intact` },
+            after: { ok: after.ok, detail: after.telemetryVerified ? "telemetry chain still verified (UNDETECTED!)" : "the embedded hash chain broke at the next record" },
+            failures: after.ok ? [] : after.failedChecks.map((c) => `${c.name}: ${c.code}`)
+        });
+    }
+    // SIGNATURE forgery: inflate the last attested hop's reported tokens and reseal its
+    // usage digest + recordHash so the chain AND archive digests still verify; only the
+    // ed25519 signature (over the original usage) no longer matches the inflated number.
+    {
+        const j = JSON.parse(cleanLedger);
+        const idx = j.records.length - 1;
+        j.records[idx].reportedUsage = { ...j.records[idx].reportedUsage, output_tokens: j.records[idx].reportedUsage.output_tokens * 10 };
+        j.records[idx].reportedUsageDigest = (0, telemetry_ledger_1.reportedUsageDigest)(j.records[idx].reportedUsage);
+        const { recordHash: _drop, ...rest } = j.records[idx];
+        j.records[idx].recordHash = (0, telemetry_ledger_1.computeRecordHash)(rest);
+        node_fs_1.default.writeFileSync(ledgerFile, JSON.stringify(j, null, 2));
+        const forged = node_path_1.default.join(workdir, "forged-sig.cwrun.json");
+        exportSealed(forged);
+        const after = (0, run_export_1.verifyReportBundle)(forged);
+        node_fs_1.default.writeFileSync(ledgerFile, cleanLedger);
+        layers.push({
+            layer: "signature",
+            tamper: `inflated the last attested hop's output_tokens 10x and resealed its digest + recordHash; the chain stays valid`,
+            before: { ok: clean.ok, detail: `the embedded public key reverifies the original signature` },
+            after: { ok: after.ok, detail: after.signaturesFailed > 0 ? `${after.signaturesFailed} signature(s) failed ed25519 reverify` : "signature still verified (UNDETECTED!)" },
+            failures: after.ok ? [] : after.failedChecks.map((c) => `${c.name}: ${c.code}`)
+        });
+    }
+    if (!options.keepDir && !options.dir)
+        node_fs_1.default.rmSync(workdir, { recursive: true, force: true });
+    const proven = baseline.ok &&
+        baseline.telemetryVerified &&
+        baseline.signaturesReverified === attestedCount &&
+        layers.every((l) => l.before.ok && !l.after.ok && l.failures.length > 0);
+    return { schemaVersion: 1, runId, workers: HOPS.length, trustKey: "ephemeral-ed25519", baseline, layers, proven };
+}
+function formatBundleDemo(r) {
+    const lines = [];
+    lines.push(`cw demo bundle — portable-bundle verification proof (hermetic, ${r.trustKey} key)`);
+    lines.push("");
+    lines.push(`▶ Exported a sealed report bundle: ${r.workers} hops, public key embedded`);
+    lines.push(`  ${r.baseline.ok ? "✓" : "✗"} bundle verifies offline   ${r.baseline.signaturesReverified} signed hop(s) reverify with only the embedded public key`);
+    for (const l of r.layers) {
+        lines.push("");
+        lines.push(`▶ ${l.layer.toUpperCase()} forgery`);
+        lines.push(`  edit:   ${l.tamper}`);
+        lines.push(`  before: ${l.before.ok ? "✓ verifies" : "✗"} — ${l.before.detail}`);
+        lines.push(`  after:  ${l.after.ok ? "✓ (UNDETECTED!)" : "✗ DETECTED"} — ${l.after.detail}`);
+    }
+    lines.push("");
+    lines.push(r.proven
+        ? "VERDICT: bundle verification holds ✓ — every forgery caught offline with only the bundle's embedded public key. No repo, no server, no key handed over."
+        : "VERDICT: PROOF FAILED ✗ — a forged bundle verified. This is a regression in the bundle guarantee.");
+    return lines.join("\n");
+}

package/dist/types/report-bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+// Verifiable report bundle — result shapes shared across the run-export verifier,
+// the capability-core producer (reportBundle), and the quickstart auto-bundle field
+// on QuickstartResult. Kept in types/ (a leaf) so types/drive.ts can reference
+// ReportBundleResult without a types->core import cycle.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.js

@@ -28,6 +28,7 @@ __exportStar(require("./types/sandbox"), exports);
 __exportStar(require("./types/execution-backend"), exports);
 __exportStar(require("./types/boundary"), exports);
 __exportStar(require("./types/drive"), exports);
+__exportStar(require("./types/report-bundle"), exports);
 __exportStar(require("./types/multi-agent"), exports);
 __exportStar(require("./types/topology"), exports);
 __exportStar(require("./types/blackboard"), exports);

package/dist/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION = exports.LEGACY_RUN_STATE_SCHEMA_VERSION = exports.CURRENT_RUN_STATE_SCHEMA_VERSION = exports.WORKFLOW_APP_SCHEMA_VERSION = exports.CURRENT_COOL_WORKFLOW_VERSION = void 0;
-exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.83";
+exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.85";
 exports.WORKFLOW_APP_SCHEMA_VERSION = 1;
 exports.CURRENT_RUN_STATE_SCHEMA_VERSION = 1;
 exports.LEGACY_RUN_STATE_SCHEMA_VERSION = 0;

package/dist/worker-accept/acceptance.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acceptWorkerResult = acceptWorkerResult;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const state_1 = require("../state");
+const pipeline_contract_1 = require("../pipeline-contract");
+const state_node_1 = require("../state-node");
+const result_normalize_1 = require("../result-normalize");
+const trust_audit_1 = require("../trust-audit");
+/** Step 3 — recordStateNode/audit: the irreversible accept. Records the allowed
+ *  path decision, copies the result into the run results dir, completes the task,
+ *  builds + appends the result node, emits the accepted audit event, re-normalizes
+ *  node evidence against both audit ids, and surfaces the empty-capture warning.
+ *  Writes destination/pathAuditId/acceptedAuditId/resultNode back into `accept`. */
+function acceptWorkerResult(accept, delegation) {
+    const { run, workerId, scope, task, absoluteResultPath, parsedResult } = accept;
+    const { agentDelegation } = delegation;
+    const pathAudit = (0, trust_audit_1.recordSandboxPathDecision)(run, {
+        workerId,
+        taskId: task.id,
+        sandboxProfileId: scope.sandboxProfileId,
+        policySnapshot: scope.sandboxPolicy,
+        target: absoluteResultPath,
+        decision: "allowed",
+        metadata: { operation: "worker-output-acceptance" }
+    });
+    const destination = node_path_1.default.join(run.paths.resultsDir, `${(0, state_1.safeFileName)(task.id)}.md`);
+    node_fs_1.default.mkdirSync(run.paths.resultsDir, { recursive: true });
+    node_fs_1.default.copyFileSync(absoluteResultPath, destination);
+    task.status = "completed";
+    task.completedAt = new Date().toISOString();
+    task.resultPath = destination;
+    task.loopStage = "observe";
+    task.result = parsedResult;
+    const evidence = (0, trust_audit_1.normalizeEvidence)(run, parsedResult.evidence.map((entry, index) => ({
+        id: `result:${index + 1}`,
+        source: "cw:result",
+        locator: entry,
+        summary: entry
+    })), { source: "cw-validated", workerId, taskId: task.id, auditEventIds: [pathAudit.id] });
+    const resultNode = (0, state_node_1.appendRunNode)(run, (0, state_node_1.createStateNode)({
+        id: `${run.id}:result:${task.id}`,
+        kind: "result",
+        status: "completed",
+        loopStage: "observe",
+        inputs: { taskId: task.id, dispatchId: task.dispatchId, workerId },
+        outputs: parsedResult,
+        artifacts: [
+            { id: "result", kind: "markdown", path: destination },
+            { id: "worker-result", kind: "markdown", path: absoluteResultPath }
+        ],
+        evidence,
+        parents: task.dispatchId ? [`${run.id}:dispatch:${task.dispatchId}`] : [task.stateNodeId || `${run.id}:task:${task.id}`],
+        contractId: pipeline_contract_1.DEFAULT_PIPELINE_CONTRACT_ID,
+        metadata: {
+            taskId: task.id,
+            workerId,
+            workerDir: scope.workerDir,
+            sandboxProfileId: scope.sandboxProfileId,
+            auditEventIds: [pathAudit.id],
+            // Empty-capture warning (v0.1.42): even after robust normalization the result
+            // yielded NO findings and NO evidence — surfaced, never silently passed.
+            ...((0, result_normalize_1.isEmptyCapture)(parsedResult) ? { captureWarning: "no findings or evidence captured from result.md" } : {}),
+            // Folded into the snapshotted node body so v0.1.35 replay re-verifies the
+            // prompt/result/model digests WITHOUT re-spawning the agent. NOT evidence.
+            ...(agentDelegation ? { agentDelegation } : {})
+        }
+    }));
+    const acceptedAudit = (0, trust_audit_1.recordTrustAuditEvent)(run, {
+        kind: "worker.output",
+        decision: "accepted",
+        source: "cw-validated",
+        workerId,
+        taskId: task.id,
+        nodeId: resultNode.id,
+        sandboxProfileId: scope.sandboxProfileId,
+        policySnapshot: scope.sandboxPolicy,
+        normalizedPath: absoluteResultPath,
+        evidence,
+        parentEventIds: [pathAudit.id],
+        metadata: { destination }
+    });
+    resultNode.evidence = (0, trust_audit_1.normalizeEvidence)(run, resultNode.evidence, {
+        source: "cw-validated",
+        workerId,
+        taskId: task.id,
+        resultNodeId: resultNode.id,
+        auditEventIds: [pathAudit.id, acceptedAudit.id]
+    });
+    (0, state_node_1.appendRunNode)(run, resultNode);
+    task.resultNodeId = resultNode.id;
+    // Warn (don't silently pass) when a worker's result captured no structured signal
+    // at all — the v0.1.41 self-audit's "accepted with evidenceCount:0" failure mode.
+    if ((0, result_normalize_1.isEmptyCapture)(parsedResult)) {
+        (0, trust_audit_1.recordTrustAuditEvent)(run, {
+            kind: "worker.capture-warning",
+            decision: "recorded",
+            source: "cw-validated",
+            workerId,
+            taskId: task.id,
+            nodeId: resultNode.id,
+            parentEventIds: [acceptedAudit.id],
+            metadata: { reason: "no findings or evidence captured from result.md", resultPath: destination }
+        });
+    }
+    accept.destination = destination;
+    accept.pathAuditId = pathAudit.id;
+    accept.acceptedAuditId = acceptedAudit.id;
+    accept.resultNode = resultNode;
+}

package/dist/worker-accept/blackboard-fanout.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fanOutWorkerOutput = fanOutWorkerOutput;
+const coordinator_1 = require("../coordinator");
+const multi_agent_1 = require("../multi-agent");
+const blackboard_linkage_1 = require("./blackboard-linkage");
+/** Step 7 — fanOut: publish the accepted output to the blackboard and record the
+ *  multi-agent worker output (linking the blackboard message/artifact refs). */
+function fanOutWorkerOutput(accept) {
+    const { run, workerId, scope, task, absoluteResultPath, parsedResult, destination, resultNode, verifierNodeId, acceptedAuditId } = accept;
+    const blackboardLinks = publishWorkerOutputToBlackboard(run, scope, task, parsedResult.summary, destination, absoluteResultPath, resultNode.evidence, acceptedAuditId);
+    (0, multi_agent_1.recordMultiAgentWorkerOutput)(run, {
+        workerId,
+        taskId: task.id,
+        resultNodeId: resultNode.id,
+        verifierNodeId,
+        evidence: resultNode.evidence,
+        artifactPaths: [destination, absoluteResultPath],
+        blackboardMessageIds: blackboardLinks.messageIds,
+        blackboardArtifactRefIds: blackboardLinks.artifactRefIds
+    });
+}
+function publishWorkerOutputToBlackboard(run, scope, task, summary, destination, workerResultPath, evidence, acceptedAuditId) {
+    const linkage = (0, blackboard_linkage_1.blackboardLinkage)(run, scope);
+    if (!linkage.blackboardId || !linkage.topicIds.length)
+        return { messageIds: [], artifactRefIds: [] };
+    const topicId = linkage.topicIds[0];
+    const artifactRefs = [
+        (0, coordinator_1.addBlackboardArtifact)(run, {
+            topicId,
+            blackboardId: linkage.blackboardId,
+            kind: "worker-result",
+            path: destination,
+            owner: { kind: "worker", id: scope.id },
+            author: { kind: "runtime", id: "cw" },
+            source: "cw-validated-worker-output",
+            provenance: {
+                workerId: scope.id,
+                taskId: task.id,
+                multiAgentRunId: scope.multiAgent?.runId,
+                agentGroupId: scope.multiAgent?.groupId,
+                agentRoleId: scope.multiAgent?.roleId,
+                agentMembershipId: scope.multiAgent?.membershipId,
+                auditEventIds: [acceptedAuditId]
+            },
+            evidenceRefs: evidence.map((entry) => entry.locator || entry.path || entry.summary || entry.id).filter(Boolean),
+            auditEventIds: [acceptedAuditId],
+            metadata: { workerResultPath }
+        })
+    ];
+    const message = (0, coordinator_1.postBlackboardMessage)(run, {
+        topicId,
+        blackboardId: linkage.blackboardId,
+        body: summary,
+        author: { kind: "worker", id: scope.id },
+        scope: { kind: "worker", id: scope.id },
+        artifactRefIds: artifactRefs.map((artifact) => artifact.id),
+        evidenceRefs: evidence.map((entry) => entry.locator || entry.path || entry.summary || entry.id).filter(Boolean),
+        auditEventIds: [acceptedAuditId],
+        links: {
+            multiAgentRunId: scope.multiAgent?.runId,
+            agentGroupId: scope.multiAgent?.groupId,
+            agentRoleId: scope.multiAgent?.roleId,
+            agentMembershipId: scope.multiAgent?.membershipId,
+            agentFanoutId: scope.multiAgent?.fanoutId,
+            taskId: task.id,
+            workerId: scope.id,
+            auditEventIds: [acceptedAuditId]
+        },
+        metadata: {
+            taskId: task.id,
+            resultPath: destination,
+            multiAgent: scope.multiAgent
+        }
+    });
+    return {
+        messageIds: [message.id],
+        artifactRefIds: artifactRefs.map((artifact) => artifact.id)
+    };
+}

package/dist/worker-accept/blackboard-linkage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blackboardLinkage = blackboardLinkage;
+const helpers_1 = require("../worker-isolation/helpers");
+function blackboardLinkage(run, scope) {
+    const membershipId = scope.multiAgent?.membershipId;
+    const membership = membershipId ? run.multiAgent?.memberships.find((entry) => entry.id === membershipId) : undefined;
+    const group = scope.multiAgent?.groupId ? run.multiAgent?.groups.find((entry) => entry.id === scope.multiAgent?.groupId) : undefined;
+    const role = scope.multiAgent?.roleId ? run.multiAgent?.roles.find((entry) => entry.id === scope.multiAgent?.roleId) : undefined;
+    const multiAgentRun = scope.multiAgent?.runId ? run.multiAgent?.runs.find((entry) => entry.id === scope.multiAgent?.runId) : undefined;
+    const blackboardId = membership?.blackboardId || group?.blackboardId || role?.blackboardId || multiAgentRun?.blackboardId;
+    const topicIds = (0, helpers_1.unique)([
+        ...(membership?.topicIds || []),
+        ...(group?.topicIds || []),
+        ...(role?.topicIds || []),
+        ...(multiAgentRun?.topicIds || [])
+    ]);
+    return { blackboardId, topicIds };
+}

package/dist/worker-accept/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });