cool-workflow 0.1.98 → 0.2.0

package/dist/shell/execution-backend/registry.js

@@ -0,0 +1,402 @@
+"use strict";
+// shell/execution-backend/registry.ts — the 7-driver registry: DRIVER_SPECS,
+// registerBackend, resolveBackendSelection, attestSandbox, probeBackend,
+// runBackend, and the CLI-facing inspection payloads.
+//
+// MILESTONE 5 (v2/PLAN.md build order, step 5). Byte-exact port of
+// plugins/cool-workflow/src/execution-backend.ts (the parts not carved into
+// local.ts/container.ts/remote.ts/ci.ts/agent.ts/probes.ts).
+//
+// Evidence: SPEC/execution-backend.md "The driver registry".
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasExecutable = exports.BackendError = exports.SANDBOX_DIMENSIONS = exports.DEFAULT_BACKEND_ID = exports.EXECUTION_BACKEND_SCHEMA_VERSION = void 0;
+exports.registerBackend = registerBackend;
+exports.getBackendDriver = getBackendDriver;
+exports.listBackendDescriptors = listBackendDescriptors;
+exports.backendIds = backendIds;
+exports.isBackendId = isBackendId;
+exports.getBackendDescriptor = getBackendDescriptor;
+exports.resolveBackendSelection = resolveBackendSelection;
+exports.requiredSandboxDimensions = requiredSandboxDimensions;
+exports.attestSandbox = attestSandbox;
+exports.probeBackend = probeBackend;
+exports.runBackend = runBackend;
+exports.createExecutionBackend = createExecutionBackend;
+exports.backendListPayload = backendListPayload;
+exports.backendShowPayload = backendShowPayload;
+exports.backendProbePayload = backendProbePayload;
+const probes_1 = require("./probes");
+Object.defineProperty(exports, "hasExecutable", { enumerable: true, get: function () { return probes_1.hasExecutable; } });
+const local_1 = require("./local");
+const envelopes_1 = require("./envelopes");
+const container_1 = require("./container");
+const remote_1 = require("./remote");
+const ci_1 = require("./ci");
+const agent_1 = require("./agent");
+exports.EXECUTION_BACKEND_SCHEMA_VERSION = 1;
+exports.DEFAULT_BACKEND_ID = "node";
+exports.SANDBOX_DIMENSIONS = ["read", "write", "command", "network", "env"];
+class BackendError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "BackendError";
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.BackendError = BackendError;
+const DRIVER_SPECS = [
+    {
+        id: "node",
+        title: "Node (default)",
+        description: "Default backend. Reproduces pre-v0.1.29 behavior exactly: the host runs the worker in-process under CW's worker-output acceptance. When executing a command it enforces the command + env policy via the Node child process and attests OS read/write/network isolation to the host.",
+        kind: "local",
+        locality: "local",
+        default: true,
+        readiness: "ready",
+        support: { read: "attest", write: "attest", command: "enforce", network: "attest", env: "enforce" },
+    },
+    {
+        id: "bun",
+        title: "Bun",
+        description: "Bun-friendly backend. Node-compatible by default: it executes via the Node-compatible runtime so evidence is byte-stable with the node backend, and attests Bun availability in provenance. Enforces command + env via the child process; attests read/write/network to the host.",
+        kind: "local",
+        locality: "local",
+        default: false,
+        delegate: "bun",
+        readiness: "ready",
+        support: { read: "attest", write: "attest", command: "enforce", network: "attest", env: "enforce" },
+    },
+    {
+        id: "shell",
+        title: "Shell",
+        description: "Runs a command/worker via the system shell (/bin/sh -c) under the sandbox contract. Enforces command + env via the child process; attests read/write/network to the host.",
+        kind: "local",
+        locality: "local",
+        default: false,
+        delegate: "/bin/sh",
+        readiness: "ready",
+        support: { read: "attest", write: "attest", command: "enforce", network: "attest", env: "enforce" },
+    },
+    {
+        id: "container",
+        title: "Container",
+        description: "Delegates execution to a container runtime (docker/podman) and records the image@digest handle + attestation + result. A container can enforce all five dimensions via mounts, dropped capabilities, a network namespace, and a filtered env. Fails closed when no image is supplied or no runtime is present.",
+        kind: "delegating",
+        locality: "local",
+        default: false,
+        delegate: "docker",
+        readiness: "unverified",
+        support: { read: "enforce", write: "enforce", command: "enforce", network: "enforce", env: "enforce" },
+    },
+    {
+        id: "remote",
+        title: "Remote Runner",
+        description: "Delegates execution to a remote runner and records the endpoint + job handle + attestation + result. Enforces command + env at the remote; attests read/write/network. Fails closed when no endpoint is configured.",
+        kind: "delegating",
+        locality: "remote",
+        default: false,
+        delegate: "remote-runner",
+        readiness: "unverified",
+        support: { read: "attest", write: "attest", command: "enforce", network: "attest", env: "enforce" },
+    },
+    {
+        id: "ci",
+        title: "CI Runner",
+        description: "Delegates execution to a CI runner and records the job handle + attestation + result. Enforces command + env in the CI job; attests read/write/network. Fails closed when no CI job target is configured.",
+        kind: "delegating",
+        locality: "remote",
+        default: false,
+        delegate: "ci-runner",
+        readiness: "unverified",
+        support: { read: "attest", write: "attest", command: "enforce", network: "attest", env: "enforce" },
+    },
+    {
+        id: "agent",
+        title: "Agent (external process)",
+        description: "Delegates each worker to an EXTERNAL agent process (claude -p / codex exec / an HTTP agent endpoint) and records the agent CHILD's command + exit + stdout digest as the canonical evidence triple, plus a kind:process handle and the agent-reported model + prompt/result digests as provenance. The MODEL runs in the agent's process, NEVER in CW — CW imports no model SDK and holds no API key; it spawns an out-of-process child argv-style (shell:false) or POSTs to a configured endpoint. CW enforces only the exact argv it spawns; the agent host attests read/write/network/env. Fails closed when no command-template/endpoint is configured, on non-zero exit, or on a missing/invalid result.md.",
+        kind: "delegating",
+        locality: "local",
+        default: false,
+        delegate: "agent-process",
+        readiness: "unverified",
+        support: { read: "attest", write: "attest", command: "enforce", network: "attest", env: "attest" },
+    },
+];
+function specCapabilities(spec) {
+    return exports.SANDBOX_DIMENSIONS.map((dimension) => ({ dimension, support: spec.support[dimension] }));
+}
+function specDescriptor(spec) {
+    const capabilities = specCapabilities(spec);
+    return {
+        schemaVersion: 1,
+        id: spec.id,
+        title: spec.title,
+        description: spec.description,
+        kind: spec.kind,
+        locality: spec.locality,
+        default: spec.default,
+        capabilities,
+        enforces: capabilities.filter((cap) => cap.support === "enforce").map((cap) => cap.dimension),
+        attests: capabilities.filter((cap) => cap.support === "attest").map((cap) => cap.dimension),
+        delegate: spec.delegate,
+        readiness: spec.readiness,
+    };
+}
+const BACKEND_REGISTRY = new Map();
+/** Register (or override) a backend driver. The public extension seam. */
+function registerBackend(driver) {
+    BACKEND_REGISTRY.set(driver.spec.id, driver);
+}
+function getBackendDriver(id) {
+    return BACKEND_REGISTRY.get(id);
+}
+function registeredDrivers() {
+    return [...BACKEND_REGISTRY.values()];
+}
+function listBackendDescriptors() {
+    return registeredDrivers()
+        .map((driver) => specDescriptor(driver.spec))
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
+function backendIds() {
+    return registeredDrivers()
+        .map((driver) => driver.spec.id)
+        .sort();
+}
+function isBackendId(id) {
+    return Boolean(id) && BACKEND_REGISTRY.has(id);
+}
+function getBackendDescriptor(id) {
+    const driver = BACKEND_REGISTRY.get(id);
+    if (!driver) {
+        throw new BackendError("backend-not-found", `Execution backend not found: ${id}`, { backendId: id, available: backendIds() });
+    }
+    return specDescriptor(driver.spec);
+}
+function ctxDelegate(impl) {
+    return (ctx) => impl(ctx.descriptor, ctx.policy, ctx.request, ctx.label, ctx.handle, ctx.attestation);
+}
+const BUILTIN_DRIVER_BEHAVIORS = {
+    node: { spawnStyle: "direct", runtimeNote: () => (0, local_1.runtimeNoteFor)("node"), probe: probes_1.probeNodeBackend },
+    bun: { spawnStyle: "direct", runtimeNote: () => (0, local_1.runtimeNoteFor)("bun"), probe: probes_1.probeBunBackend },
+    shell: { spawnStyle: "shell", runtimeNote: () => (0, local_1.runtimeNoteFor)("shell"), probe: probes_1.probeShellBackend },
+    container: { delegateRun: ctxDelegate(container_1.runContainer), buildHandle: container_1.containerHandle, probe: probes_1.probeContainerBackend },
+    remote: { delegateRun: ctxDelegate(remote_1.runHttpDelegation), buildHandle: remote_1.remoteHandle, probe: probes_1.probeRemoteBackend },
+    ci: { delegateRun: ctxDelegate(ci_1.runCiDelegation), buildHandle: ci_1.ciHandle, probe: probes_1.probeCiBackend },
+    agent: {
+        delegateRun: (ctx) => (0, agent_1.runAgentProcess)(ctx.descriptor, ctx.policy, ctx.request, ctx.label, ctx.attestation),
+        buildHandle: agent_1.agentHandle,
+        commandlessDelegate: true,
+        probe: probes_1.probeAgentBackend,
+    },
+};
+for (const spec of DRIVER_SPECS) {
+    registerBackend({ spec, ...(BUILTIN_DRIVER_BEHAVIORS[spec.id] || {}) });
+}
+// ---------------------------------------------------------------------------
+// Selection & resolution. `--backend <id>` (flag) > CW_BACKEND (env) > default.
+// ---------------------------------------------------------------------------
+function resolveBackendSelection(requested, env = process.env) {
+    const normalizedRequested = requested && requested.trim() ? requested.trim() : undefined;
+    if (normalizedRequested) {
+        if (!isBackendId(normalizedRequested)) {
+            throw new BackendError("backend-not-found", `Unknown execution backend: ${normalizedRequested}`, {
+                backendId: normalizedRequested,
+                available: backendIds(),
+            });
+        }
+        return { backendId: normalizedRequested, source: "flag", requested: normalizedRequested };
+    }
+    const envBackend = env.CW_BACKEND && env.CW_BACKEND.trim() ? env.CW_BACKEND.trim() : undefined;
+    if (envBackend) {
+        if (!isBackendId(envBackend)) {
+            throw new BackendError("backend-not-found", `Unknown execution backend in CW_BACKEND: ${envBackend}`, {
+                backendId: envBackend,
+                available: backendIds(),
+            });
+        }
+        return { backendId: envBackend, source: "env", requested: envBackend };
+    }
+    return { backendId: exports.DEFAULT_BACKEND_ID, source: "default" };
+}
+// ---------------------------------------------------------------------------
+// Sandbox dimension mapping + attestation.
+// ---------------------------------------------------------------------------
+function requiredSandboxDimensions(policy) {
+    const required = [];
+    required.push("read");
+    required.push("write");
+    if (policy.execute.mode !== "any")
+        required.push("command");
+    if (policy.network.mode !== "any")
+        required.push("network");
+    if (policy.env.inherit === false)
+        required.push("env");
+    return required;
+}
+function attestSandbox(descriptor, policy, options = { mode: "execute" }) {
+    const required = requiredSandboxDimensions(policy);
+    const supportByDimension = new Map(descriptor.capabilities.map((cap) => [cap.dimension, cap.support]));
+    const enforced = [];
+    const attested = [];
+    const unenforceable = [];
+    for (const dimension of required) {
+        const declared = supportByDimension.get(dimension) || "unsupported";
+        let effective = declared;
+        if (options.mode === "delegate-host" && declared !== "unsupported") {
+            effective = dimension === "write" ? "enforce" : "attest";
+        }
+        if (effective === "enforce")
+            enforced.push(dimension);
+        else if (effective === "attest")
+            attested.push(dimension);
+        else
+            unenforceable.push(dimension);
+    }
+    const refusedForReadiness = options.ready === false;
+    const status = unenforceable.length || refusedForReadiness ? "refused" : enforced.length ? "enforced" : "attested";
+    return {
+        schemaVersion: 1,
+        backendId: descriptor.id,
+        locality: descriptor.locality,
+        kind: descriptor.kind,
+        sandboxProfileId: policy.id,
+        required,
+        enforced,
+        attested,
+        unenforceable,
+        status,
+        enforcedByCW: policy.enforcement.enforcedByCW,
+        hostRequired: policy.enforcement.hostRequired,
+        recordedAt: options.recordedAt || new Date().toISOString(),
+        handle: options.handle,
+        notes: options.notes,
+    };
+}
+// ---------------------------------------------------------------------------
+// Readiness probe.
+// ---------------------------------------------------------------------------
+function probeBackend(id, context = {}) {
+    const descriptor = getBackendDescriptor(id);
+    const driver = BACKEND_REGISTRY.get(id);
+    // Config-based probes (agent/remote/ci) read readiness from the environment;
+    // the local probes (node/bun/shell/container) ignore their arg. Pass
+    // process.env, NOT the {cwd} context — otherwise the context object shadows
+    // process.env and a configured agent always reads back "unverified".
+    void context;
+    const body = driver?.probe ? driver.probe(process.env) : { checks: [], readiness: descriptor.readiness };
+    return {
+        schemaVersion: 1,
+        backendId: descriptor.id,
+        locality: descriptor.locality,
+        kind: descriptor.kind,
+        readiness: body.readiness,
+        ready: body.readiness === "ready",
+        enforces: descriptor.enforces,
+        attests: descriptor.attests,
+        checks: body.checks,
+        reason: body.reason,
+    };
+}
+// ---------------------------------------------------------------------------
+// The run entry.
+// ---------------------------------------------------------------------------
+function commandDenied(policy, command) {
+    const normalized = command.trim();
+    if (!normalized)
+        return "empty command";
+    if (policy.execute.mode === "none") {
+        return `command execution is denied by sandbox profile ${policy.id}`;
+    }
+    if (policy.execute.mode === "allowlist" && !(policy.execute.allow || []).includes(normalized)) {
+        return `command is outside sandbox profile ${policy.id} allowlist`;
+    }
+    return undefined;
+}
+function delegationHandle(descriptor, request) {
+    return getBackendDriver(descriptor.id)?.buildHandle?.(request);
+}
+function delegate(descriptor, policy, request, label, probe) {
+    const handle = delegationHandle(descriptor, request);
+    if (!handle) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "delegation-target-missing", probe.reason || `Backend ${descriptor.id} has no delegation target; refusing rather than running unsandboxed`, attestSandbox(descriptor, policy, { mode: "execute", ready: probe.ready }));
+    }
+    if (!getBackendDriver(descriptor.id)?.commandlessDelegate && !request.command) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "no-command", `Backend ${descriptor.id} requires a command to delegate`, attestSandbox(descriptor, policy, { mode: "execute", ready: probe.ready }));
+    }
+    const attestation = attestSandbox(descriptor, policy, {
+        mode: "execute",
+        ready: true,
+        handle,
+        notes: [`delegated: ${descriptor.id} -> ${handle.ref}`],
+    });
+    const driver = getBackendDriver(descriptor.id);
+    if (!driver?.delegateRun) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "backend-not-runnable", `Backend ${descriptor.id} has no delegate runner`, attestation);
+    }
+    return driver.delegateRun({ descriptor, policy, request, label, handle, attestation });
+}
+function runBackend(request) {
+    const descriptor = getBackendDescriptor(request.backendId);
+    const policy = request.sandboxPolicy;
+    const label = request.label || request.command || `${descriptor.id}-execution`;
+    const probe = probeBackend(descriptor.id, { cwd: request.cwd });
+    if (request.command) {
+        const denied = commandDenied(policy, `${request.command} ${(request.args || []).join(" ")}`.trim());
+        if (denied) {
+            return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "sandbox-command-denied", denied, attestSandbox(descriptor, policy, { mode: "execute", ready: probe.ready }));
+        }
+    }
+    const attestation = attestSandbox(descriptor, policy, { mode: "execute", ready: probe.ready });
+    if (attestation.unenforceable.length) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "sandbox-unenforceable", `Backend ${descriptor.id} cannot enforce or attest required sandbox dimension(s): ${attestation.unenforceable.join(", ")}`, attestation);
+    }
+    if (descriptor.kind === "delegating") {
+        return delegate(descriptor, policy, request, label, probe);
+    }
+    if (!probe.ready) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "backend-not-ready", probe.reason || `Backend ${descriptor.id} is not ready`, attestation);
+    }
+    if (!request.command) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "no-command", `Backend ${descriptor.id} requires a command to execute`, attestation);
+    }
+    return (0, local_1.executeLocal)(descriptor, request, label, attestation, getBackendDriver(descriptor.id)?.spawnStyle);
+}
+function createExecutionBackend(id) {
+    const descriptor = getBackendDescriptor(id);
+    return {
+        descriptor,
+        probe: (context) => probeBackend(id, context),
+        run: (request) => runBackend({ ...request, backendId: id }),
+    };
+}
+// ---- inspection payloads ---------------------------------------------------
+function backendListPayload() {
+    return { schemaVersion: 1, default: exports.DEFAULT_BACKEND_ID, backends: listBackendDescriptors() };
+}
+function backendShowPayload(id) {
+    return getBackendDescriptor(id);
+}
+const _probeCache = new Map();
+function probeCacheTtlMs() {
+    const raw = process.env.CW_PROBE_CACHE_TTL_MS;
+    const n = raw ? parseInt(raw, 10) : 60_000;
+    return Number.isFinite(n) && n >= 0 ? n : 60_000;
+}
+function cachedProbeBackend(id, context) {
+    const key = `${id}:${context.cwd || ""}`;
+    const cached = _probeCache.get(key);
+    if (cached && Date.now() - cached.at < probeCacheTtlMs())
+        return cached.result;
+    const result = probeBackend(id, context);
+    _probeCache.set(key, { result, at: Date.now() });
+    return result;
+}
+function backendProbePayload(id, context = {}) {
+    if (id && id.trim())
+        return cachedProbeBackend(id.trim(), context);
+    return { schemaVersion: 1, default: exports.DEFAULT_BACKEND_ID, probes: backendIds().map((backendId) => cachedProbeBackend(backendId, context)) };
+}

package/dist/shell/execution-backend/remote.js

@@ -0,0 +1,128 @@
+"use strict";
+// shell/execution-backend/remote.ts — remote/ci delegating drivers (shared
+// HTTP-delegation body) + handle builders.
+//
+// MILESTONE 5 (v2/PLAN.md build order, step 5). Byte-exact port of
+// plugins/cool-workflow/src/execution-backend.ts's `runHttpDelegation`
+// (:821-876), `remoteHandle` (:1077-1084), `ciHandle` (:1086-1093), and
+// `delegateChildScript` (:801-811).
+//
+// Evidence: SPEC/execution-backend.md "remote / ci drivers
+// (runHttpDelegation)".
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delegateChildScript = delegateChildScript;
+exports.remoteHandle = remoteHandle;
+exports.ciHandle = ciHandle;
+exports.runHttpDelegation = runHttpDelegation;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const envelopes_1 = require("./envelopes");
+const local_1 = require("./local");
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Resolves scripts/children/http-delegate-child.js next to the compiled
+ *  module. Throws the exact broken-installation message when missing. */
+function delegateChildScript() {
+    // __dirname is dist/shell/execution-backend — three levels up reaches
+    // the package root (scripts/ is a sibling of dist/, not two levels up).
+    const resolved = path.resolve(__dirname, "..", "..", "..", "scripts", "children", "http-delegate-child.js");
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Delegate child script not found at ${resolved}. ` +
+            `This indicates a broken installation — reinstall cool-workflow or ensure ` +
+            `"scripts/children/http-delegate-child.js" is shipped in the package.`);
+    }
+    return resolved;
+}
+function remoteHandle(request, env = process.env) {
+    const delegation = request.delegation || {};
+    const endpoint = delegation.endpoint || (env.CW_REMOTE_ENDPOINT || "").trim() || undefined;
+    if (!endpoint)
+        return undefined;
+    const jobId = delegation.jobId || (env.CW_REMOTE_JOB || "").trim() || undefined;
+    const ref = jobId ? `${endpoint}#${jobId}` : endpoint;
+    return { kind: "remote", ref, endpoint, jobId };
+}
+function ciHandle(request, env = process.env) {
+    const delegation = request.delegation || {};
+    const endpoint = delegation.endpoint || (env.CW_CI_ENDPOINT || "").trim() || undefined;
+    const jobId = delegation.jobId || (env.CW_CI_JOB || "").trim() || undefined;
+    if (!endpoint && !jobId)
+        return undefined;
+    const ref = endpoint && jobId ? `${endpoint}#${jobId}` : jobId || endpoint || "";
+    return { kind: "ci", ref, endpoint, jobId };
+}
+/** remote / ci — real HTTP delegation. POSTs the job to the configured
+ *  endpoint (and polls a returned jobId) via a Node child, then records the
+ *  runner's exit + stdout digest as canonical evidence. Fails closed when
+ *  the endpoint is missing, unreachable, errors, or returns no exitCode. */
+function runHttpDelegation(descriptor, policy, request, label, handle, attestation) {
+    const endpoint = handle.endpoint;
+    if (!endpoint) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "delegation-target-missing", `Backend ${descriptor.id} has no endpoint to POST to`, attestation);
+    }
+    const command = String(request.command);
+    const args = (request.args || []).map(String);
+    const job = JSON.stringify({
+        command,
+        args,
+        env: (0, local_1.buildChildEnv)(policy),
+        sandboxProfileId: policy.id,
+        jobId: handle.jobId,
+    });
+    const child = (0, node_child_process_1.spawnSync)(process.execPath, [delegateChildScript()], {
+        input: job,
+        env: { ...process.env, CW_DELEGATE_ENDPOINT: endpoint },
+        encoding: "utf8",
+        timeout: request.timeoutMs || 120000,
+        maxBuffer: 32 * 1024 * 1024,
+    });
+    if (child.error) {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "delegation-failed", `${descriptor.id} delegation failed: ${messageOf(child.error)}`, attestation);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(String(child.stdout || "").trim() || "{}");
+    }
+    catch {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "delegation-failed", `${descriptor.id} runner returned an unparseable response`, attestation);
+    }
+    if (parsed.error || typeof parsed.exitCode !== "number") {
+        return (0, envelopes_1.refusedEnvelope)(descriptor, policy, label, "delegation-failed", `${descriptor.id} runner error: ${parsed.error || "no exitCode reported"}`, attestation);
+    }
+    return (0, envelopes_1.delegatedEnvelope)(descriptor, label, handle, attestation, command, args, parsed.exitCode, String(parsed.stdout || ""));
+}

package/dist/shell/execution-backend/types.js

@@ -0,0 +1,11 @@
+"use strict";
+// shell/execution-backend/types.ts — plain data shapes for the driver layer.
+//
+// MILESTONE 5 (v2/PLAN.md build order, step 5). Byte-exact port of the shapes
+// in the old build's src/types/execution-backend.ts and the sandbox slice of
+// src/types/sandbox.ts that this subsystem needs. Types only — no logic — so
+// this file is safe to import from both shell/ (impure) and any future core/
+// caller without violating the core/shell purity split.
+//
+// Evidence: SPEC/execution-backend.md.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shell/feedback-cli.js

@@ -0,0 +1,81 @@
+"use strict";
+// shell/feedback-cli.ts — `cw feedback list|show|summary|collect|task|resolve`
+// (and the mirrored cw_feedback_* MCP tools) handler bodies. Loads run state
+// and routes to the feedback-operations lifecycle.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feedbackListCli = feedbackListCli;
+exports.feedbackShowCli = feedbackShowCli;
+exports.feedbackSummaryCli = feedbackSummaryCli;
+exports.feedbackCollectCli = feedbackCollectCli;
+exports.feedbackTaskCli = feedbackTaskCli;
+exports.feedbackResolveCli = feedbackResolveCli;
+const path = __importStar(require("node:path"));
+const run_store_1 = require("./run-store");
+const error_feedback_1 = require("../core/pipeline/error-feedback");
+const feedback_operations_1 = require("./feedback-operations");
+function cwdFor(args) {
+    return typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
+}
+function req(value, label) {
+    const s = value === undefined || value === null ? "" : String(value);
+    if (!s)
+        throw new Error(`Missing ${label}`);
+    return s;
+}
+function feedbackListCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, feedback_operations_1.listFeedback)(run, args);
+}
+function feedbackShowCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, feedback_operations_1.showFeedback)(run, req(args.feedbackId, "feedback id"));
+}
+function feedbackSummaryCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, error_feedback_1.summarizeFeedback)((0, feedback_operations_1.listFeedback)(run));
+}
+function feedbackCollectCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, feedback_operations_1.collectFeedback)(run);
+}
+function feedbackTaskCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, feedback_operations_1.createFeedbackTask)(run, req(args.feedbackId, "feedback id"), args);
+}
+function feedbackResolveCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, feedback_operations_1.resolveFeedback)(run, req(args.feedbackId, "feedback id"), args);
+}

package/dist/shell/feedback-operations.js

@@ -0,0 +1,48 @@
+"use strict";
+// shell/feedback-operations.ts — operator-facing feedback lifecycle:
+// collect / list / show / create-task / resolve. Byte-behavior port of the old
+// src/orchestrator/feedback-operations.ts (thin wrappers over the
+// error-feedback-io primitives that also refresh the report + persist).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectFeedback = collectFeedback;
+exports.listFeedback = listFeedback;
+exports.showFeedback = showFeedback;
+exports.createFeedbackTask = createFeedbackTask;
+exports.resolveFeedback = resolveFeedback;
+const report_1 = require("./report");
+const error_feedback_io_1 = require("./error-feedback-io");
+function collectFeedback(run) {
+    const collected = (0, error_feedback_io_1.collectRunErrors)(run);
+    (0, report_1.writeReport)(run);
+    return collected;
+}
+function listFeedback(run, options = {}) {
+    return (0, error_feedback_io_1.listFeedback)(run, {
+        status: options.status ? String(options.status) : undefined,
+        severity: options.severity ? String(options.severity) : undefined,
+        classification: options.classification ? String(options.classification) : undefined,
+    });
+}
+function showFeedback(run, feedbackId) {
+    const feedback = (0, error_feedback_io_1.getFeedback)(run, feedbackId);
+    if (!feedback)
+        throw new Error(`Unknown feedback id for run ${run.id}: ${feedbackId}`);
+    return feedback;
+}
+function createFeedbackTask(run, feedbackId, options = {}) {
+    const feedback = (0, error_feedback_io_1.createCorrectionTask)(run, feedbackId, {
+        verifierCommand: options.verify ? String(options.verify) : undefined,
+        guidance: options.guidance ? String(options.guidance) : undefined,
+    });
+    (0, report_1.writeReport)(run);
+    return feedback;
+}
+function resolveFeedback(run, feedbackId, options = {}) {
+    const feedback = (0, error_feedback_io_1.resolveFeedback)(run, feedbackId, {
+        status: options.status === "rejected" ? "rejected" : "resolved",
+        nodeId: options.node ? String(options.node) : undefined,
+        message: options.message ? String(options.message) : undefined,
+    });
+    (0, report_1.writeReport)(run);
+    return feedback;
+}