cool-workflow 0.1.98 → 0.2.0

package/dist/shell/dispatch.js

@@ -0,0 +1,162 @@
+"use strict";
+// shell/dispatch.ts — createDispatchManifest: the imperative wrapper
+// around core/pipeline/dispatch.ts's pure decision helpers.
+//
+// MILESTONE 6+7 (combined). Byte-exact port of the old build's
+// src/dispatch.ts's IO half (worker-scope allocation, manifest file
+// write, state-node append). Multi-agent attachment and custom sandbox
+// profile persistence at dispatch (H7) are milestone 9's scope and are
+// no-ops here.
+//
+// Evidence: SPEC/pipeline-run.md "Dispatch — src/dispatch.ts".
+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.writeRunNode = void 0;
+exports.createDispatchManifest = createDispatchManifest;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const dispatch_1 = require("../core/pipeline/dispatch");
+const contract_1 = require("../core/pipeline/contract");
+const state_node_1 = require("../core/state/state-node");
+const node_store_1 = require("./node-store");
+Object.defineProperty(exports, "writeRunNode", { enumerable: true, get: function () { return node_store_1.writeRunNode; } });
+const fs_atomic_1 = require("./fs-atomic");
+const worker_isolation_1 = require("./worker-isolation");
+const multi_agent_io_1 = require("./multi-agent-io");
+const registry_1 = require("./execution-backend/registry");
+const sandbox_profile_1 = require("./sandbox-profile");
+function createDispatchManifest(run, limit, options = {}) {
+    const requestedSandboxProfileId = options.sandboxProfileId || options.sandbox;
+    const sandboxProfileId = String(requestedSandboxProfileId || sandbox_profile_1.DEFAULT_SANDBOX_PROFILE_ID);
+    (0, sandbox_profile_1.resolveSandboxProfileById)(sandboxProfileId, (0, sandbox_profile_1.sandboxContextForValidation)(run.cwd));
+    // H7: if the requested profile is a CUSTOM profile loaded from a FILE (non-bundled,
+    // existing file), persist its DEFINITION on run.customSandboxProfiles keyed by the
+    // definition's logical id, so a worker boundary can re-resolve it by logical id after
+    // a scope snapshot is lost. Throws on an id collision (same id, different file).
+    (0, sandbox_profile_1.persistCustomSandboxProfile)(run, sandboxProfileId);
+    const backendSelection = (0, registry_1.resolveBackendSelection)(options.backendId);
+    const tasks = (0, dispatch_1.nextDispatchTasks)(run, limit);
+    if (!tasks.length) {
+        return { schemaVersion: 1, runId: run.id, dispatchId: null, tasks: [], manifestPath: null, sandboxProfileId, backendId: backendSelection.backendId, backendSelection };
+    }
+    const now = new Date().toISOString();
+    const dispatchId = (0, dispatch_1.formatDispatchId)((run.dispatches?.length || 0) + 1, now, /^(1|true|yes|on)$/i.test(process.env.CW_DETERMINISTIC_RUN_IDS || ""));
+    const manifestPath = path.join(run.paths.dispatchesDir, `${dispatchId}.json`);
+    fs.mkdirSync(run.paths.dispatchesDir, { recursive: true });
+    const taskIds = new Set(tasks.map((t) => t.id));
+    let sandboxPolicy;
+    let backendAttestation;
+    for (const task of run.tasks) {
+        if (!taskIds.has(task.id))
+            continue;
+        const taskSandboxProfileId = String(requestedSandboxProfileId || task.sandboxProfileId || sandbox_profile_1.DEFAULT_SANDBOX_PROFILE_ID);
+        task.status = "running";
+        task.loopStage = "act";
+        task.dispatchId = dispatchId;
+        task.dispatchedAt = now;
+        const scope = (0, worker_isolation_1.allocateWorkerScope)(run, task, { dispatchId, sandboxProfileId: taskSandboxProfileId, backendId: backendSelection.backendId, status: "running", metadata: { dispatchId, phase: task.phase } });
+        sandboxPolicy = sandboxPolicy || scope.sandboxPolicy;
+        backendAttestation = backendAttestation || scope.backendAttestation;
+    }
+    const selectedRunTasks = run.tasks.filter((t) => taskIds.has(t.id));
+    // Attach this dispatch to any active multi-agent run/group/role/fanout: the
+    // kernel binds each selected task to its membership and returns the multiAgent
+    // block that rides on the manifest + each task + run.dispatches, so a fanin can
+    // see its members. Byte-behavior port of the old build's dispatch attachment.
+    const multiAgentAttachment = (0, multi_agent_io_1.attachDispatchToMultiAgent)(run, {
+        multiAgentRunId: options.multiAgentRunId,
+        groupId: options.multiAgentGroupId,
+        roleId: options.multiAgentRoleId,
+        fanoutId: options.multiAgentFanoutId,
+        dispatchId,
+        tasks: selectedRunTasks,
+        sandboxProfileId,
+        concurrencyLimit: limit,
+    });
+    for (const task of selectedRunTasks) {
+        const worker = task.workerId ? (0, worker_isolation_1.getWorkerScope)(run, String(task.workerId)) : undefined;
+        if (worker)
+            (0, worker_isolation_1.writeWorkerManifest)(run, worker);
+    }
+    const multiAgentBlock = multiAgentAttachment.multiAgent
+        ? { ...multiAgentAttachment.multiAgent, membershipIds: multiAgentAttachment.membershipIds }
+        : undefined;
+    const dispatchNode = (0, node_store_1.appendRunNode)(run, (0, state_node_1.createStateNode)({
+        id: `${run.id}:dispatch:${dispatchId}`,
+        kind: "dispatch",
+        status: "running",
+        loopStage: "act",
+        inputs: { taskIds: tasks.map((t) => t.id), phase: tasks[0].phase, sandboxProfileId },
+        outputs: { dispatchId, sandboxProfileId },
+        artifacts: [{ id: "dispatch", kind: "json", path: manifestPath }],
+        parents: tasks.map((t) => `${run.id}:task:${t.id}`),
+        contractId: contract_1.DEFAULT_PIPELINE_CONTRACT_ID,
+        metadata: { sandboxProfileId, sandboxPolicy },
+    }));
+    for (const task of run.tasks) {
+        if (!taskIds.has(task.id) || !task.stateNodeId)
+            continue;
+        const node = (run.nodes || []).find((n) => n.id === task.stateNodeId);
+        if (node && node.status === "pending") {
+            (0, node_store_1.appendRunNode)(run, (0, state_node_1.transitionStateNode)(node, { status: "running", loopStage: "act" }));
+        }
+    }
+    run.dispatches.push({ id: dispatchId, phase: tasks[0].phase || "", taskIds: tasks.map((t) => t.id), manifestPath, createdAt: now, stateNodeId: dispatchNode.id, workerIds: selectedRunTasks.filter((t) => t.workerId).map((t) => String(t.workerId)), sandboxProfileId, backendId: backendSelection.backendId, ...(multiAgentBlock ? { multiAgent: multiAgentBlock } : {}) });
+    // Advance the run-level loop stage so operator status ("Stage: act") reflects
+    // that work is dispatched — the standalone `cw dispatch` path, like the drive
+    // loop, moves interpret→act. (Old build advanced it here.)
+    run.loopStage = "act";
+    (0, dispatch_1.updatePhaseStatuses)(run);
+    const manifest = {
+        schemaVersion: 1,
+        runId: run.id,
+        dispatchId,
+        createdAt: now,
+        phase: tasks[0].phase,
+        instructions: "Spawn one worker per task when the user explicitly authorized agent/parallel/background work. Save each final summary as Markdown and record it with `cw.js result <run-id> <task-id> <file>`.",
+        tasks: selectedRunTasks.map(dispatch_1.formatDispatchTask),
+        manifestPath,
+        stateNodeId: dispatchNode.id,
+        workerIndexPath: run.paths.workersDir ? path.join(run.paths.workersDir, "index.json") : undefined,
+        sandboxProfileId,
+        sandboxPolicy,
+        backendId: backendSelection.backendId,
+        backendSelection,
+        backendAttestation,
+        ...(multiAgentBlock ? { multiAgent: multiAgentBlock } : {}),
+    };
+    (0, fs_atomic_1.writeJson)(manifestPath, manifest);
+    return manifest;
+}

package/dist/{doctor.js → shell/doctor.js}

@@ -1,80 +1,116 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// shell/doctor.ts — `cw doctor` environment diagnostics, in the spirit of
+// `brew doctor`.
+//
+// MILESTONE 5 (v2/PLAN.md build order, step 5). Byte-exact port of
+// plugins/cool-workflow/src/doctor.ts's checks this milestone needs
+// (node/agent/agent-binary/git/home-registry/repo-state). The `--onramp`
+// section (buildDoctorOnramp) is later-milestone (reporting) territory and
+// is intentionally NOT wired here — no milestone-5 conformance case passes
+// `--onramp`, and DoctorReport.onramp is optional so this is a strict
+// subset, not a behavior change for any case this milestone must pass.
+//
+// Discipline (unchanged from the old build):
+//  - READ-ONLY. Never creates .cw/ or $CW_HOME as a side effect.
+//  - FAIL CLOSED. Any `fail` check => ok:false => the CLI exits non-zero.
+//    A `warn` (e.g. no agent yet) does not fail.
+//  - TWO RENDERINGS. Human text by default; a stable `--json` payload.
+//
+// Evidence: SPEC/execution-backend.md "Agent delegation config"; the doctor
+// behavior itself is documented in the old build's src/doctor.ts (not yet a
+// dedicated SPEC file — this milestone's conformance case,
+// exec-doctor-agent-config.case.js, pins the exact text this file must
+// produce).
+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.runDoctor = runDoctor;
 exports.formatDoctorReport = formatDoctorReport;
 exports.formatDoctorFixes = formatDoctorFixes;
-// `cw doctor` — environment diagnostics, in the spirit of `brew doctor`.
-//
-// Homebrew's `doctor` turned "something is subtly wrong with your setup" into a
-// proactive, named list of problems each paired with a concrete fix. We borrow
-// that idea: instead of letting a missing agent / old Node / unwritable state
-// surface as a confusing mid-run failure, `cw doctor` probes the host up front
-// and prints WHAT is wrong and WHAT TO DO about it.
-//
-// Discipline:
-//  - READ-ONLY. Probes versions, $PATH, and the WRITABILITY of the nearest
-//    existing ancestor dir (via access(2)) — it never creates `.cw/` or $CW_HOME
-//    as a side effect, so running `doctor` changes nothing on disk.
-//  - FAIL CLOSED. Any `fail` check ⇒ `ok:false` ⇒ the CLI exits non-zero. A
-//    `warn` (e.g. no agent yet — demo/preview still work) does not fail.
-//  - TWO RENDERINGS. Human text by default; a stable `--json` payload for scripts.
-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 fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const agent_config_1 = require("./agent-config");
 const onramp_1 = require("./onramp");
 const term_1 = require("./term");
-/** Resolve a bare binary name against $PATH (or accept an explicit path). Returns
- *  the resolved path, or undefined when not found. No spawning. */
 function whichBinary(bin, env) {
     if (bin.includes("/") || bin.includes("\\")) {
         try {
-            return node_fs_1.default.statSync(bin).isFile() ? bin : undefined;
+            return fs.statSync(bin).isFile() ? bin : undefined;
         }
         catch {
             return undefined;
         }
     }
-    const dirs = (env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean);
+    const dirs = (env.PATH || "").split(path.delimiter).filter(Boolean);
     const exts = process.platform === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
     for (const dir of dirs) {
         for (const ext of exts) {
-            const candidate = node_path_1.default.join(dir, bin + ext);
+            const candidate = path.join(dir, bin + ext);
             try {
-                if (node_fs_1.default.statSync(candidate).isFile())
+                if (fs.statSync(candidate).isFile())
                     return candidate;
             }
-            catch { /* keep looking */ }
+            catch {
+                /* keep looking */
+            }
         }
     }
     return undefined;
 }
-/** True when `target` could be created/written: walk up to the nearest EXISTING
- *  ancestor and require it to be a writable DIRECTORY. (A file in the path is not
- *  writable-as-a-dir even though access(2) W_OK on the file itself would pass.)
- *  Does NOT create anything — a diagnostic must not have side effects. */
+/** True when `target` could be created/written: walk up to the nearest
+ *  EXISTING ancestor and require it to be a writable DIRECTORY. Does NOT
+ *  create anything — a diagnostic must not have side effects. */
 function dirWritable(target) {
-    let dir = node_path_1.default.resolve(target);
+    let dir = path.resolve(target);
     for (;;) {
         let stat;
         try {
-            stat = node_fs_1.default.statSync(dir);
+            stat = fs.statSync(dir);
         }
         catch {
-            const parent = node_path_1.default.dirname(dir);
+            const parent = path.dirname(dir);
             if (parent === dir)
                 return false;
             dir = parent;
             continue;
         }
         if (!stat.isDirectory())
-            return false; // an existing file blocks mkdir beneath it
+            return false;
         try {
-            node_fs_1.default.accessSync(dir, node_fs_1.default.constants.W_OK);
+            fs.accessSync(dir, fs.constants.W_OK);
             return true;
         }
         catch {
@@ -84,19 +120,24 @@ function dirWritable(target) {
 }
 function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
     const checks = [];
-    // 1. Node runtime — the one hard prerequisite (README: v18+).
+    // 1. Node runtime — the one hard prerequisite (v18+).
     const major = Number((process.version.match(/^v(\d+)/) || [])[1]);
     checks.push(Number.isFinite(major) && major >= 18
         ? { name: "node", status: "ok", detail: `Node ${process.version} (>= 18).` }
-        : { name: "node", status: "fail", detail: `Node ${process.version} is below the required v18.`, fix: "Install Node.js 18+ (e.g. `brew install node`, or https://nodejs.org)." });
+        : {
+            name: "node",
+            status: "fail",
+            detail: `Node ${process.version} is below the required v18.`,
+            fix: "Install Node.js 18+ (e.g. `brew install node`, or https://nodejs.org).",
+        });
     // 2. Agent backend — CW delegates execution; without one, real runs park.
     const cfg = (0, agent_config_1.resolveAgentConfig)(args, env);
     if (cfg.source === "auto") {
-        const vendor = (cfg.model && cfg.model.startsWith("builtin:")) ? cfg.model.slice("builtin:".length) : "auto";
+        const vendor = cfg.model && cfg.model.startsWith("builtin:") ? cfg.model.slice("builtin:".length) : "auto";
         checks.push({
             name: "agent",
             status: "ok",
-            detail: `Agent auto-detected: ${vendor}. Set CW_AGENT_COMMAND or --agent-command to override.`
+            detail: `Agent auto-detected: ${vendor}. Set CW_AGENT_COMMAND or --agent-command to override.`,
         });
     }
     else if (cfg.source === "none") {
@@ -104,7 +145,7 @@ function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
             name: "agent",
             status: "warn",
             detail: "No agent backend configured — `demo` and `--preview` work, but a real run reports status: blocked.",
-            fix: 'Pass --agent-command "claude -p", set $CW_AGENT_COMMAND, or use --agent-command builtin:claude.'
+            fix: 'Pass --agent-command "claude -p", set $CW_AGENT_COMMAND, or use --agent-command builtin:claude.',
         });
     }
     else {
@@ -112,33 +153,50 @@ function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
         checks.push({
             name: "agent",
             status: "ok",
-            detail: `Agent configured from ${cfg.source}${binToken ? `: ${binToken}` : cfg.endpoint ? " (HTTP endpoint)" : ""}.`
+            detail: `Agent configured from ${cfg.source}${binToken ? `: ${binToken}` : cfg.endpoint ? " (HTTP endpoint)" : ""}.`,
         });
-        // 2b. If it is a command agent, is the binary actually on PATH?
         if (binToken) {
             const resolved = whichBinary(binToken, env);
             checks.push(resolved
                 ? { name: "agent-binary", status: "ok", detail: `Agent binary "${binToken}" found at ${resolved}.` }
-                : { name: "agent-binary", status: "warn", detail: `Configured agent binary "${binToken}" is not on $PATH.`, fix: `Install "${binToken}", or correct --agent-command / $CW_AGENT_COMMAND.` });
+                : {
+                    name: "agent-binary",
+                    status: "warn",
+                    detail: `Configured agent binary "${binToken}" is not on $PATH.`,
+                    fix: `Install "${binToken}", or correct --agent-command / $CW_AGENT_COMMAND.`,
+                });
         }
     }
-    // 3. git — only needed for commit provenance (git HEAD); a warn, not a hard fail.
+    // 3. git — only needed for commit provenance; a warn, not a hard fail.
     const git = (0, node_child_process_1.spawnSync)("git", ["--version"], { encoding: "utf8", timeout: 5000 });
     checks.push(!git.error && git.status === 0
-        ? { name: "git", status: "ok", detail: (String(git.stdout || "git").trim()) + "." }
-        : { name: "git", status: "warn", detail: "git is not available — commit provenance (git HEAD) is recorded as absent.", fix: "Install git (e.g. `brew install git`) if you want commit provenance." });
+        ? { name: "git", status: "ok", detail: `${String(git.stdout || "git").trim()}.` }
+        : {
+            name: "git",
+            status: "warn",
+            detail: "git is not available — commit provenance (git HEAD) is recorded as absent.",
+            fix: "Install git (e.g. `brew install git`) if you want commit provenance.",
+        });
     // 4. Home registry — the cross-repo run index lives here; must be writable.
-    const home = env.CW_HOME && String(env.CW_HOME).trim()
-        ? node_path_1.default.resolve(String(env.CW_HOME))
-        : node_path_1.default.join(node_os_1.default.homedir(), ".local", "state", "cool-workflow");
+    const home = env.CW_HOME && String(env.CW_HOME).trim() ? path.resolve(String(env.CW_HOME)) : path.join(os.homedir(), ".local", "state", "cool-workflow");
     checks.push(dirWritable(home)
         ? { name: "home-registry", status: "ok", detail: `Home registry location is writable (${home}).` }
-        : { name: "home-registry", status: "fail", detail: `Home registry location is not writable: ${home}`, fix: "Set $CW_HOME to a writable directory, or fix the permissions." });
+        : {
+            name: "home-registry",
+            status: "fail",
+            detail: `Home registry location is not writable: ${home}`,
+            fix: "Set $CW_HOME to a writable directory, or fix the permissions.",
+        });
     // 5. Working-dir state — per-repo runs land under <cwd>/.cw.
-    const cwState = node_path_1.default.join(node_path_1.default.resolve(cwd), ".cw");
+    const cwState = path.join(path.resolve(cwd), ".cw");
     checks.push(dirWritable(cwState)
         ? { name: "repo-state", status: "ok", detail: `Run state location is writable (${cwState}).` }
-        : { name: "repo-state", status: "warn", detail: `Cannot write run state under ${cwState}.`, fix: "Run from a writable working directory, or pass --cwd PATH." });
+        : {
+            name: "repo-state",
+            status: "warn",
+            detail: `Cannot write run state under ${cwState}.`,
+            fix: "Run from a writable working directory, or pass --cwd PATH.",
+        });
     const fails = checks.filter((c) => c.status === "fail").length;
     const warns = checks.filter((c) => c.status === "warn").length;
     const ok = fails === 0;
@@ -152,9 +210,18 @@ function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
         ok,
         checks,
         summary,
+        // `--onramp` attaches the change-contract onramp block (byte-exact port
+        // of the old build's src/doctor.ts wiring). `--changed-from REF` threads
+        // the base ref through to resolveChangedFiles + evaluateOnrampContract.
         ...((0, onramp_1.optionEnabled)(args.onramp)
-            ? { onramp: (0, onramp_1.buildDoctorOnramp)({ cwd, env, changedFrom: typeof args["changed-from"] === "string" ? args["changed-from"] : undefined }) }
-            : {})
+            ? {
+                onramp: (0, onramp_1.buildDoctorOnramp)({
+                    cwd,
+                    env,
+                    changedFrom: typeof args["changed-from"] === "string" ? args["changed-from"] : undefined,
+                }),
+            }
+            : {}),
     };
 }
 /** Human rendering (TTY/default). `--json` callers use the report object directly. */