harness-everything 0.37.0 → 0.38.0

package/ci/fixtures/doc-obligations/reconciliation-s1/fail-session-writes.js

@@ -0,0 +1,116 @@
+'use strict';
+
+// #325 PR #351 review follow-up ("Unwritable session store"): test-only preload that simulates an
+// unwritable session store for one child process, without chmod (cross-platform).
+//
+// Loaded through NODE_OPTIONS=--require <this file> onto the real Stop entry point by
+// ci/mechanism-325-3b-s1-review.test.js. The integration test passes the target session directory in the
+// HARNESS_S1_REVIEW_SESSION_DIR environment variable. While that variable names a directory, every
+// write/rename/open-for-write/unlink whose target is inside it fails with EACCES and nothing else is
+// intercepted: reads, mkdir, and writes outside the session directory keep working, so a failed write
+// cannot be confused with a skipped or missing one. Without the variable this preload is inert.
+
+const fs = require('fs');
+const path = require('path');
+
+(function install() {
+  const sessionDirectory = process.env.HARNESS_S1_REVIEW_SESSION_DIR;
+  if (!sessionDirectory) return;
+  let resolvedDirectory;
+  try { resolvedDirectory = path.resolve(sessionDirectory); } catch (_) { return; }
+  if (!resolvedDirectory || resolvedDirectory === '/') return;
+
+  function unwritable(target) {
+    if (target === undefined || target === null) return false;
+    try {
+      const resolved = path.resolve(String(target));
+      const relative = path.relative(resolvedDirectory, resolved);
+      return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative));
+    } catch (_) { return false; }
+  }
+
+  function writeTargetOpenFlags(flags) {
+    // open()/openSync() only fail for write-capable flags; 'r' stays readable.
+    const value = String(flags || 'r');
+    return value.startsWith('w') || value.startsWith('a') || value.includes('+') || value.includes('x');
+  }
+
+  function eacces(method, target) {
+    const error = new Error(`EACCES: permission denied, ${method} ${target} (simulated session store write failure)`);
+    error.code = 'EACCES';
+    error.errno = -13;
+    error.syscall = method;
+    error.path = String(target);
+    return error;
+  }
+
+  const originalWriteFileSync = fs.writeFileSync;
+  fs.writeFileSync = function (file, ...rest) {
+    if (unwritable(file)) throw eacces('write', file);
+    return originalWriteFileSync.call(fs, file, ...rest);
+  };
+
+  const originalRenameSync = fs.renameSync;
+  fs.renameSync = function (from, to, ...rest) {
+    if (unwritable(from) || unwritable(to)) throw eacces('rename', from);
+    return originalRenameSync.call(fs, from, to, ...rest);
+  };
+
+  const originalOpenSync = fs.openSync;
+  fs.openSync = function (file, flags, ...rest) {
+    if (unwritable(file) && writeTargetOpenFlags(flags)) throw eacces('open', file);
+    return originalOpenSync.call(fs, file, flags, ...rest);
+  };
+
+  const originalUnlinkSync = fs.unlinkSync;
+  fs.unlinkSync = function (file, ...rest) {
+    if (unwritable(file)) throw eacces('unlink', file);
+    return originalUnlinkSync.call(fs, file, ...rest);
+  };
+
+  // Callback forms used by async production paths, if any.
+  const normalizeCallback = args => (typeof args[args.length - 1] === 'function' ? args[args.length - 1] : () => {});
+  const originalWriteFile = fs.writeFile;
+  fs.writeFile = function (file, data, ...rest) {
+    const callback = normalizeCallback(rest);
+    if (unwritable(file)) return process.nextTick(() => callback(eacces('write', file)));
+    return originalWriteFile.call(fs, file, data, ...rest);
+  };
+  const originalRename = fs.rename;
+  fs.rename = function (from, to, ...rest) {
+    const callback = normalizeCallback(rest);
+    if (unwritable(from) || unwritable(to)) return process.nextTick(() => callback(eacces('rename', from)));
+    return originalRename.call(fs, from, to, ...rest);
+  };
+  const originalUnlink = fs.unlink;
+  fs.unlink = function (file, ...rest) {
+    const callback = normalizeCallback(rest);
+    if (unwritable(file)) return process.nextTick(() => callback(eacces('unlink', file)));
+    return originalUnlink.call(fs, file, ...rest);
+  };
+
+  // fs.promises equivalents, if any production path uses them.
+  const promises = fs.promises || null;
+  if (promises) {
+    const originalPromisesWriteFile = promises.writeFile;
+    promises.writeFile = function (file, data, ...rest) {
+      if (unwritable(file)) return Promise.reject(eacces('write', file));
+      return originalPromisesWriteFile.call(promises, file, data, ...rest);
+    };
+    const originalPromisesRename = promises.rename;
+    promises.rename = function (from, to, ...rest) {
+      if (unwritable(from) || unwritable(to)) return Promise.reject(eacces('rename', from));
+      return originalPromisesRename.call(promises, from, to, ...rest);
+    };
+    const originalPromisesUnlink = promises.unlink;
+    promises.unlink = function (file, ...rest) {
+      if (unwritable(file)) return Promise.reject(eacces('unlink', file));
+      return originalPromisesUnlink.call(promises, file, ...rest);
+    };
+    const originalPromisesOpen = promises.open;
+    promises.open = function (file, flags, ...rest) {
+      if (unwritable(file) && writeTargetOpenFlags(flags)) return Promise.reject(eacces('open', file));
+      return originalPromisesOpen.call(promises, file, flags, ...rest);
+    };
+  }
+})();

package/ci/lib/doc-reconciliation-prep-fixtures.js

@@ -5,10 +5,12 @@
 // Each replay creates a fresh workspace and state home, runs ordered actions through one explicitly
 // selected distribution, and returns a replay root with the L1 shape:
 //   { actions: { [actionId]: { exitCode, signal, error, errorCode, stdout, stderr, json, state, pilot } }, state, pilot, pilotReportOrigin }.
-// Nothing here is production code. The pilot switch is passed to children only as a request; no reader for
-// it exists in this preparation slice, so ON replays run the legacy code path. Fixture operations
+// Nothing here is production code. The pilot switch is passed to children through their environment; the S1
+// runtime reads it and, when ON, runs the fail-closed no-credit gate. Fixture operations
 // (provideEvidence, mutateIdentity, timestampHints) write simulated records only inside the replay's own
-// temporary directories. They are contract fixtures, not production commands, and nothing reads them yet.
+// temporary directories. They are contract fixtures, not production commands; no S1 runtime reads them.
+// seedState writes one allowlisted session file (workflow-stages.json) into the replay's own state home, so a case can
+// reach a correlated Fable stage contract. It is test-only; no production code reads or writes through it.
 
 const crypto = require('crypto');
 const fs = require('fs');
@@ -18,9 +20,16 @@ const { spawnSync } = require('child_process');
 
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 const PILOT_SWITCH = 'HARNESS_DOC_RECONCILIATION_PILOT';
-const FIXTURE_OPS = new Set(['provideEvidence', 'mutateIdentity', 'timestampHints']);
-const CONTROLLER_OPS = new Set(['plan', 'start', 'binding', 'step', 'obligation']);
-const ALL_OPS = new Set(['route', 'stop', ...CONTROLLER_OPS, ...FIXTURE_OPS]);
+// Session-directory file the S1 runtime writes its pilot report to. Read-only here; only a report carrying
+// reportOrigin: runtime is accepted.
+const PILOT_REPORT_FILE = 'doc-reconciliation-pilot.json';
+const BASELINE_AUTHOR = Object.freeze({ name: 'doc-recon-replay', email: 'doc-recon-replay@invalid' });
+const BASELINE_DATE = '2026-01-01T00:00:00Z';
+const FIXTURE_OPS = new Set(['provideEvidence', 'mutateIdentity', 'timestampHints', 'seedState', 'gitCommit']);
+const CONTROLLER_OPS = new Set(['plan', 'start', 'binding', 'stageBinding', 'step', 'obligation']);
+const ALL_OPS = new Set(['route', 'stop', 'stopGeneric', ...CONTROLLER_OPS, ...FIXTURE_OPS]);
+// The only session files a case may seed, and only inside its own temporary state home.
+const SEEDABLE_FILES = new Set(['workflow-stages.json']);
 
 // Explicit distributions. Every entry point is named by absolute path; no module is reused across legs.
 const DISTRIBUTIONS = Object.freeze({
@@ -28,13 +37,15 @@ const DISTRIBUTIONS = Object.freeze({
     root: REPO_ROOT,
     controller: path.join(REPO_ROOT, 'hooks', 'scripts', 'workflow-disposition.js'),
     stopGate: path.join(REPO_ROOT, 'hooks', 'scripts', 'workflow-stop-gate.js'),
-    kernel: path.join(REPO_ROOT, 'harness-everything', 'scripts', 'kernel-router.js')
+    kernel: path.join(REPO_ROOT, 'harness-everything', 'scripts', 'kernel-router.js'),
+    genericStopGate: path.join(REPO_ROOT, 'hooks', 'scripts', 'stop-gate.js')
   },
   packaged: {
     root: path.join(REPO_ROOT, 'plugins', 'harness-everything'),
     controller: path.join(REPO_ROOT, 'plugins', 'harness-everything', 'hooks', 'scripts', 'workflow-disposition.js'),
     stopGate: path.join(REPO_ROOT, 'plugins', 'harness-everything', 'hooks', 'scripts', 'workflow-stop-gate.js'),
-    kernel: path.join(REPO_ROOT, 'plugins', 'harness-everything', 'skills', 'harness-everything', 'scripts', 'kernel-router.js')
+    kernel: path.join(REPO_ROOT, 'plugins', 'harness-everything', 'skills', 'harness-everything', 'scripts', 'kernel-router.js'),
+    genericStopGate: path.join(REPO_ROOT, 'plugins', 'harness-everything', 'hooks', 'scripts', 'stop-gate.js')
   }
 });
 
@@ -196,6 +207,29 @@ function runFixture(handle, action, pilot) {
     fs.writeFileSync(target, String(p.content), 'utf8');
     return fixtureResult(handle, pilot, { op: 'mutateIdentity', kind: p.kind, path: p.path });
   }
+  if (action.op === 'gitCommit') {
+    // Commits the replay workspace's current tree into HEAD mid-workflow. The baseline recorded at plan is not moved by
+    // this fixture: the case exists to show that scope is still assessed against that recorded baseline. A clean tree
+    // makes `git commit` fail, so a misused op is an infrastructure fault, not a silent no-op.
+    if (typeof p.message !== 'string' || !p.message.trim()) throw new Error('gitCommit needs a message');
+    git(handle.workspace, ['add', '-A']);
+    git(handle.workspace, [
+      '-c', `user.name=${BASELINE_AUTHOR.name}`, '-c', `user.email=${BASELINE_AUTHOR.email}`, '-c', 'commit.gpgsign=false',
+      'commit', '-q', '--no-verify', '-m', p.message
+    ]);
+    return fixtureResult(handle, pilot, { op: 'gitCommit' });
+  }
+  if (action.op === 'seedState') {
+    // Writes one allowlisted session file into the replay's own state home. The session must already exist, so the
+    // seeded file lands where the runtime reads it; nothing outside the replay's state home is reachable.
+    if (!SEEDABLE_FILES.has(p.file)) throw new Error(`seedState may only write ${[...SEEDABLE_FILES].join(', ')}`);
+    const dir = sessionDirOf(handle);
+    if (!dir) throw new Error('seedState needs an existing session');
+    const target = path.join(dir, p.file);
+    if (!target.startsWith(handle.stateHome + path.sep)) throw new Error('seedState target escaped the replay state home');
+    fs.writeFileSync(target, JSON.stringify(p.json, null, 2), 'utf8');
+    return fixtureResult(handle, pilot, { op: 'seedState', file: p.file });
+  }
   if (action.op === 'timestampHints') {
     const dir = sessionDirOf(handle);
     if (!dir) throw new Error('timestampHints needs an existing session');
@@ -222,6 +256,9 @@ function runAction(handle, action, pilot) {
     result = runScript(handle, scriptFor(handle, 'route', dist.kernel), [], { session_id: sid, cwd: handle.workspace, prompt: p.prompt }, pilot);
   } else if (action.op === 'stop') {
     result = runScript(handle, scriptFor(handle, 'stop', dist.stopGate), [], { session_id: sid, cwd: handle.workspace, hook_event_name: 'Stop' }, pilot);
+  } else if (action.op === 'stopGeneric') {
+    // The second Stop surface (verification reminder). It must exit 0 in every case, like the workflow surface.
+    result = runScript(handle, scriptFor(handle, 'stopGeneric', dist.genericStopGate), [], { session_id: sid, cwd: handle.workspace, hook_event_name: 'Stop' }, pilot);
   } else if (action.op === 'plan') {
     result = runScript(handle, scriptFor(handle, 'plan', dist.controller), [
       'plan', '--session-id', sid, '--requirements-json', JSON.stringify(p.requirements),
@@ -234,6 +271,12 @@ function runAction(handle, action, pilot) {
       'binding', '--session-id', sid, '--step-id', p.stepId, '--binding-id', p.bindingId,
       '--disposition', p.disposition, '--evidence', p.evidence
     ], undefined, pilot);
+  } else if (action.op === 'stageBinding') {
+    // Correlated Fable stage binding (the stage-binding command). Generic binding refuses Fable workflows.
+    result = runScript(handle, scriptFor(handle, 'stageBinding', dist.controller), [
+      'stage-binding', '--session-id', sid, '--stage-id', p.stageId, '--binding-id', p.bindingId,
+      '--disposition', p.disposition, '--evidence', p.evidence
+    ], undefined, pilot);
   } else if (action.op === 'step') {
     result = runScript(handle, scriptFor(handle, 'step', dist.controller), [
       'step', '--session-id', sid, '--step-id', p.stepId, '--disposition', p.disposition, '--evidence', p.evidence
@@ -267,6 +310,69 @@ function effectivePilot(action, replayPilot) {
   return Object.prototype.hasOwnProperty.call(action, 'pilot') ? action.pilot : replayPilot;
 }
 
+// Runs git in a replay workspace. Inherited GIT_* variables are removed, so a hook or CI environment cannot point git
+// at another repository. Commit dates are fixed so identical inputs give the same baseline commit on both legs.
+function git(cwd, args) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (key.startsWith('GIT_')) delete env[key];
+  }
+  env.GIT_AUTHOR_DATE = BASELINE_DATE;
+  env.GIT_COMMITTER_DATE = BASELINE_DATE;
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', env, timeout: CHILD_LIMITS.timeoutMs, maxBuffer: CHILD_LIMITS.maxBuffer });
+  if (result.error || result.status !== 0) {
+    const detail = result.error ? result.error.message : String(result.stderr || '').split('\n')[0];
+    throw new Error(`git failed in the replay workspace: ${detail}`);
+  }
+  return result.stdout;
+}
+
+function writeWorkspaceFiles(workspace, files) {
+  for (const [rel, content] of Object.entries(files)) {
+    if (typeof rel !== 'string' || path.isAbsolute(rel) || rel.split(/[\\/]/).includes('..')) {
+      throw new Error(`input path must be workspace-relative: ${rel}`);
+    }
+    const target = path.join(workspace, rel);
+    if (content === null) {
+      fs.rmSync(target, { force: true });
+      continue;
+    }
+    if (typeof content !== 'string') throw new Error(`input file ${rel} must be a string or null`);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, content, 'utf8');
+  }
+}
+
+// Materialises a case's declared file inputs before any action runs. Non-empty baseFiles become a committed Git
+// baseline, so `plan` records a real HEAD. candidateFiles then become the working tree, and a null value deletes a
+// baseline file. Without baseFiles the workspace stays non-Git, so its baseline is unavailable. Fixture maps alone are
+// not runtime authority; the runtime collects scope itself.
+function materialiseInput(handle, input) {
+  const base = (input && input.baseFiles) || {};
+  const candidate = (input && input.candidateFiles) || {};
+  if (Object.keys(base).length) {
+    git(handle.workspace, ['init', '-q']);
+    writeWorkspaceFiles(handle.workspace, base);
+    git(handle.workspace, ['add', '-A']);
+    git(handle.workspace, [
+      '-c', `user.name=${BASELINE_AUTHOR.name}`, '-c', `user.email=${BASELINE_AUTHOR.email}`, '-c', 'commit.gpgsign=false',
+      'commit', '-q', '--no-verify', '-m', 'baseline'
+    ]);
+  }
+  writeWorkspaceFiles(handle.workspace, candidate);
+}
+
+// Read-only extraction of a runtime pilot report from the session directory. Only a report that carries
+// reportOrigin: runtime is accepted. Otherwise the replay reports no pilot with origin harness; nothing is synthesized.
+function runtimePilotOf(handle) {
+  const dir = sessionDirOf(handle);
+  const report = dir ? readJsonOrNull(path.join(dir, PILOT_REPORT_FILE)) : null;
+  if (report && typeof report === 'object' && !Array.isArray(report) && report.reportOrigin === 'runtime') {
+    return { pilot: report, pilotReportOrigin: 'runtime' };
+  }
+  return { pilot: null, pilotReportOrigin: 'harness' };
+}
+
 // Replays one case through one distribution. Actions run in order and the replay stops at its first infrastructure
 // fault: the faulted action is recorded, no later action runs, and the temporary directories are still removed.
 // A crash is recorded, not hidden.
@@ -275,6 +381,7 @@ function replayCase(caseDef, distribution, options = {}) {
   const mode = options.pilot === undefined ? 'off' : 'on';
   const handle = { ...createSession(distribution, caseDef.id, options.pilot), distribution, limits };
   try {
+    materialiseInput(handle, caseDef.input);
     const actions = {};
     for (const action of caseDef.actions) {
       if (Object.prototype.hasOwnProperty.call(actions, action.id)) throw new Error(`duplicate action id ${action.id}`);
@@ -287,8 +394,7 @@ function replayCase(caseDef, distribution, options = {}) {
     return {
       actions,
       state: snapshot(handle),
-      pilot: null,
-      pilotReportOrigin: 'harness'
+      ...runtimePilotOf(handle)
     };
   } finally {
     disposeSession(handle);

package/ci/mechanism-325-3b-preparation.test.js

@@ -29,6 +29,7 @@ const SHARED_FILES = [
   ['hooks/scripts/lib/workflow-obligations.js', 'plugins/harness-everything/hooks/scripts/lib/workflow-obligations.js'],
   ['hooks/scripts/workflow-disposition.js', 'plugins/harness-everything/hooks/scripts/workflow-disposition.js'],
   ['hooks/scripts/workflow-stop-gate.js', 'plugins/harness-everything/hooks/scripts/workflow-stop-gate.js'],
+  ['hooks/scripts/lib/doc-reconciliation-pilot.js', 'plugins/harness-everything/hooks/scripts/lib/doc-reconciliation-pilot.js'],
 ];
 
 let failed = 0;
@@ -91,7 +92,7 @@ checkCase('expected-RED report: legs agree, controls are green, no pilot credit,
     assert.strictEqual(item.parity, 'match', `${item.caseId} source and packaged legs agree`);
   }
   const controls = report.cases.filter(item => item.status === 'CONTROL_PASS').map(item => item.caseId).sort();
-  assert.deepStrictEqual(controls, ['P02d', 'P06', 'P07u']);
+  assert.deepStrictEqual(controls, ['P01', 'P02a', 'P02b', 'P02c', 'P02d', 'P02f', 'P02g', 'P04', 'P06', 'P07-fable-multi-agent-workspace', 'P07-fable-parallel', 'P07-fable-staged', 'P07u']);
 });
 
 checkCase('gap registry: every entry is qualified and the expected-RED mode accounts for all of them', () => {
@@ -102,8 +103,8 @@ checkCase('gap registry: every entry is qualified and the expected-RED mode acco
 });
 
 checkCase('strict mode fails on the recorded gaps and preserves the RED log', () => {
-  const log = path.join(workDir, 'p01-red.json');
-  const run = runRunner(['--strict', '--case', 'P01', '--log', log]);
+  const log = path.join(workDir, 'p02e-red.json');
+  const run = runRunner(['--strict', '--case', 'P02e', '--log', log]);
   assert.strictEqual(run.status, 1, `strict mode exits 1 on gaps: ${run.stdout}`);
   const saved = JSON.parse(fs.readFileSync(log, 'utf8'));
   assert.ok(saved.cases[0].assertions.some(entry => entry.status === 'gap-qualified'), 'the log keeps the qualified gaps');
@@ -116,8 +117,8 @@ checkCase('malformed registry is an infrastructure error, not a RED pass', () =>
 });
 
 checkCase('a registry that omits a gap fails expected-RED mode', () => {
-  const file = writeRegistry('omit-gap.json', copy => { copy.entries = copy.entries.filter(entry => entry.assertionId !== 'P01.on.stop-unsatisfied' || entry.distribution !== 'source'); });
-  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
+  const file = writeRegistry('omit-gap.json', copy => { copy.entries = copy.entries.filter(entry => entry.assertionId !== 'P02e.on.review-pass-exit' || entry.distribution !== 'source'); });
+  const run = runRunner(['--expect-red', '--case', 'P02e', '--registry', file]);
   assert.strictEqual(run.status, 1, `an unqualified gap fails: ${run.stdout}`);
 });
 
@@ -152,9 +153,8 @@ checkCase('negative control: an abnormal route in P01 is infrastructure, and --e
     assert.deepStrictEqual(after.map(item => [item.id, item.pass, item.actual]), before.map(item => [item.id, item.pass, item.actual]),
       `${leg}: the later assertions evaluate exactly as in the unmodified replay`);
     for (const item of after) {
-      const entry = p01Entries.find(candidate => candidate.assertionId === `P01.on.${item.id}` && candidate.distribution === leg);
-      assert.ok(entry && JSON.stringify(fx.normalize(entry.actual)) === JSON.stringify(fx.normalize(item.actual)),
-        `${leg}: ${item.id} still matches its registry actual, so only the infrastructure rule can stop qualification`);
+      assert.strictEqual(item.pass, true,
+        `${leg}: ${item.id} remains strict S1 GREEN, so only the infrastructure rule can stop the replay`);
     }
   }
   const result = runner.classifyCase(p01, injected, p01Entries);