cool-workflow 0.1.98 → 0.2.0

package/dist/gates.js

@@ -1,48 +0,0 @@
-"use strict";
-// Shared, drift-proof gate primitives (F4). These two helpers were previously
-// duplicated "in sync by comment" in commit.ts and candidate-scoring.ts — the
-// no-false-green gate and the sandbox-profile lookup. A by-comment sync is a
-// structural drift hazard: nothing prevents one copy from changing without the
-// other, and the two gates MUST agree (selection + commit must reach the same
-// empty-capture verdict). Extracting ONE implementation each, imported by both
-// call sites, makes that drift impossible.
-//
-// Pure functions over PERSISTED state only — no clock, no randomness, no fs —
-// so both selection and commit replays reach the same gate decision. Keep them
-// fail-closed: when in doubt the caller must BLOCK, never silently pass.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emptyCaptureWarning = emptyCaptureWarning;
-exports.sandboxProfileForCandidate = sandboxProfileForCandidate;
-/** The HARD no-false-green gate (DIRECTION.md "ambiguity is a visible state").
- *  A verifier node is built FROM a result node; when that result captured no
- *  structured signal at all the result node carries a `metadata.captureWarning`
- *  marker (set in worker-isolation / lifecycle ingest via isEmptyCapture). The
- *  worker output is still ACCEPTED (a recorded warning, never a silent pass), but
- *  a verifier-GATED commit — and candidate SELECTION — must NOT be able to
- *  present that zero-evidence result as clean/green. We detect it here, reading
- *  ONLY persisted state (the source result node's metadata) — purely functional,
- *  no clock/ordering — so snapshot replay reaches the same gate decision.
- *  Returns the marker string, or undefined.
- *
- *  Resolution trail: verifier node -> its input/parent result node. We look at
- *  `inputs.inputNodeId` (set by runPipelineStage) first, then fall back to the
- *  first parent, so it works regardless of which ingest path produced the node. */
-function emptyCaptureWarning(run, verifierNode) {
-    const resultNodeId = (typeof verifierNode.inputs?.inputNodeId === "string" ? verifierNode.inputs.inputNodeId : undefined) ||
-        verifierNode.parents[0];
-    const resultNode = resultNodeId ? (run.nodes || []).find((node) => node.id === resultNodeId) : undefined;
-    const warning = resultNode?.metadata?.captureWarning;
-    return typeof warning === "string" && warning ? warning : undefined;
-}
-/** Resolve the sandbox profile that backed a candidate's acceptance: the
- *  worker's profile if the candidate has a worker, else the originating task's.
- *  Read by both the commit gate's acceptance rationale and selection. Accepts an
- *  optional candidate so the commit-side caller (which may not have resolved a
- *  candidate) can share the same lookup. Pure over persisted run state. */
-function sandboxProfileForCandidate(run, candidate) {
-    const worker = candidate?.workerId ? (run.workers || []).find((entry) => entry.id === candidate.workerId) : undefined;
-    if (worker?.sandboxProfileId)
-        return worker.sandboxProfileId;
-    const task = candidate?.taskId ? (run.tasks || []).find((entry) => entry.id === candidate.taskId) : undefined;
-    return task?.sandboxProfileId;
-}

package/dist/harness.js

@@ -1,61 +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.writeTaskFiles = writeTaskFiles;
-exports.renderTask = renderTask;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const state_1 = require("./state");
-function writeTaskFiles(run) {
-    for (const task of run.tasks) {
-        const taskPath = node_path_1.default.join(run.paths.tasksDir, `${(0, state_1.safeFileName)(task.id)}.md`);
-        task.taskPath = taskPath;
-        node_fs_1.default.writeFileSync(taskPath, renderTask(run, task), "utf8");
-    }
-}
-function renderTask(run, task) {
-    return [
-        `# ${task.id}`,
-        "",
-        `- Workflow: ${run.workflow.title}`,
-        `- Run: ${run.id}`,
-        `- Phase: ${task.phase}`,
-        `- Kind: ${task.kind}`,
-        "",
-        "## Inputs",
-        "",
-        `- Repository: ${String(run.inputs.repo || run.cwd)}`,
-        `- Question: ${String(run.inputs.question || "")}`,
-        `- Invariants: ${formatInputList(run.inputs.invariant)}`,
-        "",
-        "## Task",
-        "",
-        task.prompt,
-        "",
-        "## Output Contract",
-        "",
-        "- Return a concise Markdown summary.",
-        "- Include concrete evidence paths and line numbers when applicable.",
-        "- Separate real, conditional, non-issue, and unknown findings when reviewing risk.",
-        "- For verification or verdict tasks, include a `cw:result` JSON fence with `findings` and `evidence`.",
-        "- Do not edit files unless the parent agent session explicitly assigned implementation work.",
-        "",
-        "```cw:result",
-        "{",
-        '  "summary": "one sentence",',
-        '  "findings": [',
-        '    { "id": "finding-id", "classification": "real|conditional|non-issue|unknown", "severity": "P0|P1|P2|P3|none", "evidence": ["file-or-url:line"] }',
-        "  ],",
-        '  "evidence": ["file-or-url:line"]',
-        "}",
-        "```",
-        ""
-    ].join("\n");
-}
-function formatInputList(value) {
-    if (Array.isArray(value))
-        return value.join("; ");
-    return value ? String(value) : "";
-}

package/dist/ledger.js

@@ -1,313 +0,0 @@
-"use strict";
-// Cross-agent handoff ledger — the core mechanism for two agents scoped to two
-// separate repos to hand each other a CHANGE PROPOSAL or a REVIEW VERDICT as
-// verifiable data, not chat. Design: docs/designs/handoff-ledger.md.
-//
-// Stage 1 (human-relay transport): a ledger entry is a self-contained JSON
-// object carrying its own sha256 content digest. The producing side prints one;
-// the operator carries it to the other session; the consuming side VERIFIES it
-// fail-closed (a tampered or malformed entry is refused, never acted on) before
-// turning a proposal into a real PR or recording a verdict.
-//
-// Zero-dependency (only node stdlib). `build*`/`verify*` are pure; the stage-2
-// git transport adds `listLedgerEntries`, a READ-ONLY scan of a shared ledger
-// directory (the working tree of a handoff repo) that verifies every entry
-// fail-closed. No run state, no writes, no network.
-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.computeLedgerDigest = computeLedgerDigest;
-exports.buildLedgerProposal = buildLedgerProposal;
-exports.buildLedgerReview = buildLedgerReview;
-exports.verifyLedgerEntry = verifyLedgerEntry;
-exports.applyLedgerProposal = applyLedgerProposal;
-exports.listLedgerEntries = listLedgerEntries;
-exports.unionLedgerEntries = unionLedgerEntries;
-exports.resolveLedgerInbox = resolveLedgerInbox;
-const crypto = __importStar(require("crypto"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-/** Deterministic JSON with recursively sorted object keys, so the digest is a
- *  function of content only — never key insertion order. */
-function stableStringify(value) {
-    if (value === null || typeof value !== "object")
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(stableStringify).join(",")}]`;
-    const keys = Object.keys(value).sort();
-    const body = keys
-        .map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`)
-        .join(",");
-    return `{${body}}`;
-}
-/** sha256 over the canonical content (every field except `id` and `digest`,
- *  which are derived FROM it). Returns the full `sha256:<hex>` form. */
-function computeLedgerDigest(entry) {
-    const hash = crypto.createHash("sha256");
-    hash.update(stableStringify(entry));
-    return `sha256:${hash.digest("hex")}`;
-}
-/** Content-addressed id: `ldg-` + the first 16 hex chars of the digest. Two
- *  entries with the same content (and createdAt) get the same id. */
-function deriveId(digest) {
-    return `ldg-${digest.replace(/^sha256:/, "").slice(0, 16)}`;
-}
-function seal(content) {
-    const digest = computeLedgerDigest(content);
-    return { ...content, id: deriveId(digest), digest };
-}
-function buildLedgerProposal(input) {
-    const content = {
-        kind: "proposal",
-        schemaVersion: 1,
-        from: input.from,
-        to: input.to,
-        title: input.title,
-        rationale: input.rationale,
-        targetFiles: [...input.targetFiles],
-        suggestedDiff: input.suggestedDiff || "",
-        createdAt: input.createdAt
-    };
-    return seal(content);
-}
-function buildLedgerReview(input) {
-    const content = {
-        kind: "review",
-        schemaVersion: 1,
-        from: input.from,
-        to: input.to,
-        target: input.target,
-        verdict: input.verdict,
-        findings: [...input.findings],
-        createdAt: input.createdAt
-    };
-    return seal(content);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-const PROPOSAL_FIELDS = ["from", "to", "title", "rationale", "targetFiles", "suggestedDiff", "createdAt"];
-const REVIEW_FIELDS = ["from", "to", "target", "verdict", "findings", "createdAt"];
-/** Fail-closed verification. Any structural defect, unknown kind, or digest
- *  mismatch yields `ok:false` — the caller refuses to act on it. */
-function verifyLedgerEntry(raw) {
-    const checks = [];
-    const fail = (name, code, detail) => {
-        checks.push({ name, pass: false, code, detail });
-        return {
-            ok: false,
-            id: isRecord(raw) && typeof raw.id === "string" ? raw.id : null,
-            kind: isRecord(raw) && typeof raw.kind === "string" ? raw.kind : null,
-            checks,
-            failedChecks: checks.filter((c) => !c.pass).map((c) => ({ name: c.name, code: c.code, detail: c.detail }))
-        };
-    };
-    if (!isRecord(raw))
-        return fail("structure", "ledger-not-object", "entry is not a JSON object");
-    checks.push({ name: "structure", pass: true });
-    const kind = raw.kind;
-    if (kind !== "proposal" && kind !== "review")
-        return fail("kind", "ledger-unknown-kind", `kind must be proposal|review, got ${JSON.stringify(kind)}`);
-    checks.push({ name: "kind", pass: true });
-    if (raw.schemaVersion !== 1)
-        return fail("schema", "ledger-bad-schema", `schemaVersion must be 1, got ${JSON.stringify(raw.schemaVersion)}`);
-    checks.push({ name: "schema", pass: true });
-    if (typeof raw.digest !== "string" || !raw.digest)
-        return fail("digest-present", "ledger-missing-digest", "digest is absent or not a string");
-    checks.push({ name: "digest-present", pass: true });
-    const fields = kind === "proposal" ? PROPOSAL_FIELDS : REVIEW_FIELDS;
-    const content = { kind, schemaVersion: 1 };
-    for (const field of fields) {
-        if (!(field in raw))
-            return fail("fields", "ledger-missing-field", `required field ${field} is absent`);
-        content[field] = raw[field];
-    }
-    if (kind === "review" && raw.verdict !== "APPROVED" && raw.verdict !== "REJECTED") {
-        return fail("verdict", "ledger-bad-verdict", `verdict must be APPROVED|REJECTED, got ${JSON.stringify(raw.verdict)}`);
-    }
-    checks.push({ name: "fields", pass: true });
-    const recomputed = computeLedgerDigest(content);
-    if (recomputed !== raw.digest) {
-        return fail("digest", "ledger-digest-mismatch", `stored digest does not match content (recomputed ${recomputed})`);
-    }
-    checks.push({ name: "digest", pass: true });
-    // Bind the id to the content: it MUST be the content-addressed id derived from
-    // the digest. Without this, `id` is a free, unverified field (it is excluded
-    // from the digest) — a forged entry could set `id` to collide with a legit
-    // one, and any id-keyed de-duplication (`cw ledger list` union) would silently
-    // drop one of them. Fail closed so a spoofed or absent id is refused, not
-    // trusted.
-    const expectedId = deriveId(raw.digest);
-    if (raw.id !== expectedId) {
-        return fail("id", "ledger-id-mismatch", `id ${JSON.stringify(raw.id)} is not the content-addressed id for this digest (expected ${expectedId})`);
-    }
-    checks.push({ name: "id", pass: true });
-    return { ok: true, id: expectedId, kind, checks, failedChecks: [] };
-}
-/** Fail-closed extraction of a proposal's `suggestedDiff` for `git apply`. The
- *  diff can ONLY escape after the entry verifies: a tampered entry, a review
- *  (not a proposal), or a proposal with no diff all yield `ok:false` and
- *  `diff:null`, so `cw ledger apply <file> | git apply` can never feed an
- *  unverified patch to git. The kernel never shells out to git — turning the
- *  diff into a patch stays the operator's step (mechanism, not policy). */
-function applyLedgerProposal(raw) {
-    const verified = verifyLedgerEntry(raw);
-    if (!verified.ok) {
-        return { ok: false, id: verified.id, kind: verified.kind, diff: null, failedChecks: verified.failedChecks };
-    }
-    if (verified.kind !== "proposal") {
-        return { ok: false, id: verified.id, kind: verified.kind, diff: null, failedChecks: [{ name: "kind", code: "ledger-not-a-proposal", detail: "apply expects a proposal entry, not a review" }] };
-    }
-    const rec = isRecord(raw) ? raw : {};
-    const diff = typeof rec.suggestedDiff === "string" ? rec.suggestedDiff : "";
-    if (!diff) {
-        return { ok: false, id: verified.id, kind: verified.kind, diff: null, failedChecks: [{ name: "diff", code: "ledger-empty-diff", detail: "proposal carries no suggestedDiff to apply" }] };
-    }
-    return { ok: true, id: verified.id, kind: verified.kind, diff, failedChecks: [] };
-}
-/** Read every `*.json` in `dir`, verify each entry fail-closed, and report.
- *  `allOk` is false if any entry is tampered, malformed, or unreadable — so the
- *  receiving side refuses the whole inbox rather than acting on a mixed batch. */
-function listLedgerEntries(dir) {
-    let names;
-    try {
-        names = fs.readdirSync(dir).filter((n) => n.endsWith(".json")).sort();
-    }
-    catch (error) {
-        const entry = { file: dir, id: null, kind: null, from: null, to: null, title: null, target: null, verdict: null, ok: false, failedChecks: [{ name: "dir", code: "ledger-dir-unreadable", detail: error.message }] };
-        return { dir, count: 0, allOk: false, entries: [entry], resolution: resolveLedgerInbox([entry]) };
-    }
-    const entries = names.map((name) => {
-        const file = path.join(dir, name);
-        let raw;
-        try {
-            const stat = fs.lstatSync(file);
-            if (!stat.isFile()) {
-                return { file: name, id: null, kind: null, from: null, to: null, title: null, target: null, verdict: null, ok: false, failedChecks: [{ name: "file", code: "ledger-entry-not-regular" }] };
-            }
-            raw = JSON.parse(fs.readFileSync(file, "utf8"));
-        }
-        catch {
-            return { file: name, id: null, kind: null, from: null, to: null, title: null, target: null, verdict: null, ok: false, failedChecks: [{ name: "parse", code: "ledger-bad-json" }] };
-        }
-        const result = verifyLedgerEntry(raw);
-        const rec = isRecord(raw) ? raw : {};
-        return {
-            file: name,
-            id: result.id,
-            kind: result.kind,
-            from: typeof rec.from === "string" ? rec.from : null,
-            to: typeof rec.to === "string" ? rec.to : null,
-            title: typeof rec.title === "string" ? rec.title : null,
-            target: typeof rec.target === "string" ? rec.target : null,
-            verdict: typeof rec.verdict === "string" ? rec.verdict : null,
-            ok: result.ok,
-            failedChecks: result.failedChecks
-        };
-    });
-    return { dir, count: entries.length, allOk: entries.every((e) => e.ok), entries, resolution: resolveLedgerInbox(entries) };
-}
-/** Union-verify several mirror directories into ONE fail-closed inbox. Verified
- *  entries are de-duplicated by their content-addressed id (the same entry
- *  mirrored to N hosts collapses to one, recording every mirror it came from);
- *  failing entries are kept per-occurrence so every problem in every mirror is
- *  visible. `allOk` is false if ANY entry in ANY mirror does not verify — a
- *  tampered mirror fails the whole batch. Safe because entries are immutable and
- *  content-addressed, so a union is a conflict-free set-union, not a merge. */
-function unionLedgerEntries(dirs) {
-    const byId = new Map();
-    const failures = [];
-    let allOk = true;
-    for (const dir of dirs) {
-        const listed = listLedgerEntries(dir);
-        if (!listed.allOk)
-            allOk = false;
-        for (const entry of listed.entries) {
-            if (entry.ok && entry.id) {
-                const existing = byId.get(entry.id);
-                if (existing) {
-                    if (!existing.dirs.includes(dir))
-                        existing.dirs.push(dir);
-                }
-                else {
-                    byId.set(entry.id, { ...entry, dirs: [dir] });
-                }
-            }
-            else {
-                failures.push({ ...entry, dirs: [dir] });
-            }
-        }
-    }
-    const entries = [...byId.values(), ...failures];
-    return { dirs, count: entries.length, allOk, entries, resolution: resolveLedgerInbox(entries) };
-}
-/** Derive a machine-actionable inbox summary: pair each proposal with the
- *  review(s) that target it and report whether it is pending, approved,
- *  rejected, or contested. Only VERIFIED entries take part — a tampered review
- *  must never resolve a proposal, so a proposal with only a failing review
- *  stays `pending` (fail-closed). Pure derivation over content-addressed
- *  entries: no git, no network, no policy (it reports the decision, it does not
- *  enforce one). */
-function resolveLedgerInbox(entries) {
-    const verified = entries.filter((e) => e.ok);
-    const reviews = verified.filter((e) => e.kind === "review" && e.target);
-    const proposals = verified
-        .filter((e) => e.kind === "proposal" && e.id)
-        .map((p) => {
-        const answering = reviews.filter((r) => r.target === p.id);
-        const verdicts = new Set(answering.map((r) => r.verdict));
-        let resolution;
-        if (answering.length === 0)
-            resolution = "pending";
-        else if (verdicts.size > 1)
-            resolution = "contested";
-        else
-            resolution = verdicts.has("APPROVED") ? "approved" : "rejected";
-        return {
-            id: p.id,
-            title: p.title,
-            resolution,
-            reviews: answering.map((r) => r.id).sort()
-        };
-    })
-        .sort((a, b) => a.id.localeCompare(b.id));
-    const tally = (s) => proposals.filter((p) => p.resolution === s).length;
-    return {
-        proposals,
-        pending: tally("pending"),
-        approved: tally("approved"),
-        rejected: tally("rejected"),
-        contested: tally("contested")
-    };
-}

package/dist/loop-expansion.js

@@ -1,60 +0,0 @@
-"use strict";
-// Bounded dynamic control flow (#2) — a declarative LOOP phase whose tasks are a
-// per-round TEMPLATE: after each round completes, a registered PURE predicate decides
-// whether to run another round (a fresh phase appended after this one, with the same
-// tasks under round-suffixed ids) or stop. Hard-capped at `maxRounds`.
-//
-// REPLAY-DETERMINISM: the predicate is a pure function of RECORDED round results +
-// recorded usage — no IO/clock/random in its context by construction. The engine
-// RECORDS each decision as a `loop-control` state node, so a replay walks the recorded
-// round sequence; re-running the predicate is a verification cross-check, not the
-// source of truth. Predicates are NAMED (registry refs), never inline closures —
-// closures cannot be serialized into state or re-evaluated byte-identically on replay.
-//
-// The materialization (cloning tasks, appending phases, recording the loop-control
-// node) lives in the orchestrator (maybeExpandLoop), which owns writeTaskFiles + the
-// plan pipeline; THIS module is just the pure registry + the STATIC expansion bound.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerLoopPredicate = registerLoopPredicate;
-exports.getLoopPredicate = getLoopPredicate;
-exports.hasLoopPredicate = hasLoopPredicate;
-exports.maxLoopExpansion = maxLoopExpansion;
-const REGISTRY = new Map();
-/** Register a named pure loop predicate (apps register theirs at load; CW ships a few
- *  built-ins below). Re-registering a name overwrites it. */
-function registerLoopPredicate(name, fn) {
-    REGISTRY.set(name, fn);
-}
-function getLoopPredicate(name) {
-    return REGISTRY.get(name);
-}
-function hasLoopPredicate(name) {
-    return REGISTRY.has(name);
-}
-// ---- Built-in predicates ---------------------------------------------------------
-/** Stop once a round produced no findings (a convergence loop: keep going while the
- *  agent still reports findings; stop when a round comes back empty). */
-registerLoopPredicate("no-new-findings", (ctx) => {
-    const empty = ctx.roundResults.every((r) => !r || !Array.isArray(r.findings) || r.findings.length === 0);
-    return empty
-        ? { done: true, reason: "no-new-findings: the latest round produced no findings" }
-        : { done: false, reason: "no-new-findings: the latest round still has findings" };
-});
-/** Always stop after the first round (a degenerate loop ≈ a normal phase; useful as a
- *  default / for tests). */
-registerLoopPredicate("single-round", () => ({ done: true, reason: "single-round: stop after one round" }));
-/** Static worst-case number of EXTRA tasks a fully-expanded run could mint, derived
- *  purely from the workflow DECLARATION (every loop origin phase contributes
- *  (maxRounds-1) × its round-1 task count). Used to keep the drive's iteration bound
- *  safe as tasks grow, WITHOUT reading any runtime result — so the bound is itself
- *  replay-stable and the loop is provably bounded. Zero when there are no loop phases. */
-function maxLoopExpansion(run) {
-    let extra = 0;
-    for (const phase of run.phases) {
-        if (phase.loop && typeof phase.loop.maxRounds === "number" && phase.loop.maxRounds > 1) {
-            const templateTaskCount = phase.taskIds.length;
-            extra += (phase.loop.maxRounds - 1) * templateTaskCount;
-        }
-    }
-    return extra;
-}