cool-workflow 0.1.92 → 0.1.94

package/scripts/canonical-apps.js

@@ -83,7 +83,7 @@ const canonicalApps = [
       "--source",
       "plugins/cool-workflow/docs/workflow-app-framework.7.md",
       "--scope",
-      "Cool Workflow v0.1.92",
+      "Cool Workflow v0.1.94",
       "--freshness",
       "as of release preparation"
     ]
@@ -117,14 +117,14 @@ function main() {
     assert.ok(summary, `${app.id} must appear in app list`);
     assert.equal(summary.sourceKind, "app-directory");
     assert.equal(summary.legacy, false);
-    assert.equal(summary.version, "0.1.92");
+    assert.equal(summary.version, "0.1.94");
 
     const validation = runJson(["app", "validate", manifestPath]);
     assert.equal(validation.valid, true, `${app.id} manifest must validate`);
 
     const shown = runJson(["app", "show", app.id]);
     assert.equal(shown.app.id, app.id);
-    assert.equal(shown.app.version, "0.1.92");
+    assert.equal(shown.app.version, "0.1.94");
     assert.ok(shown.app.metadata.canonical, `${app.id} must be marked canonical`);
     assert.ok(shown.app.sandboxProfiles.length > 0, `${app.id} must declare sandbox profiles`);
     assertTaskIdsUnique(shown);
@@ -135,7 +135,7 @@ function main() {
     const plan = runJson(["plan", app.id, ...app.args(workspace)]);
     const state = JSON.parse(fs.readFileSync(plan.statePath, "utf8"));
     assert.equal(state.workflow.app.id, app.id);
-    assert.equal(state.workflow.app.version, "0.1.92");
+    assert.equal(state.workflow.app.version, "0.1.94");
     assert.equal(state.workflow.app.metadata.canonical, true);
     assert.ok(state.tasks.some((task) => task.requiresEvidence), `${app.id} plan must include evidence gates`);
     assert.ok(state.tasks.every((task) => task.sandboxProfileId), `${app.id} plan must include sandbox hints`);

package/scripts/dogfood-release.js

@@ -6,7 +6,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { CoolWorkflowRunner } = require("../dist/orchestrator.js");
 
-const TARGET_VERSION = "0.1.92";
+const TARGET_VERSION = "0.1.94";
 const PREVIOUS_VERSION = "0.1.31";
 const pluginRoot = path.resolve(__dirname, "..");
 const repoRoot = path.resolve(pluginRoot, "..", "..");

package/scripts/golden-path.js

@@ -33,7 +33,7 @@ function main() {
     const appValidation = runJson(["app", "validate", "end-to-end-golden-path"], pluginRoot);
     assert.equal(appValidation.valid, true);
     assert.equal(appValidation.summary.id, "end-to-end-golden-path");
-    assert.equal(appValidation.summary.version, "0.1.92");
+    assert.equal(appValidation.summary.version, "0.1.94");
 
     const plan = runJson(
       [
@@ -42,7 +42,7 @@ function main() {
         "--repo",
         tmp,
         "--question",
-        "Prove the deterministic v0.1.92 end-to-end golden path."
+        "Prove the deterministic v0.1.94 end-to-end golden path."
       ],
       pluginRoot
     );
@@ -52,7 +52,7 @@ function main() {
 
     let state = readJson(plan.statePath);
     assert.equal(state.workflow.app.id, "end-to-end-golden-path");
-    assert.equal(state.workflow.app.version, "0.1.92");
+    assert.equal(state.workflow.app.version, "0.1.94");
     assert.equal(state.loopStage, "interpret");
 
     const dispatch = runJson(["dispatch", plan.runId, "--limit", "1", "--sandbox", "readonly"], tmp);
@@ -195,7 +195,7 @@ function main() {
     assert.equal(reportPath, plan.reportPath);
     assert.ok(fs.existsSync(reportPath));
     const report = fs.readFileSync(reportPath, "utf8");
-    assert.match(report, /Workflow App: end-to-end-golden-path@0\.1\.92/);
+    assert.match(report, /Workflow App: end-to-end-golden-path@0\.1\.94/);
     assert.match(report, /## Candidates/);
     assert.match(report, /## Trust Audit/);
     assert.match(report, /## Acceptance Rationale/);

package/scripts/parity-check.js

@@ -69,7 +69,15 @@ function cliDispatchTokens() {
 }
 
 function cliDispatchSources() {
-  return [cli, path.join(pluginRoot, "dist", "cli", "command-surface.js")].filter((file) => fs.existsSync(file));
+  // The dispatcher + every per-command handler module carved out of it (the
+  // command-surface god-object decomposition). A verb's subcommand `case`s may
+  // live in dist/cli/handlers/<group>.js, so scan those too or their tokens read
+  // as "missing from dist/cli.js".
+  const handlersDir = path.join(pluginRoot, "dist", "cli", "handlers");
+  const handlerFiles = fs.existsSync(handlersDir)
+    ? fs.readdirSync(handlersDir).filter((name) => name.endsWith(".js")).map((name) => path.join(handlersDir, name))
+    : [];
+  return [cli, path.join(pluginRoot, "dist", "cli", "command-surface.js"), ...handlerFiles].filter((file) => fs.existsSync(file));
 }
 
 function cliHelpTokens() {

package/scripts/release-flow.js

@@ -119,6 +119,40 @@ function runGate() {
   if (r.status !== 0) die("deterministic gate FAILED — fix findings in normal cycles, do not retry the release here.");
 }
 
+// ---- 1b. vendor liveness preflight (cut only) ------------------------------
+// CW promises claude/codex/gemini/deepseek all work; this proves it before a cut.
+// LIVE: spends real tokens on each vendor, so it runs on --cut (release machine
+// has the keys), not on --check. HARD-BLOCK: any vendor not green stops the cut.
+// Escape hatch CW_SKIP_VENDOR_PREFLIGHT=1 (emergencies/offline). Test seam
+// CW_RELEASE_FLOW_PREFLIGHT_CMD overrides the command (smoke stubs it).
+function runVendorPreflight() {
+  if (!MODE_CUT) {
+    say("[1b/3] vendor preflight — skipped (check mode; live vendor calls run on --cut)");
+    return;
+  }
+  if (process.env.CW_SKIP_VENDOR_PREFLIGHT === "1") {
+    say("[1b/3] vendor preflight — SKIPPED via CW_SKIP_VENDOR_PREFLIGHT=1 (operator override)");
+    return;
+  }
+  const vendors = (process.env.CW_PREFLIGHT_VENDORS || "claude,codex,gemini,deepseek").trim();
+  const override = (process.env.CW_RELEASE_FLOW_PREFLIGHT_CMD || "").trim();
+  say(`[1b/3] vendor preflight — live liveness check: ${vendors}`);
+  let r;
+  if (override) {
+    // Test/override seam — shell:true, smoke/operator only, never the delegated agent.
+    r = spawnSync(override, { cwd: repoRoot, encoding: "utf8", shell: true, stdio: "inherit" });
+  } else {
+    r = spawnSync(process.execPath, [path.join(scriptsDir, "vendor-preflight.js"), "--vendors", vendors], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "inherit"
+    });
+  }
+  if (r.status !== 0) {
+    die("vendor preflight FAILED — a promised vendor is not live (missing CLI/key or broken). Users must not be limited to one vendor; fix before cutting, or set CW_SKIP_VENDOR_PREFLIGHT=1 to override.");
+  }
+}
+
 // ---- 2. independent reviewer, delegated to the configured agent -------------
 function reviewerPromptBody() {
   // Reuse the committed reviewer spec as the prompt; strip YAML frontmatter.
@@ -476,6 +510,7 @@ function main() {
   const inputPath = path.join(markerDir, `review-input-${HEAD}.md`);
 
   runGate();
+  runVendorPreflight();
   fs.writeFileSync(inputPath, buildReviewerInput(resultPath));
   delegateReview(resultPath, inputPath);
   const capability = verifyVerdict(resultPath);

package/scripts/vendor-preflight.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+"use strict";
+
+// vendor-preflight.js — pre-release liveness gate for ALL agent vendors.
+//
+// CW promises that claude, codex, gemini, and deepseek all work. This gate
+// proves it before a release: it runs EACH builtin wrapper against a tiny
+// throwaway git repo with a trivial question and checks the wrapper returns a
+// real, non-empty result. It is the enforcement behind that promise.
+//
+// HARD-BLOCK policy (operator chose this): a vendor that does not return a valid
+// result — missing CLI, auth error, empty/garbage output — counts as FAIL and
+// the gate exits nonzero. There is no "skip"; an unconfigured vendor blocks.
+//
+// This is a LIVE gate: it spends real tokens on each configured vendor. It is
+// meant for the release machine (where all keys/logins exist), NOT the offline
+// CI test suite. The offline smoke (test/vendor-preflight-smoke.js) exercises
+// this script's LOGIC with PATH shims, no keys.
+//
+// Zero runtime dependency: node + git only. stdout is data (the matrix), stderr
+// is diagnostics — same discipline as the rest of CW.
+//
+// Usage:
+//   node vendor-preflight.js [--vendors claude,codex,deepseek] [--question "..."]
+//                            [--timeout-ms 180000] [--json] [--keep]
+//
+// Test seam (smoke/operator only):
+//   CW_PREFLIGHT_AGENTS_DIR  override where wrapper scripts + builtin-templates.json
+//                            are read from (the smoke points this at a shim dir).
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+function argValue(flag, fallback) {
+  const i = process.argv.indexOf(flag);
+  return i >= 0 && i + 1 < process.argv.length ? process.argv[i + 1] : fallback;
+}
+const hasFlag = (flag) => process.argv.includes(flag);
+
+const agentsDir = process.env.CW_PREFLIGHT_AGENTS_DIR || path.join(__dirname, "agents");
+const manifestPath = path.join(agentsDir, "builtin-templates.json");
+const question = argValue("--question", "In one sentence, what does this repo do? Keep it short.");
+const timeoutMs = Number(argValue("--timeout-ms", "180000")) || 180000;
+const asJson = hasFlag("--json");
+const keep = hasFlag("--keep");
+
+function die(msg) {
+  process.stderr.write(msg + "\n");
+  process.exit(2);
+}
+
+let templates;
+try {
+  templates = JSON.parse(fs.readFileSync(manifestPath, "utf8")).templates || {};
+} catch (e) {
+  die(`vendor-preflight: cannot read ${manifestPath}: ${e.message}`);
+}
+
+const onlyRaw = argValue("--vendors", "");
+const only = onlyRaw ? onlyRaw.split(",").map((s) => s.trim()).filter(Boolean) : null;
+const vendors = Object.keys(templates).filter((v) => !only || only.includes(v));
+if (only) {
+  for (const v of only) if (!templates[v]) die(`vendor-preflight: unknown vendor "${v}" — known: ${Object.keys(templates).join(", ")}`);
+}
+if (!vendors.length) die("vendor-preflight: no vendors to check");
+
+// One throwaway git repo + worker input, reused read-only across vendors.
+const work = fs.mkdtempSync(path.join(os.tmpdir(), "cw-preflight-"));
+const repo = path.join(work, "repo");
+fs.mkdirSync(repo, { recursive: true });
+spawnSync("git", ["init", "-q"], { cwd: repo });
+fs.writeFileSync(path.join(repo, "README.md"), "# Tiny App\n\nA one-file demo. main.js reads input and prints it.\n");
+const inputPath = path.join(repo, "input.md");
+fs.writeFileSync(inputPath, `# Worker preflight\n\n- Result: ${path.join(repo, "result.md")}\n\n## Task\n\n${question}\n`);
+
+function checkVendor(name) {
+  const script = templates[name];
+  const wrapper = path.join(agentsDir, script);
+  const resultPath = path.join(repo, `result-${name}.md`);
+  try { fs.rmSync(resultPath, { force: true }); } catch { /* ignore */ }
+  const started = process.hrtime.bigint();
+  const r = spawnSync(process.execPath, [wrapper, inputPath, resultPath], {
+    cwd: repo,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    env: { ...process.env, CW_AGENT_STREAM: "0" }
+  });
+  const ms = Number((process.hrtime.bigint() - started) / 1000000n);
+  const result = (() => { try { return fs.readFileSync(resultPath, "utf8"); } catch { return ""; } })();
+  let model;
+  try { model = JSON.parse(r.stdout || "{}").model; } catch { /* provenance optional */ }
+
+  let status = "PASS";
+  let reason = "";
+  if (r.error && r.error.code === "ETIMEDOUT") {
+    status = "FAIL"; reason = `timed out after ${timeoutMs}ms`;
+  } else if (r.status !== 0) {
+    status = "FAIL"; reason = (r.stderr || "").trim().split("\n").pop() || `exit ${r.status}`;
+  } else if (!result.trim()) {
+    status = "FAIL"; reason = "exit 0 but empty result";
+  }
+  return { vendor: name, status, reason, ms, model, hasContract: /```cw:result/.test(result) };
+}
+
+const rows = vendors.map(checkVendor);
+if (!keep) { try { fs.rmSync(work, { recursive: true, force: true }); } catch { /* ignore */ } }
+
+const failed = rows.filter((r) => r.status !== "PASS");
+
+if (asJson) {
+  process.stdout.write(JSON.stringify({ ok: failed.length === 0, vendors: rows }, null, 2) + "\n");
+} else {
+  for (const r of rows) {
+    const mark = r.status === "PASS" ? "✓" : "✗";
+    const extra = r.status === "PASS"
+      ? `${r.ms}ms${r.model ? `, ${r.model}` : ""}${r.hasContract ? "" : ", no cw:result block"}`
+      : r.reason;
+    process.stdout.write(`  ${mark} ${r.vendor.padEnd(10)} ${r.status}  (${extra})\n`);
+  }
+  process.stdout.write(failed.length === 0
+    ? `vendor-preflight: ok — ${rows.length}/${rows.length} vendors live\n`
+    : `vendor-preflight: BLOCKED — ${failed.length}/${rows.length} vendor(s) not live: ${failed.map((r) => r.vendor).join(", ")}\n`);
+}
+
+process.exit(failed.length === 0 ? 0 : 1);

package/scripts/version-sync-check.js

@@ -196,6 +196,11 @@ function main() {
   checkIncludes("plugins/cool-workflow/docs/release-and-migration.7.md", VERSION, checks);
   checkIncludes("CHANGELOG.md", `## ${VERSION}`, checks);
   checkIncludes("RELEASE.md", VERSION, checks);
+  // Homebrew formula (repo root): git-tag formula. Homebrew scans the version
+  // from the tag, so the tag is the single version surface to gate (an explicit
+  // `version` line would be redundant and brew audit rejects it). bump-version.js
+  // moves this tag.
+  checkIncludes("Formula/cool-workflow.rb", `tag: "v${VERSION}"`, checks);
   checkIncludes("plugins/cool-workflow/skills/cool-workflow/SKILL.md", "release:check", checks);
 
   process.stdout.write(