cool-workflow 0.1.98 → 0.2.1

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/shell/doctor.js

@@ -0,0 +1,292 @@
+"use strict";
+// shell/doctor.ts — `cw doctor` environment diagnostics, in the spirit of
+// `brew doctor`.
+//
+// MILESTONE 5 (docs/rebuild/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;
+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");
+function whichBinary(bin, env) {
+    if (bin.includes("/") || bin.includes("\\")) {
+        try {
+            return fs.statSync(bin).isFile() ? bin : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    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 = path.join(dir, bin + ext);
+            try {
+                if (fs.statSync(candidate).isFile())
+                    return candidate;
+            }
+            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. Does NOT
+ *  create anything — a diagnostic must not have side effects. */
+function dirWritable(target) {
+    let dir = path.resolve(target);
+    for (;;) {
+        let stat;
+        try {
+            stat = fs.statSync(dir);
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return false;
+            dir = parent;
+            continue;
+        }
+        if (!stat.isDirectory())
+            return false;
+        try {
+            fs.accessSync(dir, fs.constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
+    const checks = [];
+    // 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).",
+        });
+    // 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";
+        checks.push({
+            name: "agent",
+            status: "ok",
+            detail: `Agent auto-detected: ${vendor}. Set CW_AGENT_COMMAND or --agent-command to override.`,
+        });
+    }
+    else if (cfg.source === "none") {
+        checks.push({
+            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.',
+        });
+    }
+    else {
+        const binToken = cfg.command ? String(cfg.command).split(/\s+/)[0] : undefined;
+        checks.push({
+            name: "agent",
+            status: "ok",
+            detail: `Agent configured from ${cfg.source}${binToken ? `: ${binToken}` : cfg.endpoint ? " (HTTP endpoint)" : ""}.`,
+        });
+        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.`,
+                });
+        }
+    }
+    // 3. Sandbox enforcement boundary — a fixed architectural fact (see
+    // docs/sandbox-profiles.7.md), not a host-specific problem to fix, so this
+    // is "ok" (informational), never "warn": CW validates sandbox policy and
+    // gates worker-output acceptance, but OS-level read/write/execute/network/
+    // env isolation is the execution host's responsibility, which this doctor
+    // run cannot itself verify. An "ok" check carries no `fix` line by
+    // convention (see the node/git checks above), so the pointer to the docs
+    // lives in `detail` instead.
+    checks.push({
+        name: "sandbox-enforceability",
+        status: "ok",
+        detail: "CW sandbox profiles validate policy and gate worker-output acceptance; OS-level read/write/execute/network/env isolation is the execution host's responsibility (see docs/sandbox-profiles.7.md's ENFORCEMENT section) — this doctor run cannot verify that host enforcement.",
+    });
+    // 4. 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.",
+        });
+    // 5. Home registry — the cross-repo run index lives here; must be writable.
+    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.",
+        });
+    // 6. Working-dir state — per-repo runs land under <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.",
+        });
+    const fails = checks.filter((c) => c.status === "fail").length;
+    const warns = checks.filter((c) => c.status === "warn").length;
+    const ok = fails === 0;
+    const summary = ok
+        ? warns === 0
+            ? "ready — all checks passed"
+            : `ready, with ${warns} warning${warns === 1 ? "" : "s"}`
+        : `${fails} blocking problem${fails === 1 ? "" : "s"} found`;
+    return {
+        schemaVersion: 1,
+        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,
+                }),
+            }
+            : {}),
+    };
+}
+/** Human rendering (TTY/default). `--json` callers use the report object directly. */
+function formatDoctorReport(report) {
+    const lines = [(0, term_1.bold)("cw doctor")];
+    for (const check of report.checks) {
+        lines.push(`  ${(0, term_1.doctorGlyph)(check.status)} ${check.name}: ${check.detail}`);
+        if (check.fix && check.status !== "ok")
+            lines.push(`      fix: ${check.fix}`);
+    }
+    lines.push("");
+    const summaryGlyph = report.ok ? (0, term_1.green)("✓") : (0, term_1.red)("✗");
+    lines.push(`${summaryGlyph} ${report.summary}`);
+    if (report.onramp) {
+        lines.push("");
+        lines.push("Quick start (3 steps):");
+        lines.push("  1. cw demo tamper        — prove trust checks work (30s)");
+        lines.push("  2. cw demo bundle         — prove portable bundles (30s)");
+        lines.push('  3. cw -q "what risks?"     — your first real report (needs an agent)');
+        lines.push('     cw quickstart research-synthesis --repo <folder> --question "..."  — cited report over a docs/papers folder, not only code');
+        lines.push("");
+        lines.push("Onramp");
+        lines.push(`  ${report.onramp.summary}`);
+        if (report.onramp.recommendedChecks) {
+            lines.push("");
+            lines.push("  Recommended Checks");
+            for (const command of report.onramp.recommendedChecks.commands)
+                lines.push(`    - ${command}`);
+        }
+        if (report.onramp.contract && !report.onramp.contract.ok) {
+            lines.push("");
+            lines.push("  Contract Issues");
+            for (const issue of report.onramp.contract.issues) {
+                lines.push(`    - ${issue.code}: ${issue.detail}`);
+                lines.push(`      fix: ${issue.fix}`);
+            }
+        }
+        for (const section of report.onramp.sections) {
+            lines.push("");
+            lines.push(`  ${section.title}: ${section.summary}`);
+            for (const action of section.actions) {
+                lines.push(`    - ${action.command}`);
+                lines.push(`      ${action.reason}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+/** `--fix` rendering: consolidates all fix strings into an actionable block. */
+function formatDoctorFixes(report) {
+    const fixes = report.checks.filter((c) => c.fix && c.status !== "ok").map((c) => c.fix);
+    if (!fixes.length)
+        return "No fixes needed.";
+    return [(0, term_1.bold)("Fix Commands"), ...fixes.map((f, i) => `  ${i + 1}. ${f}`), ""].join("\n");
+}