cool-workflow 0.1.88 → 0.1.90

package/dist/clones.js

@@ -0,0 +1,162 @@
+"use strict";
+// src/clones.ts — manage the remote-source clone cache that `--link`/URL reviews populate.
+//
+// The cache lives under resolveCwHome()/clones/<hash>/ (one content-addressed checkout per
+// URL+ref). `cw clones list` inspects it; `cw clones gc` reclaims it (a TTL sweep, or --all).
+// Pure filesystem work — no network, no git. Fail closed: gc only ever deletes a path it has
+// proven is INSIDE the clones root (the hash dir names are hex, so this always holds; the
+// assertion guards against a future change).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listClones = listClones;
+exports.gcClones = gcClones;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const run_registry_1 = require("./run-registry");
+function isTrue(value) {
+    return value === true || value === "true" || value === "1" || value === 1;
+}
+function optionalNumber(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+}
+function clonesRoot(args) {
+    // resolveCwHome reads CW_HOME/XDG_STATE_HOME from the environment — the same root the
+    // materialize step writes to, so list/gc see exactly what `--link` created.
+    void args;
+    return node_path_1.default.join((0, run_registry_1.resolveCwHome)(), "clones");
+}
+/** Total bytes of a directory tree, NOT following symlinks (lstat). Missing/unreadable
+ *  entries are skipped — sizing is best-effort and must never throw. */
+function dirSize(dir) {
+    let total = 0;
+    const walk = (d) => {
+        let names;
+        try {
+            names = node_fs_1.default.readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const p = node_path_1.default.join(d, name);
+            let st;
+            try {
+                st = node_fs_1.default.lstatSync(p);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                walk(p);
+            else
+                total += st.size;
+        }
+    };
+    walk(dir);
+    return total;
+}
+function readEntries(root) {
+    let names = [];
+    try {
+        names = node_fs_1.default.readdirSync(root);
+    }
+    catch {
+        return []; // no cache yet
+    }
+    const entries = [];
+    for (const hash of names) {
+        if (hash.startsWith("."))
+            continue; // skip in-progress .stage-* temp dirs
+        const dir = node_path_1.default.join(root, hash);
+        let st;
+        try {
+            st = node_fs_1.default.statSync(dir);
+        }
+        catch {
+            continue;
+        }
+        if (!st.isDirectory())
+            continue;
+        let meta = {};
+        try {
+            meta = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, ".cw-clone-meta.json"), "utf8"));
+        }
+        catch {
+            /* legacy/partial entry without meta — still listable/reclaimable */
+        }
+        entries.push({
+            hash,
+            url: typeof meta.url === "string" ? meta.url : "(unknown)",
+            kind: typeof meta.kind === "string" ? meta.kind : "git",
+            ref: typeof meta.ref === "string" ? meta.ref : null,
+            fetchedAt: typeof meta.fetchedAt === "string" ? meta.fetchedAt : null,
+            commit: typeof meta.commit === "string" ? meta.commit : null,
+            bytes: dirSize(dir)
+        });
+    }
+    entries.sort((a, b) => (a.fetchedAt || "").localeCompare(b.fetchedAt || ""));
+    return entries;
+}
+/** `cw clones list` — every cached remote checkout with its origin, commit, age, and size. */
+function listClones(args) {
+    const root = clonesRoot(args);
+    const entries = readEntries(root);
+    return {
+        schemaVersion: 1,
+        clonesDir: root,
+        count: entries.length,
+        totalBytes: entries.reduce((sum, e) => sum + e.bytes, 0),
+        entries
+    };
+}
+/** `cw clones gc [--older-than-days N] [--all]` — reclaim cached checkouts. Default keeps
+ *  entries fetched within the last 30 days; `--all` removes every entry. Deletes ONLY paths
+ *  proven inside the clones root (fail closed). `--now` (ISO) is injectable for deterministic
+ *  tests; an entry with no fetchedAt is treated as old (eligible). */
+function gcClones(args) {
+    const root = clonesRoot(args);
+    const all = isTrue(args.all);
+    let olderThanDays = null;
+    if (!all) {
+        const raw = args.olderThanDays ?? args["older-than-days"];
+        olderThanDays = optionalNumber(raw) ?? 30;
+        if (!Number.isFinite(olderThanDays) || olderThanDays < 0) {
+            throw new Error(`--older-than-days must be a non-negative number (got ${String(raw)})`);
+        }
+    }
+    let now = Date.now();
+    if (args.now !== undefined) {
+        now = new Date(String(args.now)).getTime();
+        if (!Number.isFinite(now))
+            throw new Error(`--now must be a valid ISO date (got ${String(args.now)})`);
+    }
+    const cutoff = olderThanDays != null ? now - olderThanDays * 24 * 60 * 60 * 1000 : Infinity;
+    const rootResolved = node_path_1.default.resolve(root);
+    const removed = [];
+    let freedBytes = 0;
+    const entries = readEntries(root);
+    for (const entry of entries) {
+        if (!all) {
+            // Fail-SAFE: a TTL sweep reclaims only entries we can PROVE are old enough. An entry with
+            // no (or an unparseable) fetchedAt is a partial/legacy materialize that never wrote meta —
+            // we cannot date it, so we KEEP it (never delete what you can't age). `--all` clears them.
+            if (!entry.fetchedAt)
+                continue;
+            const age = new Date(entry.fetchedAt).getTime();
+            if (!Number.isFinite(age) || age > cutoff)
+                continue;
+        }
+        const dir = node_path_1.default.join(root, entry.hash);
+        if (!node_path_1.default.resolve(dir).startsWith(rootResolved + node_path_1.default.sep))
+            continue; // containment, fail closed
+        node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+        removed.push({ hash: entry.hash, url: entry.url, bytes: entry.bytes });
+        freedBytes += entry.bytes;
+    }
+    return { schemaVersion: 1, clonesDir: root, removed, freedBytes, keptCount: entries.length - removed.length, olderThanDays, all };
+}

package/dist/drive.js

@@ -32,6 +32,7 @@ exports.drive = drive;
 exports.drivePreview = drivePreview;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const term_1 = require("./term");
 const dispatch_1 = require("./dispatch");
 const execution_backend_1 = require("./execution-backend");
 const worker_isolation_1 = require("./worker-isolation");
@@ -690,6 +691,34 @@ function drive(runner, runId, options = {}) {
         const cap = Math.max(1, Math.floor(run.workflow.limits?.maxConcurrentAgents || 1));
         return Math.max(1, Math.min(cap, phase.taskIds.length));
     };
+    // Phase-boundary progress (brew-style): announce each phase when it becomes active
+    // and when it finishes — `==> Map ✓ (6/6)` / `==> Assess … (3/6)`. Describes CW's OWN
+    // phases (vendor-neutral); goes to stderr via emitProgress so stdout stays clean data.
+    const announcedPhaseComplete = new Set();
+    let activePhaseId;
+    const titleCase = (s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
+    const emitPhaseProgress = (run) => {
+        for (const ph of run.phases || []) {
+            const phaseTasks = run.tasks.filter((task) => ph.taskIds.includes(task.id));
+            const total = phaseTasks.length;
+            if (total === 0)
+                continue;
+            const done = phaseTasks.filter((task) => task.status === "completed").length;
+            const label = titleCase(ph.name || ph.id);
+            if (done >= total) {
+                if (!announcedPhaseComplete.has(ph.id)) {
+                    announcedPhaseComplete.add(ph.id);
+                    emitProgress((0, term_1.phaseProgressLine)(label, done, total, ph.mode, process.stderr));
+                }
+                continue;
+            }
+            if (ph.id !== activePhaseId) {
+                activePhaseId = ph.id;
+                emitProgress((0, term_1.phaseProgressLine)(label, done, total, ph.mode, process.stderr));
+            }
+            return; // only the first not-yet-complete phase is "active"
+        }
+    };
     for (let i = 0; i < maxIterations; i++) {
         const width = concurrency > 1 ? concurrency : autoWidth(runner.loadRun(runId));
         const roundSteps = width > 1 ? driveConcurrentRound(ctx, width) : [driveStep(ctx)];
@@ -706,6 +735,10 @@ function drive(runner, runId, options = {}) {
                 .filter(Boolean)
                 .join(" "));
         }
+        // Brew-style phase boundaries: after each round, announce a newly-active phase and
+        // any phase that just finished (`==> Map ✓ (6/6)` / `==> Assess … (3/6)`). Cheap —
+        // reuses the run we just advanced; goes to stderr via emitProgress so stdout is clean.
+        emitPhaseProgress(runner.loadRun(runId));
         const last = roundSteps[roundSteps.length - 1];
         if (options.once)
             break;
@@ -739,7 +772,8 @@ function drive(runner, runId, options = {}) {
         parkedWorkers,
         commitId: committed?.id,
         reportPath: run.paths.report,
-        statePath: run.paths.state
+        statePath: run.paths.state,
+        agentConfigured: agentConfigured(config)
     };
 }
 /** Read-only, deterministic preview of the NEXT drive step for a run — no mutation,

package/dist/mcp/tool-call.js

@@ -402,6 +402,10 @@ function callTool(name, args) {
             return (0, capability_core_1.gcRun)((0, capability_core_1.runRegistryFor)(args, runner), (0, capability_core_1.optionalString)(args.runId), args);
         case "cw_gc_verify":
             return (0, capability_core_1.gcVerify)((0, capability_core_1.runRegistryFor)(args, runner), String(args.runId || ""), args);
+        case "cw_clones_list":
+            return (0, capability_core_1.listClones)(args);
+        case "cw_clones_gc":
+            return (0, capability_core_1.gcClones)(args);
         case "cw_telemetry_verify":
             return (0, capability_core_1.telemetryVerify)(runner, args);
         case "cw_history":

package/dist/mcp/tool-definitions.js

@@ -952,6 +952,11 @@ function toolDefinitions() {
             scope: stringSchema("home (default, cross-repo) or repo"),
             runId: stringSchema("Run id to verify")
         }),
+        capabilityTool("clones.list", "List the cached remote-source checkouts that `--link`/URL reviews populate (origin URL, kind, commit, age, bytes). Read-only. Peer of `cw clones list`.", {}),
+        capabilityTool("clones.gc", "Reclaim cached remote-source checkouts: a TTL sweep (entries older than --older-than-days, default 30) or --all. Deletes only inside the clones cache. Peer of `cw clones gc`.", {
+            olderThanDays: numberSchema("Reclaim checkouts fetched more than N days ago (default 30; ignored with all)"),
+            all: booleanSchema("Reclaim every cached checkout")
+        }),
         capabilityTool("telemetry.verify", "Re-prove a run's telemetry attestation ledger offline: prevHash chain linkage + independent per-record hash recompute (never trusts the stored hash), and optionally re-run ed25519 checks with a public key. A forged or edited record fails it. Peer of `cw telemetry verify`.", {
             cwd: stringSchema("Repo workspace"),
             runId: stringSchema("Run id to verify"),

package/dist/orchestrator/report.js

@@ -39,6 +39,12 @@ function writeReport(run) {
         `- Created: ${run.createdAt}`,
         `- Updated: ${run.updatedAt}`,
         `- Repository: ${String(run.inputs.repo || run.cwd)}`,
+        // Remote provenance (v0.1.91): when the repo was materialized from a --link/URL, record
+        // the sanitized origin + resolved commit so the report itself says where the code came
+        // from. Conditional — absent for a local-repo run, so existing reports stay byte-identical.
+        ...(run.inputs.sourceUrl
+            ? [`- Source: ${String(run.inputs.sourceUrl)}${run.inputs.sourceCommit ? `@${String(run.inputs.sourceCommit)}` : ""}`]
+            : []),
         `- Question: ${String(run.inputs.question || "")}`,
         `- Invariants: ${formatInputList(run.inputs.invariant)}`,
         `- Loop Stage: ${run.loopStage}`,

package/dist/orchestrator.js

@@ -806,7 +806,7 @@ function parseArgv(argv) {
         }
         if (!token.startsWith("--")) {
             // Single-dash short flag aliases: -q → question, -r → repo, -a → agent-command, -h → help, -v → version
-            const shortMap = { q: "question", r: "repo", a: "agent-command", h: "help", v: "version" };
+            const shortMap = { q: "question", r: "repo", d: "dir", l: "link", a: "agent-command", h: "help", v: "version" };
             const flag = token.slice(1);
             // Handle combined short flags like -qr (not common but safe to ignore)
             const key = shortMap[flag] || flag;
@@ -824,7 +824,13 @@ function parseArgv(argv) {
         }
         else {
             key = withoutPrefix;
-            value = rest[index + 1] && !rest[index + 1].startsWith("--") ? rest[++index] : true;
+            // A flag's value is never ANOTHER flag: reject a next token starting with `-`
+            // (single OR double dash), matching the single-dash branch above. Without this, a
+            // valueless `--flag` greedily swallowed the following single-dash flag — e.g.
+            // `run app --drive -dir /p` made `drive="-dir"` and dropped `-dir` entirely. A
+            // value that legitimately starts with `-` still goes through `--key=-value` or
+            // after a `--` end-of-options marker (both handled above).
+            value = rest[index + 1] && !rest[index + 1].startsWith("-") ? rest[++index] : true;
         }
         appendOption(options, key, value);
     }
@@ -835,7 +841,7 @@ exports.KNOWN_COMMANDS = new Set([
     "help", "list", "doctor", "info", "search", "man", "init", "quickstart", "plan", "status", "next",
     "dispatch", "result", "state", "commit", "report", "app", "sandbox",
     "backend", "contract", "node", "feedback", "worker", "audit", "candidate",
-    "review", "loop", "schedule", "routine", "registry", "run", "queue",
+    "review", "loop", "schedule", "routine", "registry", "run", "queue", "clones",
     "history", "audit-run", "multi-agent", "topology", "summary", "blackboard",
     "coordinator", "metrics", "operator", "sched", "gc", "telemetry",
     "migration", "demo", "workbench", "approve", "reject", "comment", "handoff",
@@ -923,23 +929,48 @@ function formatInfo(appId, data) {
     return lines.join("\n");
 }
 function formatHelp() {
+    // Help is written to stdout, so color must key off stdout (not the term default).
+    const out = process.stdout;
+    const moreCommands = ("list search info init plan status next dispatch result state commit report app " +
+        "sandbox backend contract node feedback worker audit candidate review loop schedule " +
+        "routine registry run queue clones history quickstart audit-run multi-agent topology summary " +
+        "blackboard coordinator metrics operator sched gc telemetry migration demo workbench " +
+        "approve reject comment handoff graph eval man version update fix").split(" ");
+    // Wrap the command list into clean, indented, pipe-joined lines (<=76 cols) instead of
+    // one 400-char line that wraps raggedly and merges with the next shell prompt. Pipe-joined
+    // (no internal spaces) keeps it parseable by the CLI/MCP parity help-token check.
+    const wrapped = [];
+    let line = "  ";
+    for (const cmd of moreCommands) {
+        const sep = line.length > 2 ? "|" : "";
+        if (line.length + sep.length + cmd.length > 76) {
+            wrapped.push(line);
+            line = "  ";
+        }
+        line += (line.length > 2 ? "|" : "") + cmd;
+    }
+    if (line.length > 2)
+        wrapped.push(line);
     return [
-        (0, term_1.bold)("Cool Workflow"),
+        (0, term_1.bold)("Cool Workflow", out),
         "",
         "  -q \"question\" [-claude|-codex|-deepseek]  Ask a question, get a report",
+        "  -q \"question\" --link <url>                 Review a remote repo by URL",
         "  version                                   Show version",
         "  update                                    Update to latest release",
         "  doctor                                    Check setup",
         "  fix                                       Show fix commands for setup issues",
         "",
-        (0, term_1.bold)("Flags"),
+        (0, term_1.bold)("Flags", out),
         "  -q, --question TEXT    The task or question to answer",
         "  -r, --repo PATH        Target repository path (default: .)",
+        "  -d, --dir PATH         Project folder to review (alias for --repo)",
         "  -claude                Use Claude agent",
         "  -codex                 Use Codex agent",
         "  -deepseek              Use DeepSeek (via opencode)",
         "",
-        "  list|search|info|init|plan|status|next|dispatch|result|state|commit|report|app|sandbox|backend|contract|node|feedback|worker|audit|candidate|review|loop|schedule|routine|registry|run|queue|history|quickstart|audit-run|multi-agent|topology|summary|blackboard|coordinator|metrics|operator|sched|gc|telemetry|migration|demo|workbench|approve|reject|comment|handoff|graph|eval|man|version|update|fix  More commands"
+        (0, term_1.bold)("More commands", out),
+        ...wrapped
     ].join("\n");
 }
 function appendOption(options, key, value) {