cool-workflow 0.1.98 → 0.2.1

package/dist/workbench.js

@@ -1,192 +0,0 @@
-"use strict";
-// Web / Desktop Workbench core (v0.1.30) — the SINGLE source of the human
-// console's view models, and a THIRD FRONT DOOR over ONE mechanism.
-//
-// BSD discipline:
-//  - MECHANISM VS POLICY. The kernel + durable `.cw/` state are the mechanism.
-//    The CLI renders for human speed, MCP for machine context, and the Workbench
-//    for human inspection at a glance. All three are presentation POLICY over the
-//    same data. This module computes, decides, and stores NOTHING the CLI/MCP
-//    cannot already produce — every panel embeds, verbatim, the canonical
-//    `--json` payload of ONE already-declared capability, assembled by calling
-//    the SAME runner core entries the CLI and MCP route through.
-//  - NO HIDDEN DASHBOARD. These are DERIVED, read-only projections. They hold no
-//    authoritative state; refresh re-derives everything from disk. Delete the
-//    host process and nothing is lost — the data is the files.
-//  - EXPLICIT, INSPECTABLE, FAIL CLOSED. When a source capability is unreadable
-//    (e.g. a run with no blackboard yet, or unresolvable state), the panel is
-//    rendered `absent` with the honest error; we never fabricate a view.
-//
-// See docs/web-desktop-workbench.7.md, src/capability-registry.ts, and the
-// v0.1.27 parity contract (docs/cli-mcp-parity.7.md).
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORKBENCH_UI_RELATIVE = exports.WORKBENCH_DEFAULT_PORT = void 0;
-exports.buildWorkbenchRunView = buildWorkbenchRunView;
-exports.buildWorkbenchIndex = buildWorkbenchIndex;
-exports.workbenchUiRoot = workbenchUiRoot;
-exports.buildWorkbenchServeDescriptor = buildWorkbenchServeDescriptor;
-const capability_core_1 = require("./capability-core");
-const node_path_1 = __importDefault(require("node:path"));
-const node_fs_1 = __importDefault(require("node:fs"));
-/** Default loopback port. Local by default, least privilege — never a public
- *  interface. Overridable with `--port`. */
-exports.WORKBENCH_DEFAULT_PORT = 7717;
-/** Relative location of the optional, dependency-light static UI assets. Kept
- *  OUT of the kernel: the host reads them lazily at request time, so the framework
- *  builds and runs with the Workbench (and these files) absent. */
-exports.WORKBENCH_UI_RELATIVE = node_path_1.default.join("ui", "workbench");
-// ---------------------------------------------------------------------------
-// Panel assembly — each panel IS one capability payload, embedded verbatim.
-// ---------------------------------------------------------------------------
-/** Render one panel by invoking its single source capability. On success `data`
- *  equals `cw <cmd> --json` byte-for-byte; on failure the panel is `absent` with
- *  the honest reason (fail closed) — exactly what the CLI would report. */
-function panel(capability, cli, mcp, produce) {
-    try {
-        return { capability, cli, mcp, status: "present", data: produce() };
-    }
-    catch (error) {
-        return { capability, cli, mcp, status: "absent", error: error instanceof Error ? error.message : String(error) };
-    }
-}
-function buildPanels(runner, runId) {
-    return {
-        // Run graph — operator + multi-agent, including the v0.1.25 compact and
-        // critical-path views. Backend ids/attestations (v0.1.29) ride on the nodes.
-        graph: {
-            operator: panel("graph", `cw graph ${runId} --json`, "cw_operator_graph", () => runner.operatorGraph(runId)),
-            multiAgent: panel("multi-agent.graph", `cw multi-agent graph ${runId} --json`, "cw_multi_agent_graph", () => runner.multiAgentOperatorGraph(runId)),
-            compact: panel("multi-agent.graph.compact", `cw multi-agent graph ${runId} --view compact --json`, "cw_multi_agent_graph_compact", () => runner.multiAgentGraphView(runId, { view: "compact" })),
-            criticalPath: panel("multi-agent.graph.compact", `cw multi-agent graph ${runId} --view critical-path --json`, "cw_multi_agent_graph_compact", () => runner.multiAgentGraphView(runId, { view: "critical-path" }))
-        },
-        // Blackboard — coordinator topics/messages/contexts/artifacts/snapshots/
-        // decisions/conflicts/adopted+missing evidence.
-        blackboard: {
-            coordinator: panel("coordinator.summary", `cw coordinator summary ${runId}`, "cw_coordinator_summary", () => runner.coordinatorSummary(runId)),
-            digest: panel("blackboard.summarize", `cw blackboard summarize ${runId} --json`, "cw_blackboard_summarize", () => runner.blackboardSummarize(runId)),
-            graph: panel("blackboard.graph", `cw blackboard graph ${runId}`, "cw_blackboard_graph", () => runner.blackboardGraph(runId))
-        },
-        // Worker logs — manifests, outputs, scoped results, failures, and the
-        // recorded execution backend + sandbox attestation.
-        worker: {
-            summary: panel("worker.summary", `cw worker summary ${runId} --json`, "cw_worker_summary", () => runner.summarizeWorkerRecords(runId))
-        },
-        // Candidate compare — scores/selection/rejection, plus the v0.1.26
-        // evidence-adoption reasoning chain (why adopted).
-        candidate: {
-            summary: panel("candidate.summary", `cw candidate summary ${runId} --json`, "cw_candidate_summary", () => runner.summarizeCandidateOperatorRecords(runId)),
-            reasoning: panel("multi-agent.reasoning", `cw multi-agent reasoning ${runId} --json`, "cw_evidence_reasoning", () => runner.multiAgentReasoning(runId))
-        },
-        // Observability + cost (v0.1.31) — durations, failure/verifier/acceptance
-        // rates with sample counts, attested usage + cost, coverage, `unreported`/
-        // `n/a` shown honestly. Equals `cw metrics show <run> --json` byte-for-byte.
-        metrics: {
-            report: panel("metrics.show", `cw metrics show ${runId} --json`, "cw_metrics_show", () => runner.metricsShow(runId))
-        },
-        // Audit timeline — trust-audit events, role policy decisions, provenance,
-        // judge/chair rationale, and policy violations.
-        audit: {
-            summary: panel("audit.summary", `cw audit summary ${runId}`, "cw_audit_summary", () => runner.auditSummary(runId)),
-            multiAgent: panel("audit.multi-agent", `cw audit multi-agent ${runId} --json`, "cw_audit_multi_agent", () => runner.auditMultiAgent(runId)),
-            policy: panel("audit.policy", `cw audit policy ${runId} --json`, "cw_audit_policy", () => runner.auditPolicy(runId)),
-            judge: panel("audit.judge", `cw audit judge ${runId} --json`, "cw_audit_judge", () => runner.auditJudge(runId))
-        },
-        // Collaboration (v0.1.32) — derived per-target review state (pending/approved/
-        // rejected/blocked/unattributed, required vs recorded), the append-only
-        // approval/comment/handoff timeline, and the run owner. Read-only; equals
-        // `cw review status <run> --json` and `cw comment list <run> --json`.
-        collaboration: {
-            review: panel("review.status", `cw review status ${runId} --json`, "cw_review_status", () => runner.reviewStatus(runId)),
-            comments: panel("comment.list", `cw comment list ${runId} --json`, "cw_comment_list", () => runner.collaborationCommentList(runId))
-        }
-    };
-}
-/** Assemble the read-only five-panel view of ONE run. The run is first resolved
- *  from its durable `.cw/runs/<id>/state.json`; when that source is unreadable
- *  the view is `resolved: false` and every panel is `absent` — fail closed,
- *  never fabricated. */
-function buildWorkbenchRunView(runner, runId) {
-    const id = String(runId || "");
-    return runner.loadWithCache((r) => {
-        let resolved = true;
-        let error;
-        try {
-            r.loadRun(id);
-        }
-        catch (caught) {
-            resolved = false;
-            error = caught instanceof Error ? caught.message : String(caught);
-        }
-        return {
-            schemaVersion: 1,
-            surface: "workbench",
-            runId: id,
-            resolved,
-            ...(error ? { error } : {}),
-            panels: buildPanels(r, id)
-        };
-    });
-}
-// ---------------------------------------------------------------------------
-// Cross-run entry (v0.1.28 Run Registry) — composed from already-declared
-// capabilities; adds NO new source of truth.
-// ---------------------------------------------------------------------------
-/** Build the cross-run index: the registry index plus the run list (or a
- *  filtered search). Each field equals the corresponding `cw <cmd> --json`
- *  payload; the Workbench can show nothing the CLI/MCP cannot. */
-function buildWorkbenchIndex(runner, args = {}) {
-    const scope = args.scope === "repo" ? "repo" : "home";
-    const scoped = { ...args, scope };
-    const registry = (0, capability_core_1.runRegistryShow)((0, capability_core_1.runRegistryFor)(scoped, runner), scoped);
-    const filtered = Boolean(args.text || args.q || args.query || args.app || args.appId || args.status || args.repo || args.since || args.until);
-    const runs = filtered ? (0, capability_core_1.runSearch)((0, capability_core_1.runRegistryFor)(scoped, runner), scoped) : (0, capability_core_1.runList)((0, capability_core_1.runRegistryFor)(scoped, runner), scoped);
-    return { schemaVersion: 1, surface: "workbench", command: "index", scope, registry, runs };
-}
-// ---------------------------------------------------------------------------
-// Serve descriptor — describes the OPTIONAL localhost host (no state).
-// ---------------------------------------------------------------------------
-/** Absolute path to the optional static UI assets for this plugin install. */
-function workbenchUiRoot(runner) {
-    return node_path_1.default.join(runner.pluginRoot, exports.WORKBENCH_UI_RELATIVE);
-}
-/** The canonical `cw workbench serve` payload: a description of the localhost
- *  bind and its read-only routes. Holds zero authoritative state. The CLI emits
- *  this under `--json`/`--once`; `cw_workbench_serve` returns it directly. */
-function buildWorkbenchServeDescriptor(runner, args = {}) {
-    const scope = args.scope === "repo" ? "repo" : "home";
-    const root = node_path_1.default.resolve(String(args.cwd || process.cwd()));
-    const portRaw = Number(args.port);
-    const port = Number.isFinite(portRaw) && portRaw > 0 ? Math.floor(portRaw) : exports.WORKBENCH_DEFAULT_PORT;
-    const uiRoot = workbenchUiRoot(runner);
-    return {
-        schemaVersion: 1,
-        surface: "workbench",
-        command: "serve",
-        host: "127.0.0.1",
-        port,
-        once: Boolean(args.once),
-        readOnly: true,
-        scope,
-        root,
-        uiAvailable: dirExists(uiRoot),
-        uiRoot,
-        routes: [
-            { method: "GET", path: "/", description: "Workbench UI shell (static, dependency-light)." },
-            { method: "GET", path: "/ui/*", description: "Static UI assets (read from disk; absent if not installed)." },
-            { method: "GET", path: "/api/index", description: "Cross-run index: registry show + run list/search (v0.1.28)." },
-            { method: "GET", path: "/api/serve", description: "This serve descriptor." },
-            { method: "GET", path: "/api/run/:runId", description: "Five-panel WorkbenchRunView for one run (read-only)." }
-        ]
-    };
-}
-function dirExists(target) {
-    try {
-        return node_fs_1.default.statSync(target).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/worker-accept/acceptance.js

@@ -1,114 +0,0 @@
-"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

@@ -1,80 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-"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

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

package/dist/worker-accept/telemetry-ledger.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attestWorkerDelegation = attestWorkerDelegation;
-exports.recordWorkerDelegationLedger = recordWorkerDelegationLedger;
-const execution_backend_1 = require("../execution-backend");
-const telemetry_attestation_1 = require("../telemetry-attestation");
-const telemetry_ledger_1 = require("../telemetry-ledger");
-const trust_audit_1 = require("../trust-audit");
-const helpers_1 = require("../worker-isolation/helpers");
-/** Step 2 — attestSandbox/attestDelegation: verify the agent's signed telemetry
- *  BEFORE recording it, enforce the opt-in require-attested-telemetry gate (still
- *  fail-closed, pre-mutation), and build the agent-hop provenance. Non-agent hops
- *  return an empty delegation. */
-function attestWorkerDelegation(accept, deps) {
-    const { run, workerId, options, task, absoluteResultPath, rawResult } = accept;
-    // Agent Delegation Drive (v0.1.38): if this worker's result.md was produced by an
-    // EXTERNAL agent, record the agent-hop attestation AS PROVENANCE — the agent
-    // (kind:process) handle, the agent-REPORTED model (never CW_AGENT_MODEL), the
-    // prompt digest, the secret-stripped args, and the result digest computed HERE
-    // from the accepted result.md. These live in the result node's metadata (covered
-    // by the v0.1.35 snapshot body) + a trust-audit event, NEVER in `evidence`.
-    // Track 1: verify the agent's signed telemetry BEFORE recording it. CW holds
-    // only the operator's PUBLIC key — it verifies attribution, never measures
-    // usage. Absent/invalid signature => `unattested`/`absent`, surfaced loudly,
-    // NEVER silently recorded as trusted.
-    const telemetry = options.agentDelegation
-        ? (0, telemetry_attestation_1.verifyTelemetryAttestation)(options.agentDelegation.reportedUsage, options.agentDelegation.usageSignature, (0, telemetry_attestation_1.resolveTrustPublicKey)(options.agentDelegation.usageTrustPublicKey), 
-        // resultDigest binds the agent's findings into the signature: CW recomputes
-        // the digest from the accepted result (the SAME raw bytes the executor
-        // signed) so a result edited after signing fails verification. A signer
-        // that did not cover the result still verifies (verifier back-compat).
-        { runId: run.id, taskId: task.id, promptDigest: options.agentDelegation.promptDigest, resultDigest: (0, execution_backend_1.sha256)(rawResult) })
-        : undefined;
-    // Track 1 fail-closed (Decision 2 — OPT-IN, off by default). 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. Default behavior is unchanged
-    // (flag-and-surface). Non-agent hops carry no verdict and are never blocked.
-    if (options.requireAttestedTelemetry && telemetry && telemetry.status !== "attested") {
-        const error = (0, helpers_1.structuredError)("telemetry-unattested-blocked", `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`, { path: absoluteResultPath, retryable: false });
-        deps.recordWorkerFailure(run, workerId, error, { ...options, persist: options.persist });
-        throw new Error(error.message);
-    }
-    const agentDelegation = options.agentDelegation
-        ? {
-            schemaVersion: 1,
-            backendId: "agent",
-            handle: options.agentDelegation.handle,
-            model: options.agentDelegation.model,
-            promptDigest: options.agentDelegation.promptDigest,
-            resultDigest: (0, execution_backend_1.sha256)(rawResult),
-            command: options.agentDelegation.command,
-            args: options.agentDelegation.args,
-            exitCode: options.agentDelegation.exitCode,
-            ...(options.agentDelegation.reportedUsage ? { reportedUsage: options.agentDelegation.reportedUsage } : {}),
-            ...(options.agentDelegation.usageSignature ? { usageSignature: options.agentDelegation.usageSignature } : {}),
-            ...(telemetry ? { usageAttestation: telemetry.status, usageAttestationReason: telemetry.reason } : {})
-        }
-        : undefined;
-    return { agentDelegation, telemetry };
-}
-/** Step 4 — recordTelemetryLedger: the agent-hop attestation. Binds the telemetry
- *  verdict into the append-only hash-chained ledger BEFORE the audit event (so the
- *  event can cross-link the record hash), then emits the worker.agent-delegation
- *  audit event. No-op for non-agent hops. */
-function recordWorkerDelegationLedger(accept, delegation) {
-    const { agentDelegation, telemetry } = delegation;
-    // The agent-hop attestation event — hung off worker.output, alongside
-    // worker.backend. Recorded in trust-audit/provenance, NEVER in node evidence.
-    if (!agentDelegation)
-        return;
-    const { run, workerId, scope, task, resultNode, acceptedAuditId } = accept;
-    // Track 1 (tamper-evidence): bind this verdict into the append-only,
-    // hash-chained telemetry ledger BEFORE the audit event, so the event can
-    // cross-link the record hash. Editing the recorded verdict/usage later breaks
-    // the chain (verifyTelemetryLedger). Only when a verdict was computed.
-    const ledgerRecord = agentDelegation.usageAttestation
-        ? (0, telemetry_ledger_1.appendTelemetryAttestation)(run, {
-            workerId,
-            taskId: task.id,
-            promptDigest: agentDelegation.promptDigest,
-            reportedUsage: agentDelegation.reportedUsage,
-            usageSignature: agentDelegation.usageSignature,
-            // Store the signed result digest ONLY when the signature actually covered
-            // it, so the offline re-verifier (telemetry verify --pubkey / report verify)
-            // can reconstruct the 5-field payload. A usage-only signature stores none
-            // (its record stays byte-identical to a pre-result-coverage one).
-            resultDigest: telemetry?.coversResult ? agentDelegation.resultDigest : undefined,
-            attestation: agentDelegation.usageAttestation,
-            attestationReason: agentDelegation.usageAttestationReason
-        })
-        : undefined;
-    (0, trust_audit_1.recordTrustAuditEvent)(run, {
-        kind: "worker.agent-delegation",
-        decision: "recorded",
-        source: "host-attested",
-        workerId,
-        taskId: task.id,
-        nodeId: resultNode.id,
-        sandboxProfileId: scope.sandboxProfileId,
-        policySnapshot: scope.sandboxPolicy,
-        parentEventIds: [acceptedAuditId],
-        metadata: {
-            backendId: agentDelegation.backendId,
-            handleKind: agentDelegation.handle.kind,
-            handleRef: agentDelegation.handle.ref,
-            model: agentDelegation.model,
-            promptDigest: agentDelegation.promptDigest,
-            resultDigest: agentDelegation.resultDigest,
-            command: agentDelegation.command,
-            args: agentDelegation.args,
-            exitCode: agentDelegation.exitCode,
-            // Track 1: the telemetry verdict travels with the agent-hop event so the
-            // audit report can surface `unattested` usage loudly. Absent => no usage.
-            ...(agentDelegation.usageAttestation
-                ? {
-                    telemetryAttestation: agentDelegation.usageAttestation,
-                    ...(agentDelegation.usageAttestationReason ? { telemetryAttestationReason: agentDelegation.usageAttestationReason } : {}),
-                    ...(agentDelegation.reportedUsage ? { reportedUsage: agentDelegation.reportedUsage } : {}),
-                    // Cross-link to the hash-chained ledger entry (tamper-evidence).
-                    ...(ledgerRecord ? { telemetryRecordId: ledgerRecord.recordId, telemetryRecordHash: ledgerRecord.recordHash, telemetryPrevHash: ledgerRecord.prevHash } : {})
-                }
-                : {})
-        }
-    });
-}

package/dist/worker-accept/validation.js

@@ -1,77 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateWorkerResult = validateWorkerResult;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const verifier_1 = require("../verifier");
-const evidence_grounding_1 = require("../evidence-grounding");
-const trust_audit_1 = require("../trust-audit");
-const helpers_1 = require("../worker-isolation/helpers");
-/** Step 1 — validateResult: resolve scope/task, enforce the sandbox boundary, the
- *  result-file existence, the envelope contract, and (opt-in) resolvable evidence.
- *  Fail-closed: any guard records a worker failure and throws BEFORE accept-side
- *  state mutation. Returns the partially-filled accept context on success. */
-function validateWorkerResult(run, workerId, resultPath, options, deps) {
-    const scope = deps.requireWorkerScope(run, workerId);
-    const task = deps.requireWorkerTask(run, scope);
-    const absoluteResultPath = node_path_1.default.resolve(resultPath);
-    const violation = deps.validateWorkerBoundary(run, workerId, { ...options, policy: options.policy, path: absoluteResultPath });
-    if (violation) {
-        (0, trust_audit_1.recordSandboxPathDecision)(run, {
-            workerId,
-            taskId: task.id,
-            sandboxProfileId: scope.sandboxProfileId,
-            policySnapshot: scope.sandboxPolicy,
-            target: absoluteResultPath,
-            decision: "denied",
-            metadata: { code: violation.code, allowedPaths: violation.allowedPaths }
-        });
-        deps.recordWorkerFailure(run, workerId, violation, { ...options, path: absoluteResultPath, code: violation.code, retryable: false });
-        throw new Error(violation.message);
-    }
-    if (!node_fs_1.default.existsSync(absoluteResultPath)) {
-        const error = (0, helpers_1.structuredError)("worker-result-missing", `Worker result file does not exist: ${absoluteResultPath}`, {
-            path: absoluteResultPath,
-            retryable: true
-        });
-        deps.recordWorkerFailure(run, workerId, error, { ...options, persist: options.persist });
-        throw new Error(error.message);
-    }
-    const rawResult = node_fs_1.default.readFileSync(absoluteResultPath, "utf8");
-    const parsedResult = (0, verifier_1.parseResultEnvelope)(rawResult);
-    (0, verifier_1.validateResultEnvelope)(task, parsedResult);
-    // Strict evidence resolution (v0.1.40 self-audit P1, opt-in via
-    // CW_REQUIRE_RESOLVABLE_EVIDENCE): fail closed if the result cites file-style
-    // evidence that does not resolve on disk, so a worker cannot land a result
-    // whose evidence locators point nowhere. Off by default — the default gate is
-    // the deterministic grounding check in validateResultEnvelope.
-    if ((0, evidence_grounding_1.requireResolvableEvidence)()) {
-        const baseDirs = Array.from(new Set([run.cwd, process.cwd(), scope.workerDir, run.paths.runDir].filter(Boolean)));
-        const unresolved = (0, evidence_grounding_1.unresolvedFileEvidence)(parsedResult.evidence, baseDirs);
-        if (unresolved.length) {
-            const error = (0, helpers_1.structuredError)("worker-evidence-unresolvable", `Worker ${workerId} result cites file evidence that does not resolve on disk: ${unresolved.join(", ")}`, { path: absoluteResultPath, retryable: false });
-            deps.recordWorkerFailure(run, workerId, error, { ...options, persist: options.persist });
-            throw new Error(error.message);
-        }
-    }
-    return {
-        run,
-        workerId,
-        options,
-        scope,
-        task,
-        absoluteResultPath,
-        rawResult,
-        parsedResult,
-        destination: "",
-        pathAuditId: "",
-        acceptedAuditId: "",
-        resultNode: undefined,
-        verifierNodeId: "",
-        verifierStatus: "",
-        output: undefined
-    };
-}