@izkac/forgekit 0.3.10 → 0.3.12

package/bin/forge.mjs

@@ -63,6 +63,7 @@ Commands:
   change new|archive      Specs-engine change scaffold / archive
   spine init|check        Capability→runtime spine matrix (spine.json)
   e2e init|run|check      Executable product-loop acceptance (e2e.json)
+  e2e disable|enable      Operator-only project e2e off switch
   defer add|resolve|list  Deferral registry (deferred wiring = tracked debt)
   integrity-check         Mechanical integrity gate (runs at phase done)
   score [--write]         L2 session scorecard (auto-written at phase done)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izkac/forgekit",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Forgekit CLIs — forgekit (install), forge (workflow), review (code review)",
   "type": "module",
   "bin": {

package/src/e2e-cli.test.mjs

@@ -73,3 +73,25 @@ test('e2e harness --set requires a description', () => {
   makeFixture(root);
   assert.throws(() => run(root, ['harness', '--set']), /Usage: forge e2e harness --set/);
 });
+
+test('e2e disable/enable toggles the project off switch; check honors it', () => {
+  const root = tmp('e2e-disable-');
+  makeFixture(root);
+
+  assert.match(run(root, ['disable', 'slow legacy stack']), /E2E disabled/);
+  const cfg = JSON.parse(fs.readFileSync(path.join(root, '.forge', 'config.json'), 'utf8'));
+  assert.equal(cfg.e2e.disabled, 'slow legacy stack');
+
+  // check passes without any e2e.json while disabled
+  const check = JSON.parse(run(root, ['check']));
+  assert.equal(check.ok, true);
+  assert.equal(check.disabled, 'slow legacy stack');
+
+  assert.throws(() => run(root, ['disable']), /reason is required/);
+
+  run(root, ['enable']);
+  const cfg2 = JSON.parse(fs.readFileSync(path.join(root, '.forge', 'config.json'), 'utf8'));
+  assert.equal(cfg2.e2e.disabled, null);
+  // gate demands e2e.json again once re-enabled → non-zero exit
+  assert.throws(() => run(root, ['check']));
+});

package/src/e2e.mjs

@@ -9,6 +9,8 @@
  *   forge e2e check                   # gate check: green + current results; exit 1 with problems
  *   forge e2e harness                 # show recorded project harness (reuse it!)
  *   forge e2e harness --set "<desc>" [--start "<cmd>"] [--dir <path>]
+ *   forge e2e disable "<reason>"      # OPERATOR ONLY: project-level e2e off switch
+ *   forge e2e enable                  # re-enable the executed-run requirement
  *   [--session <id>]
  *
  * e2e.json lives next to spine.json (change dir, falling back to the session
@@ -22,6 +24,7 @@ import { loadSession, readActive, readJson } from './lib.mjs';
 import { loadProjectConfig, saveProjectConfig } from './config.mjs';
 import {
   checkE2eGate,
+  e2eDisabledReason,
   e2ePath,
   e2eResultsPath,
   e2eStepsHash,
@@ -37,7 +40,7 @@ const sub = args[0] && !args[0].startsWith('--') ? args[0] : 'status';
 
 if (args[0] === '--help' || sub === 'help') {
   process.stdout.write(
-    'Usage: forge e2e [init [--force] | run | check | status | harness [--set <desc> --start <cmd> --dir <path>]] [--session <id>]\n',
+    'Usage: forge e2e [init [--force] | run | check | status | harness [--set <desc> --start <cmd> --dir <path>] | disable "<reason>" | enable] [--session <id>]\n',
   );
   process.exit(0);
 }
@@ -88,6 +91,28 @@ if (sub === 'harness') {
   process.exit(0);
 }
 
+// Project-level, no session needed. Operator-only: agents must never run
+// `disable` themselves — it is the human's call to trade e2e time away.
+if (sub === 'disable') {
+  const reason = args.slice(1).filter((a) => !a.startsWith('--')).join(' ').trim();
+  if (!reason) {
+    process.stderr.write('Usage: forge e2e disable "<reason>" — a reason is required.\n');
+    process.exit(1);
+  }
+  saveProjectConfig(process.cwd(), { e2e: { disabled: reason } }, { mergeKeys: ['adr', 'plan', 'e2e'] });
+  process.stdout.write(
+    `E2E disabled for this project (.forge/config.json): ${reason}\n` +
+      `Integrity gates stop demanding executed e2e runs. Re-enable: forge e2e enable\n`,
+  );
+  process.exit(0);
+}
+
+if (sub === 'enable') {
+  saveProjectConfig(process.cwd(), { e2e: { disabled: null } }, { mergeKeys: ['adr', 'plan', 'e2e'] });
+  process.stdout.write('E2E re-enabled — executed green runs are required again where the spine has rows.\n');
+  process.exit(0);
+}
+
 let sessionId = null;
 let force = false;
 for (let i = 0; i < args.length; i += 1) {
@@ -170,6 +195,13 @@ if (sub === 'run') {
 }
 
 if (sub === 'check') {
+  const disabled = e2eDisabledReason(process.cwd());
+  if (disabled) {
+    process.stdout.write(
+      `${JSON.stringify({ file, ok: true, disabled, problems: [] }, null, 2)}\n`,
+    );
+    process.exit(0);
+  }
   const gate = checkE2eGate({ e2eFile: file, sessionDir: dir });
   process.stdout.write(
     JSON.stringify(
@@ -184,7 +216,13 @@ if (sub === 'check') {
 
 if (sub === 'status') {
   if (!fs.existsSync(file)) {
-    process.stdout.write(JSON.stringify({ file, exists: false, harness: loadHarness() }, null, 2));
+    process.stdout.write(
+      JSON.stringify(
+        { file, exists: false, disabled: e2eDisabledReason(process.cwd()), harness: loadHarness() },
+        null,
+        2,
+      ),
+    );
     process.stdout.write('\n');
     process.exit(0);
   }
@@ -204,6 +242,7 @@ if (sub === 'status') {
         exists: true,
         ok: valid.ok,
         problems: valid.problems,
+        disabled: e2eDisabledReason(process.cwd()),
         harness: loadHarness(),
         results: results
           ? {

package/src/integrity.mjs

@@ -25,6 +25,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { readJson, writeJson } from './lib.mjs';
+import { loadProjectConfig } from './config.mjs';
 import { DEFAULT_SPECS_DIR, resolveProjectPlanEngine } from './plan-engine.mjs';
 
 /** Signals that a change involves jobs/workers and therefore needs a spine. */
@@ -602,6 +603,25 @@ export function sessionJobsSignalText(session) {
  * @param {{ cwd?: string, sessionDir: string, session: Record<string, unknown> }} opts
  * @returns {{ ok: boolean, problems: string[], spineFile: string, spineExists: boolean, e2eFile: string | null }}
  */
+/**
+ * Project-level e2e off switch: `.forge/config.json` → `e2e.disabled` set to a
+ * non-empty reason string. Operator-set via `forge e2e disable "<reason>"` —
+ * agents must never set it themselves. When set, the integrity gate stops
+ * demanding an executed green e2e run (the most time-consuming part of a
+ * session); spine, deferrals, evidence, and BLOCKED checks still apply.
+ *
+ * @param {string} [cwd]
+ * @returns {string | null} the reason, or null when e2e is enabled
+ */
+export function e2eDisabledReason(cwd = process.cwd()) {
+  try {
+    const reason = loadProjectConfig(cwd)?.e2e?.disabled;
+    return isNonEmptyString(reason) ? reason : null;
+  } catch {
+    return null;
+  }
+}
+
 export function runIntegrityChecks(opts) {
   /** @type {string[]} */
   const problems = [];
@@ -645,9 +665,12 @@ export function runIntegrityChecks(opts) {
   }
 
   let e2eFile = null;
+  const e2eDisabled = e2eDisabledReason(cwd);
   if (spineExists && spineHasRows) {
-    e2eFile = e2ePath({ cwd, session, sessionDir });
-    problems.push(...checkE2eGate({ e2eFile, sessionDir }).problems);
+    if (!e2eDisabled) {
+      e2eFile = e2ePath({ cwd, session, sessionDir });
+      problems.push(...checkE2eGate({ e2eFile, sessionDir }).problems);
+    }
 
     const evidenceFile = path.join(sessionDir, 'verify-evidence.md');
     if (fs.existsSync(evidenceFile) && /\bBLOCKED\b/.test(fs.readFileSync(evidenceFile, 'utf8'))) {
@@ -655,5 +678,5 @@ export function runIntegrityChecks(opts) {
     }
   }
 
-  return { ok: problems.length === 0, problems, spineFile, spineExists, e2eFile };
+  return { ok: problems.length === 0, problems, spineFile, spineExists, e2eFile, e2eDisabled };
 }

package/src/integrity.test.mjs

@@ -470,6 +470,36 @@ test('runIntegrityChecks: spine rows demand an executed green e2e run', () => {
   }
 });
 
+test('runIntegrityChecks: project-level e2e disable skips the executed-run demand', () => {
+  const cwd = tmp('forge-int-e2eoff-');
+  try {
+    const sessionDir = makeSessionDir(cwd);
+    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'), /e2e\.json required/);
+
+    fs.writeFileSync(
+      path.join(cwd, '.forge', 'config.json'),
+      `${JSON.stringify({ e2e: { disabled: 'operator accepts manual verification' } }, null, 2)}\n`,
+      'utf8',
+    );
+    result = runIntegrityChecks({ cwd, sessionDir, session });
+    assert.equal(result.ok, true);
+    assert.equal(result.e2eDisabled, 'operator accepts manual verification');
+
+    // BLOCKED evidence still blocks — the off switch only drops the run demand.
+    fs.writeFileSync(path.join(sessionDir, 'verify-evidence.md'), 'BLOCKED: cannot verify\n', 'utf8');
+    result = runIntegrityChecks({ cwd, sessionDir, session });
+    assert.equal(result.ok, false);
+    assert.match(result.problems.join('\n'), /BLOCKED/);
+  } 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 {

package/src/score.mjs

@@ -12,6 +12,7 @@ import { readJson, writeJson } from './lib.mjs';
 import {
   JOBS_SIGNAL_RE,
   checkE2eGate,
+  e2eDisabledReason,
   e2ePath,
   loadDeferrals,
   openDeferrals,
@@ -153,11 +154,13 @@ function scoreProductLoopBody(body, executedGreen = false) {
     notes.push('no executed green e2e run and no product-loop section in verify-evidence');
     return { points: 0, max, notes };
   }
-  if (/\b(fixture|OP\d+|testdata|sample)\b/i.test(body)) {
+  // \w* suffixes: a trailing \b silently rejected inflected forms ("asserts",
+  // "fixtures", "ratify") and cost honest sessions real points.
+  if (/\b(fixture\w*|OP\d+|testdata\w*|sample\w*)/i.test(body)) {
     pts += 4;
     notes.push('names a fixture / corpus');
   }
-  if (/\b(differ|baseline|ratif|assert|before.?after|output changed)\b/i.test(body)) {
+  if (/\b(differ\w*|baseline\w*|ratif\w*|assert\w*|before.?after|output changed)/i.test(body)) {
     pts += 5;
     notes.push('asserts decision/output change vs baseline');
   } else {
@@ -262,7 +265,8 @@ export function scoreSession(opts) {
     loopNotes = ['verify-evidence.md missing'];
   } else {
     const body = fs.readFileSync(evidenceFile, 'utf8');
-    const executedGreen = e2eRunGreen({ cwd, session, sessionDir });
+    const e2eOff = e2eDisabledReason(cwd);
+    const executedGreen = !e2eOff && e2eRunGreen({ cwd, session, sessionDir });
     if (spineHasRows || JOBS_SIGNAL_RE.test(sessionJobsSignalText(session))) {
       const scored = scoreProductLoopBody(body, executedGreen);
       loopPts = scored.points;
@@ -278,6 +282,9 @@ export function scoreSession(opts) {
         loopNotes = ['no spine rows and no jobs signal — partial credit without product-loop'];
       }
     }
+    if (e2eOff) {
+      loopNotes.push(`e2e disabled by project config ("${e2eOff}") — scored from evidence text only`);
+    }
   }
   checks.push({
     id: 'product_loop',

package/src/score.test.mjs

@@ -179,6 +179,32 @@ Fixture: OP1086
   }
 });
 
+test('scoreSession: product-loop bonuses match inflected forms (asserts, fixtures, ratify)', () => {
+  const root = tmp('forge-score-inflect-');
+  try {
+    const { sessionDir, session } = makeSession(root, { slug: 'jobs-loop' });
+    fs.writeFileSync(
+      path.join(sessionDir, 'spine.json'),
+      `${JSON.stringify(validSpine([validRow()]), null, 2)}\n`,
+      'utf8',
+    );
+    // Every keyword deliberately inflected — a trailing \b used to reject all of these.
+    fs.writeFileSync(
+      path.join(sessionDir, 'verify-evidence.md'),
+      '# Verify\n\n## Product loop\n\n1. seed fixtures\n2. run the loop\n3. asserts the ratify output differs from stored baselines\n',
+      'utf8',
+    );
+    const card = scoreSession({ cwd: root, sessionDir, session });
+    const loop = card.checks.find((c) => c.id === 'product_loop');
+    const notes = loop.notes.join('\n');
+    assert.match(notes, /names a fixture/);
+    assert.match(notes, /asserts decision\/output change/);
+    assert.equal(loop.points, 20);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('scoreSession: green e2e run proves the loop even without the phrase', () => {
   const root = tmp('forge-score-e2e-');
   try {

package/vendor/skills/forge/references/runtime-integrity.md

@@ -80,6 +80,15 @@ driven by any command (e.g. requires a physical device). Reviewers police the
 reason; "no time" or "covered by unit tests" is a REJECT. Keep a short loop
 narrative under `## Product loop` in `verify-evidence.md` as reviewer context.
 
+**Project-level off switch (operator only).** `forge e2e disable "<reason>"`
+records `e2e.disabled` in `.forge/config.json` and the gate stops demanding
+executed runs project-wide (`forge e2e enable` restores it). This is the
+**human's** trade-off to make — an agent must NEVER run `forge e2e disable`,
+suggest it to dodge a red gate, or edit the config key. If the gate blocks
+you, fix the loop or ask the operator. When it is disabled, keep the
+`## Product loop` narrative in `verify-evidence.md` — with no executed run,
+prose is the only loop evidence the scorecard can grade.
+
 ### Keeping the loop cheap (cost policy)
 
 "Too complex to test" is usually a signal to test it, not to wave it through —
@@ -154,6 +163,13 @@ forge defer resolve --task <id>     # when the wiring task actually lands
 - `forge phase done|finish` **refuses** while any deferral is unresolved.
 - An unregistered "later" in a brief or review is a REJECT.
 
+**Prose caveats don't survive — checkboxes and deferrals do.** Never tick a
+`tasks.md` box while a note says the work is unproven ("gate was never taken",
+"not yet verified", "should work"). Scorers, gates, and future sessions see
+the `[x]`, not the sentence above it. If a task is incomplete in any way, the
+box **stays open** or the gap becomes a `forge defer` entry — a ticked box
+documenting its own incompleteness is worse than an open one.
+
 ## Spine matrix (mechanical — `forge spine`)
 
 **Spine is mandatory for every Forge change** — not gated on pace, and not