@izkac/forgekit 0.1.7 → 0.3.0

package/src/integrity.mjs

@@ -1,6 +1,7 @@
 /**
  * Forge runtime-integrity mechanics: spine matrix, deferral registry,
- * and the integrity checks that gate `forge phase done|finish`.
+ * executable E2E acceptance, and the integrity checks that gate
+ * `forge phase done|finish`.
  *
  * Spine matrix — `spine.json` in the change dir (or session dir when the
  * session has no tracked change). One row per capability/REQ cluster:
@@ -8,13 +9,21 @@
  * Library-only rows (missing runtime owner / writes / evidence) fail
  * validation, so "wire later" cannot be checkboxed past `forge phase done`.
  *
+ * E2E acceptance — `e2e.json` next to the spine: the closed product loop as
+ * an executable step list. `forge e2e run` executes it and records
+ * `e2e-results.json` (session dir) with a hash of the steps, so results go
+ * stale when steps change. When the spine has real rows, the gate requires a
+ * green, current run — prose in verify-evidence.md no longer satisfies it.
+ *
  * Deferral registry — `deferrals.json` in the session dir. Reviewers may only
  * accept "wiring deferred" when a registered deferral names the open task;
  * unresolved deferrals block done/finish.
  */
 
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { readJson, writeJson } from './lib.mjs';
 import { DEFAULT_SPECS_DIR, resolveProjectPlanEngine } from './plan-engine.mjs';
 
@@ -169,6 +178,292 @@ export function validateSpine(doc) {
   return { ok: problems.length === 0, problems };
 }
 
+/* ------------------------------------------------------------------ */
+/* E2E acceptance — executable product loop                            */
+/* ------------------------------------------------------------------ */
+
+const E2E_FILE = 'e2e.json';
+const E2E_RESULTS_FILE = 'e2e-results.json';
+export const E2E_DEFAULT_TIMEOUT_MS = 300_000;
+
+/**
+ * Path to e2e.json: change dir when available, else session dir.
+ *
+ * @param {{ cwd?: string, session?: Record<string, unknown> | null, sessionDir?: string }} opts
+ */
+export function e2ePath(opts = {}) {
+  const changeDir = resolveChangeDir(opts);
+  if (changeDir) return path.join(changeDir, E2E_FILE);
+  if (opts.sessionDir) return path.join(opts.sessionDir, E2E_FILE);
+  throw new Error('Cannot resolve e2e.json location: no change and no session dir');
+}
+
+/**
+ * @param {{ change?: string | null }} [opts]
+ */
+export function e2eTemplate(opts = {}) {
+  return {
+    change: opts.change ?? null,
+    notApplicable: null,
+    steps: [
+      {
+        name: '<boot>',
+        cmd: '<command that starts the system, e.g. docker compose up -d api worker>',
+      },
+      {
+        name: '<produce>',
+        cmd: '<command that drives the real production entry point, e.g. node scripts/e2e/enqueue-analyze.mjs>',
+        expect: '<regex the combined output must match — delete this field if exit code 0 is enough>',
+      },
+      {
+        name: '<consume-assert>',
+        cmd: '<command that proves the domain side effects exist, e.g. node scripts/e2e/assert-ratified.mjs>',
+      },
+    ],
+  };
+}
+
+/**
+ * Scaffold e2e.json (refuses to overwrite unless force).
+ *
+ * @param {{ file: string, change?: string | null, force?: boolean }} opts
+ */
+export function initE2e(opts) {
+  if (fs.existsSync(opts.file) && !opts.force) {
+    throw new Error(`e2e.json already exists: ${opts.file} (use --force to overwrite)`);
+  }
+  writeJson(opts.file, e2eTemplate({ change: opts.change }));
+  return opts.file;
+}
+
+/**
+ * Validate an e2e document.
+ *
+ * Valid when either:
+ *  - `notApplicable` is a non-empty string (loop cannot be driven by any
+ *    command — reviewers police the reason), or
+ *  - `steps` is a non-empty array where every step has a filled `name` and
+ *    `cmd` (no scaffold placeholders), `expect` (optional) is a valid regex,
+ *    and `timeoutMs` (optional) is a positive number.
+ *
+ * @param {unknown} doc
+ * @returns {{ ok: boolean, problems: string[] }}
+ */
+export function validateE2e(doc) {
+  /** @type {string[]} */
+  const problems = [];
+  if (!doc || typeof doc !== 'object' || Array.isArray(doc)) {
+    return { ok: false, problems: ['e2e.json is not an object'] };
+  }
+  const e2e = /** @type {Record<string, unknown>} */ (doc);
+
+  if (isNonEmptyString(e2e.notApplicable)) {
+    return { ok: true, problems: [] };
+  }
+
+  const steps = e2e.steps;
+  if (!Array.isArray(steps) || steps.length === 0) {
+    return {
+      ok: false,
+      problems: [
+        'e2e.steps is empty — add executable product-loop steps, or set notApplicable with a reason',
+      ],
+    };
+  }
+
+  steps.forEach((step, i) => {
+    if (!step || typeof step !== 'object' || Array.isArray(step)) {
+      problems.push(`step ${i + 1}: not an object`);
+      return;
+    }
+    const s = /** @type {Record<string, unknown>} */ (step);
+    for (const field of ['name', 'cmd']) {
+      const value = s[field];
+      if (!isNonEmptyString(value)) {
+        problems.push(`step ${i + 1} (${s.name ?? '?'}): missing ${field}`);
+      } else if (/^<.*>$/.test(value.trim())) {
+        problems.push(`step ${i + 1} (${s.name ?? '?'}): ${field} still has scaffold placeholder`);
+      }
+    }
+    if (s.expect !== undefined && s.expect !== null) {
+      if (!isNonEmptyString(s.expect)) {
+        problems.push(`step ${i + 1} (${s.name ?? '?'}): expect must be a non-empty regex string`);
+      } else if (/^<.*>$/.test(s.expect.trim())) {
+        problems.push(`step ${i + 1} (${s.name ?? '?'}): expect still has scaffold placeholder`);
+      } else {
+        try {
+          new RegExp(s.expect);
+        } catch {
+          problems.push(`step ${i + 1} (${s.name ?? '?'}): expect is not a valid regex`);
+        }
+      }
+    }
+    if (s.timeoutMs !== undefined && (typeof s.timeoutMs !== 'number' || s.timeoutMs <= 0)) {
+      problems.push(`step ${i + 1} (${s.name ?? '?'}): timeoutMs must be a positive number`);
+    }
+  });
+
+  return { ok: problems.length === 0, problems };
+}
+
+/**
+ * Hash of the step list — recorded in results so editing e2e.json after a
+ * green run invalidates the results.
+ *
+ * @param {unknown[]} steps
+ */
+export function e2eStepsHash(steps) {
+  return crypto.createHash('sha256').update(JSON.stringify(steps ?? [])).digest('hex');
+}
+
+/**
+ * @param {string} text
+ */
+function outputTail(text, lines = 30) {
+  if (!text) return '';
+  return text.split(/\r?\n/).slice(-lines).join('\n').trim();
+}
+
+/**
+ * Execute e2e steps sequentially (shell). Stops at the first failure —
+ * later steps depend on earlier ones. Exit code must be 0 and `expect`
+ * (when present) must match combined stdout+stderr.
+ *
+ * @param {{ steps?: unknown[] }} doc — a validated e2e document with steps
+ * @param {{ cwd?: string }} [opts]
+ */
+export function runE2eSteps(doc, opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const steps = Array.isArray(doc?.steps) ? doc.steps : [];
+  /** @type {Array<Record<string, unknown>>} */
+  const results = [];
+  let ok = true;
+
+  for (const step of steps) {
+    const s = /** @type {Record<string, any>} */ (step);
+    if (!ok) {
+      results.push({ name: s.name, cmd: s.cmd, skipped: true });
+      continue;
+    }
+    const started = Date.now();
+    const r = spawnSync(s.cmd, {
+      shell: true,
+      cwd,
+      encoding: 'utf8',
+      timeout: typeof s.timeoutMs === 'number' ? s.timeoutMs : E2E_DEFAULT_TIMEOUT_MS,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    const output = `${r.stdout ?? ''}${r.stderr ?? ''}`;
+    const exitCode = typeof r.status === 'number' ? r.status : null;
+    let expectMatched = null;
+    let stepOk = exitCode === 0;
+    if (stepOk && isNonEmptyString(s.expect)) {
+      expectMatched = new RegExp(s.expect).test(output);
+      stepOk = expectMatched;
+    }
+    results.push({
+      name: s.name,
+      cmd: s.cmd,
+      exitCode,
+      expectMatched,
+      ok: stepOk,
+      durationMs: Date.now() - started,
+      outputTail: outputTail(output),
+      error: r.error ? String(r.error.message ?? r.error) : null,
+    });
+    if (!stepOk) ok = false;
+  }
+
+  return {
+    ok,
+    ranAt: new Date().toISOString(),
+    stepsHash: e2eStepsHash(steps),
+    steps: results,
+  };
+}
+
+/**
+ * @param {string} sessionDir
+ */
+export function e2eResultsPath(sessionDir) {
+  return path.join(sessionDir, E2E_RESULTS_FILE);
+}
+
+/**
+ * @param {string} sessionDir
+ * @param {ReturnType<typeof runE2eSteps>} results
+ */
+export function writeE2eResults(sessionDir, results) {
+  writeJson(e2eResultsPath(sessionDir), results);
+  return e2eResultsPath(sessionDir);
+}
+
+/**
+ * @param {string} sessionDir
+ * @returns {Record<string, any> | null}
+ */
+export function loadE2eResults(sessionDir) {
+  const file = e2eResultsPath(sessionDir);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return readJson(file);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Gate check for the executable E2E acceptance. Returns the problems that
+ * block `forge phase done` — empty when the loop was executed green (and the
+ * results are current), or when e2e.json honestly opts out via notApplicable.
+ *
+ * @param {{ e2eFile: string, sessionDir: string }} opts
+ * @returns {{ problems: string[], notApplicable: boolean }}
+ */
+export function checkE2eGate(opts) {
+  /** @type {string[]} */
+  const problems = [];
+
+  if (!fs.existsSync(opts.e2eFile)) {
+    problems.push(
+      `e2e.json required at ${opts.e2eFile} — run forge e2e init, author the product-loop steps, then forge e2e run. Spine rows mean an async loop exists; it must be executed, not described.`,
+    );
+    return { problems, notApplicable: false };
+  }
+
+  let doc;
+  try {
+    doc = readJson(opts.e2eFile);
+  } catch (err) {
+    problems.push(`e2e.json unreadable: ${err instanceof Error ? err.message : err}`);
+    return { problems, notApplicable: false };
+  }
+
+  const valid = validateE2e(doc);
+  if (!valid.ok) {
+    problems.push(...valid.problems.map((p) => `e2e: ${p}`));
+    return { problems, notApplicable: false };
+  }
+
+  if (isNonEmptyString(doc.notApplicable)) {
+    return { problems: [], notApplicable: true };
+  }
+
+  const results = loadE2eResults(opts.sessionDir);
+  if (!results) {
+    problems.push('e2e-results.json missing — run forge e2e run (a green run is required before done)');
+  } else if (results.stepsHash !== e2eStepsHash(doc.steps)) {
+    problems.push('e2e-results.json is stale — e2e.json changed since the last run; re-run forge e2e run');
+  } else if (!results.ok) {
+    const failed = Array.isArray(results.steps) ? results.steps.find((s) => s?.ok === false) : null;
+    problems.push(
+      `e2e run failed${failed ? ` at step "${failed.name}"` : ''} — fix and re-run forge e2e run`,
+    );
+  }
+
+  return { problems, notApplicable: false };
+}
+
 /**
  * @param {string} sessionDir
  */
@@ -245,13 +540,15 @@ export function sessionJobsSignalText(session) {
  *  2. spine.json — **always required** (filled rows, or `notApplicable` with a
  *     reason). Keyword sniffing is not enough to decide; missing spine is how
  *     library-only platforms checkbox past gaps.
- *  3. verify-evidence.md — when a spine has real rows (not notApplicable): must
- *     exist and contain a product-loop section; an explicit BLOCKED marker means
- *     the change cannot be done. Sync-only work should prefer `notApplicable`
- *     over inventing a fake loop.
+ *  3. E2E acceptance — when a spine has real rows (not notApplicable):
+ *     e2e.json must exist with filled steps (or its own notApplicable reason)
+ *     and e2e-results.json must record a green, current run (steps hash must
+ *     match). Prose in verify-evidence.md does not satisfy this; an explicit
+ *     BLOCKED marker there still means the change cannot be done. Sync-only
+ *     work should prefer spine `notApplicable` over inventing a fake loop.
  *
  * @param {{ cwd?: string, sessionDir: string, session: Record<string, unknown> }} opts
- * @returns {{ ok: boolean, problems: string[], spineFile: string, spineExists: boolean }}
+ * @returns {{ ok: boolean, problems: string[], spineFile: string, spineExists: boolean, e2eFile: string | null }}
  */
 export function runIntegrityChecks(opts) {
   /** @type {string[]} */
@@ -295,23 +592,16 @@ export function runIntegrityChecks(opts) {
     }
   }
 
+  let e2eFile = null;
   if (spineExists && spineHasRows) {
+    e2eFile = e2ePath({ cwd, session, sessionDir });
+    problems.push(...checkE2eGate({ e2eFile, sessionDir }).problems);
+
     const evidenceFile = path.join(sessionDir, 'verify-evidence.md');
-    if (!fs.existsSync(evidenceFile)) {
-      problems.push(
-        'verify-evidence.md missing — spine rows require product-loop evidence (or use notApplicable for sync-only work)',
-      );
-    } else {
-      const body = fs.readFileSync(evidenceFile, 'utf8');
-      if (/\bBLOCKED\b/.test(body)) {
-        problems.push('verify-evidence.md contains BLOCKED — change cannot be marked done while E2E is blocked');
-      } else if (!/product[- ]loop/i.test(body)) {
-        problems.push(
-          'verify-evidence.md has no "Product loop" section — record the closed producer→consumer loop (or BLOCKED). Sync-only changes should use spine notApplicable instead.',
-        );
-      }
+    if (fs.existsSync(evidenceFile) && /\bBLOCKED\b/.test(fs.readFileSync(evidenceFile, 'utf8'))) {
+      problems.push('verify-evidence.md contains BLOCKED — change cannot be marked done while E2E is blocked');
     }
   }
 
-  return { ok: problems.length === 0, problems, spineFile, spineExists };
+  return { ok: problems.length === 0, problems, spineFile, spineExists, e2eFile };
 }

package/src/integrity.test.mjs

@@ -6,16 +6,24 @@ import { tmpdir } from 'node:os';
 import {
   JOBS_SIGNAL_RE,
   addDeferral,
+  checkE2eGate,
+  e2ePath,
+  e2eStepsHash,
+  e2eTemplate,
+  initE2e,
   initSpine,
   loadDeferrals,
   openDeferrals,
   resolveChangeDir,
   resolveDeferral,
+  runE2eSteps,
   runIntegrityChecks,
   sessionJobsSignalText,
   spinePath,
   spineTemplate,
+  validateE2e,
   validateSpine,
+  writeE2eResults,
 } from './integrity.mjs';
 
 function tmp(prefix) {
@@ -215,40 +223,184 @@ test('runIntegrityChecks: empty slug without spine still fails', () => {
   }
 });
 
-test('runIntegrityChecks: spine rows demand product-loop evidence', () => {
+function greenStep(overrides = {}) {
+  return {
+    name: 'produce',
+    cmd: 'node -e "console.log(\'proposals: 3\')"',
+    ...overrides,
+  };
+}
+
+function writeSpineWithRows(sessionDir) {
+  fs.writeFileSync(
+    path.join(sessionDir, 'spine.json'),
+    `${JSON.stringify({ change: null, notApplicable: null, rows: [validRow()] }, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+function writeE2eDoc(sessionDir, doc) {
+  fs.writeFileSync(path.join(sessionDir, 'e2e.json'), `${JSON.stringify(doc, null, 2)}\n`, 'utf8');
+}
+
+test('validateE2e: filled steps pass; template placeholders rejected', () => {
+  assert.equal(validateE2e({ notApplicable: null, steps: [greenStep()] }).ok, true);
+  const scaffold = validateE2e(e2eTemplate({ change: 'x' }));
+  assert.equal(scaffold.ok, false);
+  assert.match(scaffold.problems.join('\n'), /scaffold placeholder/);
+});
+
+test('validateE2e: missing cmd, bad regex, bad timeout, empty steps', () => {
+  assert.match(
+    validateE2e({ steps: [{ name: 'x', cmd: '' }] }).problems.join('\n'),
+    /missing cmd/,
+  );
+  assert.match(
+    validateE2e({ steps: [greenStep({ expect: '(' })] }).problems.join('\n'),
+    /not a valid regex/,
+  );
+  assert.match(
+    validateE2e({ steps: [greenStep({ timeoutMs: -5 })] }).problems.join('\n'),
+    /timeoutMs/,
+  );
+  assert.match(validateE2e({ steps: [] }).problems.join('\n'), /steps is empty/);
+  assert.equal(validateE2e({ steps: [], notApplicable: 'no headless env — manual device loop' }).ok, true);
+});
+
+test('e2e init writes template and refuses overwrite without force', () => {
+  const dir = tmp('forge-e2e-init-');
+  try {
+    const file = path.join(dir, 'e2e.json');
+    initE2e({ file, change: 'my-change' });
+    assert.equal(JSON.parse(fs.readFileSync(file, 'utf8')).change, 'my-change');
+    assert.throws(() => initE2e({ file, change: 'my-change' }), /already exists/);
+    initE2e({ file, change: 'other', force: true });
+    assert.equal(JSON.parse(fs.readFileSync(file, 'utf8')).change, 'other');
+    assert.equal(
+      e2ePath({ cwd: dir, session: { openspecChange: null }, sessionDir: dir }),
+      file,
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('runE2eSteps: green run with expect match', () => {
+  const results = runE2eSteps({ steps: [greenStep({ expect: 'proposals: \\d+' })] });
+  assert.equal(results.ok, true);
+  assert.equal(results.steps[0].exitCode, 0);
+  assert.equal(results.steps[0].expectMatched, true);
+  assert.equal(results.stepsHash, e2eStepsHash([greenStep({ expect: 'proposals: \\d+' })]));
+});
+
+test('runE2eSteps: non-zero exit fails and skips later steps', () => {
+  const results = runE2eSteps({
+    steps: [
+      { name: 'boom', cmd: 'node -e "process.exit(3)"' },
+      greenStep({ name: 'never' }),
+    ],
+  });
+  assert.equal(results.ok, false);
+  assert.equal(results.steps[0].exitCode, 3);
+  assert.equal(results.steps[1].skipped, true);
+});
+
+test('runE2eSteps: exit 0 but expect mismatch fails', () => {
+  const results = runE2eSteps({ steps: [greenStep({ expect: 'ratified: \\d+' })] });
+  assert.equal(results.ok, false);
+  assert.equal(results.steps[0].expectMatched, false);
+});
+
+test('checkE2eGate: missing file, missing results, stale hash, failed run, green, notApplicable', () => {
+  const dir = tmp('forge-e2e-gate-');
+  try {
+    const e2eFile = path.join(dir, 'e2e.json');
+
+    let gate = checkE2eGate({ e2eFile, sessionDir: dir });
+    assert.match(gate.problems.join('\n'), /e2e\.json required/);
+
+    writeE2eDoc(dir, { notApplicable: null, steps: [greenStep()] });
+    gate = checkE2eGate({ e2eFile, sessionDir: dir });
+    assert.match(gate.problems.join('\n'), /e2e-results\.json missing/);
+
+    const results = runE2eSteps({ steps: [greenStep()] });
+    writeE2eResults(dir, results);
+    gate = checkE2eGate({ e2eFile, sessionDir: dir });
+    assert.deepEqual(gate.problems, []);
+
+    writeE2eDoc(dir, { notApplicable: null, steps: [greenStep({ name: 'edited' })] });
+    gate = checkE2eGate({ e2eFile, sessionDir: dir });
+    assert.match(gate.problems.join('\n'), /stale/);
+
+    writeE2eDoc(dir, { notApplicable: null, steps: [{ name: 'boom', cmd: 'node -e "process.exit(1)"' }] });
+    writeE2eResults(dir, runE2eSteps({ steps: [{ name: 'boom', cmd: 'node -e "process.exit(1)"' }] }));
+    gate = checkE2eGate({ e2eFile, sessionDir: dir });
+    assert.match(gate.problems.join('\n'), /failed at step "boom"/);
+
+    writeE2eDoc(dir, { notApplicable: 'loop needs a physical device', steps: [] });
+    gate = checkE2eGate({ e2eFile, sessionDir: dir });
+    assert.deepEqual(gate.problems, []);
+    assert.equal(gate.notApplicable, true);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('runIntegrityChecks: spine rows demand an executed green e2e run', () => {
   const cwd = tmp('forge-int-loop-');
   try {
     const sessionDir = makeSessionDir(cwd);
-    const spineFile = path.join(sessionDir, 'spine.json');
-    fs.writeFileSync(
-      spineFile,
-      `${JSON.stringify({ change: null, notApplicable: null, rows: [validRow()] }, null, 2)}\n`,
-      'utf8',
-    );
+    writeSpineWithRows(sessionDir);
     const session = { slug: 'wire-worker-jobs', openspecChange: null };
 
     let result = runIntegrityChecks({ cwd, sessionDir, session });
     assert.equal(result.ok, false);
-    assert.match(result.problems.join('\n'), /verify-evidence\.md missing/);
+    assert.match(result.problems.join('\n'), /e2e\.json required/);
 
-    const evidenceFile = path.join(sessionDir, 'verify-evidence.md');
-    fs.writeFileSync(evidenceFile, '# Verify\n\ntier 3 green\n', 'utf8');
+    writeE2eDoc(sessionDir, { notApplicable: null, steps: [greenStep()] });
     result = runIntegrityChecks({ cwd, sessionDir, session });
     assert.equal(result.ok, false);
-    assert.match(result.problems.join('\n'), /no "Product loop" section/);
+    assert.match(result.problems.join('\n'), /e2e-results\.json missing/);
 
-    fs.writeFileSync(evidenceFile, '# Verify\n\n## Product loop\n\nBLOCKED: no compose here\n', 'utf8');
+    writeE2eResults(sessionDir, runE2eSteps({ steps: [greenStep()] }));
     result = runIntegrityChecks({ cwd, sessionDir, session });
-    assert.equal(result.ok, false);
-    assert.match(result.problems.join('\n'), /BLOCKED/);
+    assert.equal(result.ok, true);
+    assert.equal(result.e2eFile, path.join(sessionDir, 'e2e.json'));
 
+    // prose "## Product loop" alone no longer satisfies the gate
+    fs.rmSync(path.join(sessionDir, 'e2e-results.json'));
     fs.writeFileSync(
-      evidenceFile,
-      '# Verify\n\n## Product loop\n\ningest x3 -> analyze -> ratify -> run@R: output differs from baseline\n',
+      path.join(sessionDir, 'verify-evidence.md'),
+      '# Verify\n\n## Product loop\n\ningest -> analyze -> ratify: output differs\n',
       'utf8',
     );
     result = runIntegrityChecks({ cwd, sessionDir, session });
-    assert.equal(result.ok, true);
+    assert.equal(result.ok, false);
+    assert.match(result.problems.join('\n'), /e2e-results\.json missing/);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('runIntegrityChecks: BLOCKED in verify-evidence blocks even with green e2e', () => {
+  const cwd = tmp('forge-int-blocked-');
+  try {
+    const sessionDir = makeSessionDir(cwd);
+    writeSpineWithRows(sessionDir);
+    writeE2eDoc(sessionDir, { notApplicable: null, steps: [greenStep()] });
+    writeE2eResults(sessionDir, runE2eSteps({ steps: [greenStep()] }));
+    fs.writeFileSync(
+      path.join(sessionDir, 'verify-evidence.md'),
+      '# Verify\n\nBLOCKED: ratify UI unreachable in CI\n',
+      'utf8',
+    );
+    const result = runIntegrityChecks({
+      cwd,
+      sessionDir,
+      session: { slug: 'wire-worker-jobs', openspecChange: null },
+    });
+    assert.equal(result.ok, false);
+    assert.match(result.problems.join('\n'), /BLOCKED/);
   } finally {
     fs.rmSync(cwd, { recursive: true, force: true });
   }