cool-workflow 0.2.3 → 0.2.5

package/scripts/children/http-batch-delegate-child.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+"use strict";
+
+// HTTP batch delegate child — the endpoint-mode sibling of batch-delegate-child.js.
+// Spawned via `node <this-path>` (shell:false) by runEndpointBatchOutcomes when a
+// concurrent drive round (`--concurrency N`) has one or more ENDPOINT-configured
+// agents. Without it, endpoint tasks in a concurrent round each spawned their own
+// blocking http-delegate-child one after another, so `--concurrency N` ran N
+// endpoint delegations strictly SERIALLY. This child POSTs all N at once from a
+// single process (one Node process holds N in-flight fetches trivially — no per-job
+// child process is needed for HTTP the way it is for a vendor CLI).
+//
+// Reads a JSON array `[{ endpoint, job, timeoutMs }, ...]` on stdin, where `job` is
+// the ALREADY-serialized POST body (byte-identical to the string the serial
+// runAgentEndpoint builds, so the concurrent path posts the same bytes). Fires all
+// jobs concurrently, each POST + optional jobId poll matching http-delegate-child.js,
+// and streams ONE NDJSON line per job — `{i, spawnError?, exitCode, stdout}\n` — the
+// INSTANT that job settles. `i` is the job's index (settle order is concurrent, not
+// submission order, so the parent cannot map a line to its job without it). The line
+// shape and the incremental-streaming reason are shared with batch-delegate-child.js:
+// the parent (runEndpointBatchOutcomes) reuses reconcileBatchOutcomes to read them.
+//
+// THE RED LINE: this child speaks ONLY plain HTTP to the operator-configured
+// endpoint. It imports NO model SDK, holds NO API key, and constructs NO model API
+// request. It re-uses the caller's inherited env for any endpoint auth exactly as
+// http-delegate-child.js does; it reads no credential itself.
+
+const MAX_STDIN_BYTES = 32 * 1024 * 1024;
+// Per-job caps mirror batch-delegate-child.js: CAP bounds each job's RAW stdout
+// bytes; LINE_CAP bounds the ESCAPED NDJSON line (JSON escaping grows bytes), held
+// under the parent's 34MB-per-job maxBuffer grant with a small margin so one job's
+// line can never push the combined stream past the parent's buffer and ENOBUFS the
+// whole batch.
+const CAP = 32 * 1024 * 1024;
+const LINE_CAP = 33 * 1024 * 1024;
+
+// In-flight fetch controllers so a stop signal aborts every open request at once.
+// No grandchild processes exist here (unlike batch-delegate-child.js), so there is
+// no wedged-pipe deadlock to guard — aborting the fetches empties the event loop
+// and the process exits on its own.
+const controllers = new Set();
+let stopSignalReceived = false;
+function onStopSignal(signal) {
+  if (stopSignalReceived) {
+    process.exit(signal === "SIGINT" ? 130 : 143);
+    return;
+  }
+  stopSignalReceived = true;
+  for (const controller of controllers) {
+    try { controller.abort(); } catch {}
+  }
+  // If aborting does not drain the loop promptly (a hung socket), force-exit.
+  setTimeout(() => process.exit(signal === "SIGINT" ? 130 : 143), 5000).unref();
+}
+process.on("SIGINT", () => onStopSignal("SIGINT"));
+process.on("SIGTERM", () => onStopSignal("SIGTERM"));
+
+function writeSettleLine(i, outcome) {
+  let line = JSON.stringify({ i, ...outcome }) + "\n";
+  if (Buffer.byteLength(line) > LINE_CAP) {
+    // Same fail-closed shape as the raw-cap path: capped output is never evidence,
+    // so drop it entirely and name the cap — never ship a line the parent's buffer
+    // cannot hold.
+    line = JSON.stringify({ i, spawnError: `serialized stdout line exceeded ${LINE_CAP} byte cap (${Buffer.byteLength(line)} bytes)`, exitCode: null, stdout: "" }) + "\n";
+  }
+  process.stdout.write(line);
+}
+
+// One job: POST the pre-serialized body, poll a returned jobId until done, and
+// return { exitCode, stdout } or throw. Byte-for-byte the same POST + poll contract
+// as http-delegate-child.js, plus a per-job deadline so one hung endpoint settles as
+// its own error instead of pinning the whole batch to the parent's backstop timeout.
+async function runOne(entry) {
+  const { endpoint, job, timeoutMs } = entry;
+  if (!endpoint) throw new Error("no endpoint");
+  const deadline = Date.now() + (Number(timeoutMs) > 0 ? Number(timeoutMs) : 600000);
+  const controller = new AbortController();
+  controllers.add(controller);
+  const abortAt = setTimeout(() => { try { controller.abort(); } catch {} }, Math.max(0, deadline - Date.now()));
+  try {
+    const post = await fetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: typeof job === "string" ? job : JSON.stringify(job),
+      signal: controller.signal,
+    });
+    if (!post.ok) throw new Error("runner responded " + post.status);
+    let data = await post.json();
+    let guard = 0;
+    while (data && data.jobId && data.done !== true && guard++ < 600) {
+      if (Date.now() >= deadline) throw new Error("endpoint poll timed out");
+      await new Promise((r) => setTimeout(r, 1000));
+      const poll = await fetch(endpoint + (endpoint.includes("?") ? "&" : "?") + "jobId=" + encodeURIComponent(data.jobId), { signal: controller.signal });
+      if (!poll.ok) throw new Error("poll responded " + poll.status);
+      data = await poll.json();
+    }
+    if (typeof data.exitCode !== "number") throw new Error("runner did not report an exitCode");
+    let stdout = String(data.stdout || "");
+    if (Buffer.byteLength(stdout) > CAP) throw new Error(`stdout exceeded ${CAP} byte cap (${Buffer.byteLength(stdout)} bytes)`);
+    return { exitCode: data.exitCode, stdout };
+  } finally {
+    clearTimeout(abortAt);
+    controllers.delete(controller);
+  }
+}
+
+(async () => {
+  // setEncoding("utf8") (as batch-delegate-child.js does), NOT `b += <Buffer>`:
+  // without it each data chunk is a raw Buffer coerced to a string on its own, so
+  // a multibyte char split across a ~64KB pipe-chunk boundary decodes to U+FFFD
+  // and the POSTed prompt is silently corrupted. With the encoding set, Node's
+  // StringDecoder carries partial bytes across chunk boundaries.
+  const read = () => new Promise((res) => { let b = ""; process.stdin.setEncoding("utf8"); process.stdin.on("data", (c) => { if (b.length < MAX_STDIN_BYTES) b += c; }); process.stdin.on("end", () => res(b)); });
+  let jobs;
+  try {
+    jobs = JSON.parse((await read()) || "[]");
+  } catch (e) {
+    process.stdout.write(JSON.stringify([{ spawnError: `invalid stdin JSON: ${String((e && e.message) || e)}`, exitCode: null, stdout: "" }]));
+    return;
+  }
+  if (!Array.isArray(jobs) || !jobs.length) { process.stdout.write("[]"); return; }
+  // allSettled, not Promise.all: one failing job never rejects the others, and
+  // every job's line is already written by runOne's settle below regardless.
+  await Promise.allSettled(jobs.map(async (entry, i) => {
+    try {
+      const out = await runOne(entry);
+      writeSettleLine(i, { exitCode: out.exitCode, stdout: out.stdout });
+    } catch (e) {
+      writeSettleLine(i, { spawnError: String((e && e.message) || e), exitCode: null, stdout: "" });
+    }
+  }));
+})();

package/scripts/children/http-delegate-child.js

@@ -16,6 +16,14 @@
 
 (async () => {
   const MAX_STDIN_BYTES = 32 * 1024 * 1024;
+  // setEncoding("utf8") before reading: Node's StringDecoder then carries a
+  // multibyte UTF-8 char that straddles a ~64KB pipe-chunk boundary across the
+  // two chunks. Without it, each Buffer chunk was coerced to a string on its
+  // own and a split char decoded to U+FFFD on both sides — silently corrupting
+  // a > ~64KB non-ASCII job (this project's prompts are frequently Chinese), or
+  // making the outer JSON.parse throw so the delegation refused. Matches the
+  // batch-delegate-child.js reader.
+  process.stdin.setEncoding("utf8");
   const read = () => new Promise((res) => { let b = ""; process.stdin.on("data", (c) => { if (b.length < MAX_STDIN_BYTES) b += c; }); process.stdin.on("end", () => res(b)); });
   try {
     const job = JSON.parse((await read()) || "{}");

package/scripts/dogfood-release.js

@@ -6,7 +6,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { CoolWorkflowRunner } = require("../dist/shell/orchestrator.js");
 
-const TARGET_VERSION = "0.2.3";
+const TARGET_VERSION = "0.2.5";
 const PREVIOUS_VERSION = "0.1.31";
 const pluginRoot = path.resolve(__dirname, "..");
 const repoRoot = path.resolve(pluginRoot, "..", "..");
@@ -291,7 +291,7 @@ function commandsForTask(taskId, context) {
               "-e",
               [
                 releaseSourceReaderSnippet(),
-                "const files=['docs/dogfood-one-real-repo.7.md','plugins/cool-workflow/docs/dogfood-one-real-repo.7.md','README.md','plugins/cool-workflow/README.md','CHANGELOG.md','RELEASE.md'];",
+                "const files=['plugins/cool-workflow/docs/dogfood-one-real-repo.7.md','README.md','plugins/cool-workflow/README.md','CHANGELOG.md','RELEASE.md'];",
                 "for (const f of files) { if (!surfaceExists(f)) throw new Error('missing '+f); }",
                 "const changelog=readSurface('CHANGELOG.md');",
                 "if (changelog===null) throw new Error('CHANGELOG.md missing from release commit');",

package/scripts/fake-date-for-reproduction.js

@@ -1,7 +1,7 @@
 "use strict";
 
 // fake-date-for-reproduction.js — a Node `--require` preload used ONLY by
-// verify-bump-reproduction.sh. It pins `new Date()` (no-args construction)
+// verify-bump-reproduction.js. It pins `new Date()` (no-args construction)
 // and `Date.now()` to a fixed instant, read from CW_FAKE_DATE (an ISO date or
 // YYYY-MM-DD string). `new Date(explicit args)` is left untouched.
 //

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.2.3");
+    assert.equal(appValidation.summary.version, "0.2.5");
 
     const plan = runJson(
       [
@@ -42,7 +42,7 @@ function main() {
         "--repo",
         tmp,
         "--question",
-        "Prove the deterministic v0.2.3 end-to-end golden path."
+        "Prove the deterministic v0.2.5 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.2.3");
+    assert.equal(state.workflow.app.version, "0.2.5");
     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\.2\.3/);
+    assert.match(report, /Workflow App: end-to-end-golden-path@0\.2\.5/);
     assert.match(report, /## Candidates/);
     assert.match(report, /## Trust Audit/);
     assert.match(report, /## Acceptance Rationale/);

package/scripts/lang-policy-check.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+"use strict";
+// lang-policy-check.js — this project is written in JavaScript and
+// TypeScript only (AGENTS.md hard rule, 2026-07-13). Every git-tracked file
+// must be JS/TS, a recognized non-code file (docs, data, config, binary
+// asset), or one of the explicit, path-scoped exceptions below — a real
+// non-JS/TS file the project genuinely needs. Fail closed: an unrecognized
+// extension/basename is a hard stop, forcing a deliberate choice (write it
+// in JS/TS, or add a new exception here with a reason) instead of a silent
+// pass. Mechanism only; the allowlists ARE the policy, kept as plain data
+// in this one file — no separate config to drift from it.
+
+const { execFileSync } = require("node:child_process");
+const path = require("node:path");
+
+const CODE_EXTENSIONS = new Set(["js", "mjs", "cjs", "ts", "tsx", "jsx"]);
+
+// Real, needed files this project cannot write in JS/TS -- the exact same
+// set already carved out of GitHub's Languages stats in .gitattributes, for
+// the same reasons (see that file's comments). Scoped to an EXACT path,
+// never a whole directory, so a new file dropped in the same folder does
+// NOT silently inherit the exception.
+const EXCEPT_PATHS = new Set([
+  "Formula/cool-workflow.rb", // Homebrew formula must be Ruby
+  "plugins/cool-workflow/ui/workbench/index.html", // served from disk by design
+  "plugins/cool-workflow/ui/workbench/app.css" // served from disk by design
+]);
+
+// Not "code" at all -- docs, data, config, and binary assets. Fine
+// anywhere in the tree; this policy is only about what the project is
+// WRITTEN in, not about every file it ships or tracks.
+const NON_CODE_EXTENSIONS = new Set([
+  "md", "mdc", "txt", "json", "jsonl", "yml", "yaml", "toml",
+  "verdict", "sig", "pub", "tape",
+  "svg", "png", "jpg", "jpeg", "gif", "webp", "ico", "pdf",
+  "woff", "woff2", "gz", "tgz", "zip", "lock"
+]);
+// Extensionless / dotfile basenames that are also not code.
+const NON_CODE_BASENAMES = new Set([
+  "LICENSE", ".gitignore", ".gitattributes", ".editorconfig", ".windsurfrules", ".npmrc", ".nvmrc"
+]);
+
+// `EXCEPT_PATHS` are written repo-root-relative, so tracked files must be
+// resolved the same way regardless of the invocation cwd (this runs both as
+// `npm run lang:check` from plugins/cool-workflow/ AND from release-check.js
+// at various cwds) -- resolve the real top-level first, never trust the
+// invocation cwd to already BE it.
+function trackedFiles() {
+  const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+  return execFileSync("git", ["-C", repoRoot, "ls-files"], { encoding: "utf8" })
+    .split("\n")
+    .filter(Boolean);
+}
+
+function classify(file) {
+  if (EXCEPT_PATHS.has(file)) return { ok: true };
+  const base = path.basename(file);
+  if (NON_CODE_BASENAMES.has(base)) return { ok: true };
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return { ok: false, ext: null };
+  const ext = base.slice(dot + 1).toLowerCase();
+  if (CODE_EXTENSIONS.has(ext) || NON_CODE_EXTENSIONS.has(ext)) return { ok: true };
+  return { ok: false, ext };
+}
+
+const files = trackedFiles();
+const violations = [];
+for (const file of files) {
+  const result = classify(file);
+  if (!result.ok) violations.push({ file, ext: result.ext });
+}
+
+if (violations.length > 0) {
+  process.stderr.write("lang-policy-check: this project is JavaScript/TypeScript only. Unrecognized file(s):\n");
+  for (const v of violations) {
+    process.stderr.write(`  - ${v.file}${v.ext ? ` (.${v.ext})` : " (no extension)"}\n`);
+  }
+  process.stderr.write("Write it in JavaScript/TypeScript, or add a scoped, reasoned exception to scripts/lang-policy-check.js.\n");
+  process.exit(1);
+}
+
+process.stdout.write(`lang-policy-check: ${files.length} tracked files, all JS/TS or an allowed non-code/exception file.\n`);

package/scripts/purity-baseline.json

@@ -36,36 +36,6 @@
   "layerViolations": {
     "core/capability-table.ts": [
       "../wiring/capability-table"
-    ],
-    "wiring/capability-table/basics.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/exec-backend.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/multi-agent.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/pipeline.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/registry-core.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/reporting.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/scheduling-registry.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/state.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/trust-ledger.ts": [
-      "../../cli/io"
-    ],
-    "wiring/capability-table/workflow-apps.ts": [
-      "../../cli/io"
     ]
   }
 }

package/scripts/purity-gate.js

@@ -112,8 +112,12 @@ function stripComments(text) {
 
 // Every `from "spec"` (import or export-from, type or value — a type-only
 // import still names a module, so it counts the same way a real dependency
-// scan would) plus every `require("spec")`. Non-greedy across `from` finds
-// each import's own clause without needing a real parser.
+// scan would) plus every `require("spec")` and every dynamic `import("spec")`.
+// Non-greedy across `from` finds each import's own clause without needing a
+// real parser. The dynamic-import form matters because a core/ file could
+// otherwise smuggle in an impure or cross-layer module through
+// `await import("node:fs")` — the one import shape the static and require
+// scans did not see, so the ratchet was blind to it.
 function extractSpecifiers(codeText) {
   const specs = [];
   const fromRe = /(?:^|\n)\s*(?:import|export)\s[\s\S]*?from\s+["']([^"']+)["']/g;
@@ -121,6 +125,8 @@ function extractSpecifiers(codeText) {
   while ((m = fromRe.exec(codeText))) specs.push(m[1]);
   const requireRe = /require\(\s*["']([^"']+)["']\s*\)/g;
   while ((m = requireRe.exec(codeText))) specs.push(m[1]);
+  const dynamicImportRe = /import\(\s*["']([^"']+)["']\s*\)/g;
+  while ((m = dynamicImportRe.exec(codeText))) specs.push(m[1]);
   return specs;
 }
 
@@ -236,4 +242,11 @@ function main() {
   process.stdout.write("purity gate: src/ matches the committed baseline (no new core/shell layer breaks, no clock/env drift).\n");
 }
 
-main();
+// Run the gate only when invoked directly (node scripts/purity-gate.js). When
+// required by a test, expose the internal helpers so the specifier scan can be
+// unit-checked without shelling out or writing into the real src/ tree.
+if (require.main === module) {
+  main();
+}
+
+module.exports = { stripComments, extractSpecifiers, layerOf, scan };

package/scripts/release-check.js

@@ -60,12 +60,13 @@ const checks = [
   // from that fresh build — strictly stronger than a bare `npm run build`.
   { name: "dist freshness", command: ["npm", "run", "dist:check"] },
   { name: "core/shell purity", command: ["npm", "run", "purity:check"] },
+  { name: "language policy (JS/TS only)", command: ["npm", "run", "lang:check"] },
   { name: "type check", command: ["npm", "run", "check"] },
   { name: "onramp contract", command: ["npm", "run", "onramp:check"] },
   { name: "run-state schema consistency", command: ["node", "scripts/validate-run-state-schema.js"] },
   // Every test path uses --concurrency auto by default (parallel, race-free:
   // each smoke runs in a private cwd + state roots). The release tag-gate
-  // (release-gate.sh) forces CW_TEST_CONCURRENCY=1 to stay sequential as the
+  // (release-gate.js) forces CW_TEST_CONCURRENCY=1 to stay sequential as the
   // deterministic backstop.
   { name: "tests", command: ["npm", "run", "test:ci"] },
   // Pure core/ unit tests (test/*.test.js) — a separate suite from the smoke