harness-everything 0.8.0 → 0.8.1

package/hooks/scripts/contract-test.js

@@ -20,7 +20,9 @@ const {
   chooseCorrelatedContract,
   commandMatches,
   listRunContracts,
+  getWorkerId,
 } = require('./lib/fable-contracts');
+const { loadWorkflow, matchingRun } = require('./lib/workflow-runtime');
 
 function resultState(payload) {
   const toolResponse = payload.tool_response || payload.tool_result || {};
@@ -41,6 +43,7 @@ function updateRunContract(entry, payload, command, sessionId) {
   const observedAt = new Date().toISOString();
   const contract = {
     ...entry.contract,
+    workerId: entry.contract.workerId || getWorkerId(payload),
     status: failed ? 'fail' : 'pass',
     lastObservedCommand: command,
     lastObservedExitCode: exitCode ?? null,
@@ -103,8 +106,11 @@ process.stdin.on('end', () => {
     const root = getWorkspaceRoot(payload);
     const stateRoot = getStateRoot(root, payload);
     const sessionId = getSessionId(payload);
+    const workflowContext = loadWorkflow(payload);
+    const activeRun = workflowContext.workflow?.workflowId ? matchingRun(workflowContext) : null;
     const runMatches = listRunContracts(stateRoot).filter(({ contract }) =>
-      ['pending', 'planned', 'running'].includes(contract.status) && commandMatches(contract, command)
+      (contract.workflowId ? ['pending', 'planned', 'running', 'fail', 'pass'] : ['pending', 'planned', 'running']).includes(contract.status) && commandMatches(contract, command) &&
+      (!workflowContext.workflow?.workflowId || (activeRun && contract.runId === activeRun.run.runId && contract.sessionId === sessionId))
     );
 
     if (runMatches.length > 0) {
@@ -115,7 +121,23 @@ process.stdin.on('end', () => {
         process.exit(2);
       }
 
-      const contract = updateRunContract(resolution.match, payload, command, sessionId);
+      const entry = resolution.match;
+      if (entry.contract.workflowId) {
+        const worker = getWorkerId(payload);
+        if (!worker || (entry.contract.workerId && worker !== entry.contract.workerId)) {
+          console.error('[Contract Test] Active workflow check lacks a matching observed worker identity.');
+          process.exit(2);
+        }
+        for (const id of entry.contract.dependsOn || []) {
+          const dependency = JSON.parse(fs.readFileSync(path.join(entry.runRoot, 'contracts', `${id}.json`), 'utf8'));
+          const escaped = workflowContext.workflow.escapes?.some(item => item.stageId === id && item.runId === entry.contract.runId);
+          if (dependency.status !== 'pass' && !escaped) {
+            console.error('[Contract Test] Dependency has not passed: ' + id);
+            process.exit(2);
+          }
+        }
+      }
+      const contract = updateRunContract(entry, payload, command, sessionId);
       console.log(`[Contract Test] ${contract.planId}/${contract.runId}/${contract.stageId}: ${contract.status.toUpperCase()} ${contract.checkCommand}`);
       if (contract.status === 'fail') {
         console.error(`Evidence: ${contract.evidence || '(no output captured)'}`);

package/hooks/scripts/lib/workflow-isolation.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function git(cwd, args) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, timeout: 5000 });
+  if (result.status !== 0) throw new Error('cannot verify Git worktree isolation');
+  return result.stdout.trim();
+}
+
+function canonical(value) {
+  const resolved = path.resolve(value);
+  // The JS resolver preserves Windows 8.3 spellings (RUNNER~1), while Git
+  // reports the long directory name. Native resolution gives one identity.
+  try { return fs.realpathSync.native(resolved); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    const parent = path.dirname(resolved);
+    if (parent === resolved) return resolved;
+    return path.join(canonical(parent), path.basename(resolved));
+  }
+}
+
+function key(value) {
+  const result = canonical(value);
+  return process.platform === 'win32' ? result.toLowerCase() : result;
+}
+
+function within(root, target) {
+  const relative = path.relative(key(root), key(target));
+  return !path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`);
+}
+
+function linkedWorktree(cwd, boundRoot) {
+  const common = canonical(git(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']));
+  const gitDir = canonical(git(cwd, ['rev-parse', '--absolute-git-dir']));
+  const boundCommon = canonical(git(boundRoot, ['rev-parse', '--path-format=absolute', '--git-common-dir']));
+  const top = canonical(git(cwd, ['rev-parse', '--show-toplevel']));
+  if (key(common) === key(gitDir) || key(common) !== key(boundCommon)) return null;
+  const worktrees = git(boundRoot, ['worktree', 'list', '--porcelain', '-z']).split('\0');
+  return worktrees.some(field => field.startsWith('worktree ') && key(field.slice(9)) === key(top)) ? top : null;
+}
+
+// A conservative read subset, not a general shell sandbox.
+function classifyShell(command) {
+  const text = String(command || '').trim();
+  if (!text || /[;&|`\r\n<>$(){}\x00]/.test(text)) return 'mutation-or-unknown';
+  if (/^git\s+worktree\s+add\s+/i.test(text) && !/\s--(?:force|checkout|detach)(?:\s|=|$)/i.test(text)) return 'worktree-setup';
+  if (/\s(?:--(?:output|ext-diff|textconv|exec|pre|pre-glob|pager|open|batch|filters)|-[xoO])(?:\b|=)|\s-(?:exec|execdir|delete|fprint|fprintf)\b/i.test(text)) return 'mutation-or-unknown';
+  if (/^git\s+(?:status|rev-parse|diff|log|show|ls-files|check-ignore)(?:\s|$)/i.test(text) ||
+      /^git\s+branch\s+--show-current$/i.test(text) || /^git\s+worktree\s+list(?:\s|$)/i.test(text) ||
+      /^(?:pwd|ls|dir|cat|type|head|tail|wc|stat|rg|Get-Location|Get-ChildItem|Get-Content|Select-String|Test-Path)(?:\s|$)/i.test(text)) return 'read-only';
+  return 'mutation-or-unknown';
+}
+
+function inputOf(payload) { return payload?.tool_input ?? payload?.toolInput ?? payload?.input ?? {}; }
+function cwdOf(payload, root) {
+  const input = inputOf(payload);
+  return input.workdir || input.cwd || input.working_directory || input.workingDirectory ||
+    payload.cwd || payload.working_directory || payload.workingDirectory || root;
+}
+function commandOf(payload) {
+  const input = inputOf(payload);
+  return String(input.command || input.script || input.cmd || '');
+}
+function mutationPaths(payload) {
+  const input = inputOf(payload);
+  if ((payload.tool_name || payload.tool) === 'apply_patch') {
+    const patch = typeof input === 'string' ? input : input.patch || input.input || '';
+    return [...String(patch).matchAll(/^\*\*\* (?:Add File|Update File|Delete File|Move to): (.+)\r?$/gm)].map(match => match[1].trim());
+  }
+  return [input.file_path || input.filePath || input.path].filter(value => typeof value === 'string' && value.trim());
+}
+function assertTargets(payload, cwd, isolatedRoot) {
+  const targets = mutationPaths(payload);
+  if (!targets.length) throw new Error('mutation target is unknown; cannot verify worktree isolation');
+  for (const target of targets) {
+    const resolved = path.resolve(cwd, target);
+    if (!within(isolatedRoot, resolved) || within(path.join(isolatedRoot, '.git'), resolved)) {
+      throw new Error('mutation target escapes Git worktree isolation or modifies Git metadata');
+    }
+    let parent = path.dirname(resolved);
+    while (!fs.existsSync(parent)) parent = path.dirname(parent);
+    if (key(git(parent, ['rev-parse', '--show-toplevel'])) !== key(isolatedRoot)) throw new Error('mutation target belongs to a different repository');
+  }
+}
+function assertShellScope(command, cwd, isolatedRoot) {
+  if (/(?:^|[;&|\r\n])\s*(?:cd|chdir|pushd|Set-Location|Push-Location)\b/i.test(command)) {
+    throw new Error('use the shell tool working-directory field so isolation can be verified');
+  }
+  const tokens = command.match(/"[^"]*"|'[^']*'|[^\s;&|<>]+/g) || [];
+  for (const token of tokens.slice(1)) {
+    const value = token.replace(/^["']|["']$/g, '').replace(/^[A-Za-z-]+=/, '');
+    if ((path.isAbsolute(value) || /^\.\.[\\/]/.test(value)) && !within(isolatedRoot, path.resolve(cwd, value))) {
+      throw new Error('explicit shell path escapes Git worktree isolation');
+    }
+  }
+}
+
+module.exports = { canonical, key, within, linkedWorktree, classifyShell, inputOf, cwdOf, commandOf, mutationPaths, assertTargets, assertShellScope };

package/hooks/scripts/lib/workflow-runtime.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getWorkspaceRoot, getSessionDir, getSessionId, getStateRoot } = require('./harness-state');
+const { atomicWriteJson, readJson } = require('./fable-contracts');
+
+const OPEN_STATES = new Set(['pending', 'active', 'running', 'failed', 'blocked', 'escaped']);
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+function isMajorWorkflow(workflow) {
+  return Boolean(workflow && (workflow.mutationIsolation?.required || workflow.tier === 'tier3' || String(workflow.strategy || '').startsWith('fable-')));
+}
+
+function loadWorkflow(payload) {
+  const root = getWorkspaceRoot(payload);
+  const sessionId = getSessionId(payload);
+  const sessionDir = getSessionDir(root, sessionId, payload);
+  const file = path.join(sessionDir, 'workflow-run.json');
+  if (!fs.existsSync(file)) return { root, sessionId, sessionDir, file, workflow: null };
+  const workflow = readJson(file);
+  if (!workflow || !['deferred', 'satisfied', ...OPEN_STATES].includes(workflow.state)) {
+    throw new Error('recorded workflow is unreadable or invalid; repair its state before mutation/completion');
+  }
+  const strategies = ['direct-single', 'iterative-single', 'fable-staged', 'fable-parallel', 'fable-multi-agent-workspace'];
+  if (![1, 2].includes(workflow.schemaVersion) || workflow.sessionId !== sessionId ||
+      (workflow.state !== 'deferred' && !strategies.includes(workflow.strategy)) ||
+      (workflow.schemaVersion === 2 && (!workflow.workflowId || !workflow.workflowPlan ||
+        workflow.workflowPlan.strategy !== workflow.strategy || !Number.isInteger(workflow.revision) || workflow.revision < 0))) {
+    throw new Error('recorded workflow schema or session correlation is invalid');
+  }
+  return { root, sessionId, sessionDir, file, workflow };
+}
+
+function saveWorkflow(context) { atomicWriteJson(context.file, context.workflow); }
+
+function matchingRun(context) {
+  const { workflow, root, sessionId } = context;
+  if (!workflow || !SAFE_ID.test(workflow.runId || '') || !workflow.workflowId || !sessionId) return null;
+  const runRoot = path.join(getStateRoot(root), 'fable-runs', workflow.runId);
+  const run = readJson(path.join(runRoot, 'run.json'));
+  if (!run || run.runId !== workflow.runId || run.workflowId !== workflow.workflowId ||
+      run.sessionId !== sessionId || run.strategy !== workflow.strategy ||
+      !Number.isFinite(Date.parse(run.createdAt)) || !Array.isArray(run.stageIds) || !run.stageIds.length ||
+      new Set(run.stageIds).size !== run.stageIds.length || run.stageIds.some(id => !SAFE_ID.test(id))) return null;
+  return { runRoot, run };
+}
+
+function unresolvedStages(match, workflow) {
+  const unresolved = [];
+  const stages = [];
+  for (const stageId of match.run.stageIds) {
+    const contract = readJson(path.join(match.runRoot, 'contracts', `${stageId}.json`));
+    if (!contract || contract.stageId !== stageId || contract.runId !== match.run.runId ||
+        contract.planId !== match.run.planId || contract.sessionId !== match.run.sessionId) {
+      unresolved.push(`${stageId}:missing-or-uncorrelated`);
+      continue;
+    }
+    stages.push(contract);
+    const escape = (workflow.escapes || []).find(item => item.stageId === stageId && item.runId === match.run.runId);
+    if (escape && escape.evidence && escape.uncoveredScope &&
+        ['workflow-uncovered-scope', 'host-capability-unavailable'].includes(escape.reasonCode)) continue;
+    const evidence = readJson(path.join(match.runRoot, 'evidence', `${stageId}.json`));
+    if (contract.status !== 'pass' || !contract.checkCommand || !evidence || evidence.status !== 'pass' ||
+        evidence.exitCode !== 0 || evidence.planId !== contract.planId || evidence.runId !== contract.runId ||
+        evidence.stageId !== stageId || evidence.sessionId !== contract.sessionId ||
+        evidence.checkCommand !== contract.checkCommand || !Number.isFinite(Date.parse(evidence.observedAt)) ||
+        evidence.workerId !== contract.workerId || !evidence.workerId || evidence.observedAt !== contract.verifiedAt) {
+      unresolved.push(`${stageId}:verification-unresolved`);
+    }
+  }
+  if (workflow.verification?.independent) {
+    const verifiers = stages.filter(stage => stage.agent === 'fable-verifier' && stage.writeSet?.length === 0);
+    const workers = stages.filter(stage => stage.agent !== 'fable-verifier').map(stage => stage.workerId).filter(Boolean);
+    const latestCheck = Math.max(0, ...stages.filter(stage => stage.agent !== 'fable-verifier').map(stage => Date.parse(stage.verifiedAt) || 0));
+    if (!verifiers.some(stage => stage.workerId && !workers.includes(stage.workerId) && stage.status === 'pass' &&
+        Date.parse(stage.verifiedAt) >= Math.max(workflow.lastMutationAt || 0, latestCheck) &&
+        match.run.stageIds.filter(id => id !== stage.stageId).every(id => stage.dependsOn?.includes(id)))) {
+      unresolved.push('independent-verifier-missing');
+    }
+  }
+  return unresolved;
+}
+
+function readHookInput(decide) {
+  let input = '';
+  let finished = false;
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    clearTimeout(timeout);
+    try { decide(input.trim() ? JSON.parse(input) : null); }
+    catch (error) { console.error(`[Workflow Gate] ${error.message}`); process.exitCode = 2; }
+  };
+  const timeout = setTimeout(finish, 500);
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', finish);
+  process.stdin.on('error', finish);
+}
+
+module.exports = { OPEN_STATES, SAFE_ID, isMajorWorkflow, loadWorkflow, saveWorkflow, matchingRun, unresolvedStages, readHookInput };

package/hooks/scripts/state-persist.js

@@ -83,6 +83,7 @@ function processState(payload) {
         const command = (payload.tool_input && payload.tool_input.command) || '';
         if (VERIFY_COMMAND_RE.test(command)) {
           state.lastVerifyAt = Date.now();
+          state.lastVerifyExitCode = exitCode ?? null;
         }
       }
 

package/hooks/scripts/workflow-disposition.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { loadWorkflow, saveWorkflow, matchingRun, OPEN_STATES } = require('./lib/workflow-runtime');
+const { getWorkspaceRoot, readCurrentSession } = require('./lib/harness-state');
+const { atomicWriteJson, readJson } = require('./lib/fable-contracts');
+
+const ALLOWED_ESCAPE_REASONS = new Set(['workflow-uncovered-scope', 'host-capability-unavailable']);
+
+function parseArgs(argv) {
+  const args = { command: argv[0] };
+  const flags = new Map([['--reason-code', 'reasonCode'], ['--scope', 'scope'], ['--evidence', 'evidence'], ['--session-id', 'sessionId'], ['--stage-id', 'stageId']]);
+  for (let i = 1; i < argv.length; i++) {
+    const key = flags.get(argv[i]);
+    if (!key || !argv[i + 1] || argv[i + 1].startsWith('--')) throw new Error('unknown or incomplete argument: ' + argv[i]);
+    args[key] = argv[++i];
+  }
+  return args;
+}
+
+function consumer() {
+  for (const relative of ['../../fable-mode/scripts/workflow-plan-consumer.js', '../../skills/fable-mode/scripts/workflow-plan-consumer.js']) {
+    const file = path.resolve(__dirname, relative);
+    if (fs.existsSync(file)) return require(file);
+  }
+  throw new Error('Fable consumer unavailable');
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const sessionId = args.sessionId || readCurrentSession(getWorkspaceRoot());
+  if (!sessionId) throw new Error('no active Harness session; pass --session-id explicitly');
+  const context = loadWorkflow({ session_id: sessionId });
+  const { workflow } = context;
+  if (!workflow || !OPEN_STATES.has(workflow.state)) throw new Error('no unresolved workflow contract exists for this session');
+  if (args.command === 'start') {
+    if (!workflow.workflowId || !workflow.workflowPlan) throw new Error('legacy workflow lacks a correlated plan; cannot start it implicitly');
+    if (workflow.state === 'running') throw new Error('workflow already running; record a blocker before replanning');
+    const max = workflow.workflowPlan.limits?.maxRevisionRounds ?? 2;
+    if (workflow.revision > max) throw new Error('replan budget exhausted; workflow remains blocked');
+    const plan = workflow.pendingPlan || workflow.workflowPlan;
+    if (!String(plan.strategy || '').startsWith('fable-')) {
+      workflow.revision++;
+      workflow.state = 'running';
+      delete workflow.blockReason;
+      saveWorkflow(context);
+      process.stdout.write(JSON.stringify({ state: workflow.state, workflowId: workflow.workflowId, revision: workflow.revision }) + '\n');
+      return;
+    }
+    const stages = readJson(path.join(context.sessionDir, 'workflow-stages.json'));
+    if (!Array.isArray(stages) || !stages.length) throw new Error('write a non-empty workflow-stages.json stage array at the session path first');
+    if (stages.some(stage => !stage.checkCommand || !stage.passCondition)) throw new Error('every required stage needs an objective checkCommand and passCondition');
+    if (plan.verification?.independent && !stages.some(stage => stage.agent === 'fable-verifier' && stage.writeSet?.length === 0 &&
+        stages.filter(other => other !== stage).every(other => stage.dependsOn?.includes(other.stageId)))) {
+      throw new Error('independent verification requires a read-only fable-verifier stage depending on all other stages');
+    }
+    const run = consumer().prepareRun({
+      routerContract: { workflowPlan: plan }, stages, workspaceRoot: context.root,
+      sessionId, workflowId: workflow.workflowId,
+    });
+    workflow.workflowPlan = plan;
+    workflow.strategy = plan.strategy;
+    workflow.tier = plan.tier;
+    workflow.verification = plan.verification;
+    workflow.mutationIsolation = plan.mutationIsolation || workflow.mutationIsolation;
+    workflow.runId = run.runId;
+    workflow.revision++;
+    workflow.state = 'running';
+    workflow.escapes = [];
+    delete workflow.pendingPlan;
+    delete workflow.blockReason;
+  } else if (args.command === 'escape') {
+    if (!ALLOWED_ESCAPE_REASONS.has(args.reasonCode)) throw new Error('generic simple/routine/already-clear reasons are intentionally rejected');
+    if (!args.scope?.trim()) throw new Error('--scope is required');
+    if (!args.evidence?.trim()) throw new Error('--evidence is required');
+    const match = matchingRun(context);
+    if (!match || !match.run.stageIds.includes(args.stageId)) throw new Error('--stage-id must name a stage in the correlated active run');
+    const contract = readJson(path.join(match.runRoot, 'contracts', args.stageId + '.json'));
+    if (contract?.agent === 'fable-verifier') throw new Error('independent verification cannot be escaped; record BLOCKED when unavailable');
+    const disposition = {
+      status: 'escaped', stageId: args.stageId, runId: match.run.runId,
+      reasonCode: args.reasonCode, uncoveredScope: args.scope.trim(), evidence: args.evidence.trim(), recordedAt: new Date().toISOString(),
+    };
+    workflow.escapes = [...(workflow.escapes || []).filter(item => item.stageId !== args.stageId), disposition];
+    atomicWriteJson(path.join(match.runRoot, 'escapes', args.stageId + '.json'), disposition);
+    // Scope-limited exception; never change the entire workflow to escaped.
+  } else if (args.command === 'block') {
+    if (!args.evidence?.trim()) throw new Error('--evidence is required');
+    workflow.state = 'blocked';
+    workflow.blockReason = args.evidence.trim();
+  } else throw new Error('Usage: workflow-disposition.js <start|escape|block> --session-id <id> [--stage-id <id> --reason-code <reason> --scope <scope> --evidence <evidence>]');
+  saveWorkflow(context);
+  process.stdout.write(JSON.stringify({ state: workflow.state, workflowId: workflow.workflowId, runId: workflow.runId, revision: workflow.revision, escapes: workflow.escapes }) + '\n');
+}
+try { main(); } catch (error) { console.error('[Workflow Disposition] ' + error.message); process.exitCode = 2; }

package/hooks/scripts/workflow-gate.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { loadWorkflow, saveWorkflow, isMajorWorkflow, matchingRun, readHookInput } = require('./lib/workflow-runtime');
+const { key, classifyShell, cwdOf, commandOf, mutationPaths, linkedWorktree, assertTargets, assertShellScope } = require('./lib/workflow-isolation');
+
+const DIRECT = new Set(['Edit', 'Write', 'apply_patch']);
+const SHELL = new Set(['Bash', 'PowerShell', 'exec_command']);
+
+function isController(command, cwd) {
+  // One trusted local executable, literal arguments, no shell evaluation.
+  if (/[;&|`\r\n<>$(){}]/.test(command)) return false;
+  const match = command.match(/^node\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s+(start|escape|block)\b/);
+  return Boolean(match && key(path.resolve(cwd, match[1] || match[2] || match[3])) === key(path.join(__dirname, 'workflow-disposition.js')));
+}
+
+function decide(payload) {
+  if (!payload) return;
+  const tool = payload.tool_name || payload.tool;
+  if (!DIRECT.has(tool) && !SHELL.has(tool)) return;
+  const context = loadWorkflow(payload);
+  const { workflow, root, sessionDir } = context;
+  if (!workflow || workflow.state === 'deferred') return;
+  const cwd = cwdOf(payload, root);
+  const command = commandOf(payload);
+  const commandClass = SHELL.has(tool) ? classifyShell(command) : 'direct-mutation';
+  if (commandClass === 'read-only' || commandClass === 'worktree-setup') return;
+  if (SHELL.has(tool) && isController(command, cwd)) return;
+  // Only the stage specification is allowed before run entry. Other runtime
+  // state, including workflow-run.json, cannot use this bootstrap exception.
+  const targets = DIRECT.has(tool) ? mutationPaths(payload) : [];
+  const spec = path.join(sessionDir, 'workflow-stages.json');
+  const specStat = fs.existsSync(spec) ? fs.lstatSync(spec) : null;
+  if ((!specStat || (specStat.isFile() && !specStat.isSymbolicLink() && specStat.nlink === 1)) &&
+      targets.length && targets.every(target => key(path.resolve(cwd, target)) === key(spec))) return;
+  if (['blocked', 'failed'].includes(workflow.state)) throw new Error('workflow is BLOCKED; replan through the controller before mutation');
+  if (isMajorWorkflow(workflow)) {
+    const isolatedRoot = linkedWorktree(cwd, root);
+    if (!isolatedRoot) throw new Error('Git worktree isolation is required before mutation. Enter a linked worktree; unavailable isolation means BLOCKED, never in-place fallback.');
+    if (DIRECT.has(tool)) assertTargets(payload, cwd, isolatedRoot);
+    else assertShellScope(command, cwd, isolatedRoot);
+  }
+  if (workflow.state === 'satisfied') throw new Error('workflow is already satisfied; submit a new task before further mutation');
+  if (String(workflow.strategy || '').startsWith('fable-') && !matchingRun(context)) {
+    throw new Error('selected Fable workflow has no correlated run. Write workflow-stages.json at the displayed session path, then use workflow-disposition.js start.');
+  }
+  workflow.lastMutationAt = Date.now();
+  saveWorkflow(context);
+}
+
+readHookInput(decide);

package/hooks/scripts/workflow-stop-gate.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { readJson } = require('./lib/fable-contracts');
+const { loadWorkflow, saveWorkflow, matchingRun, unresolvedStages, readHookInput } = require('./lib/workflow-runtime');
+
+function decide(payload) {
+  if (!payload) return;
+  const context = loadWorkflow(payload);
+  const { workflow, sessionDir } = context;
+  if (!workflow || ['deferred', 'satisfied'].includes(workflow.state)) return;
+  if (workflow.state === 'blocked') {
+    console.error('[Workflow Completion Gate] BLOCKED: report the unresolved work; completion has not been verified.');
+    return;
+  }
+  let unresolved = [];
+  if (String(workflow.strategy || '').startsWith('fable-')) {
+    const match = matchingRun(context);
+    unresolved = match ? unresolvedStages(match, workflow) : ['correlated-run-missing'];
+  } else {
+    const handoff = readJson(path.join(sessionDir, 'handoff-state.json'));
+    const lastEdit = Math.max(workflow.lastMutationAt || 0, handoff?.lastEditAt || 0);
+    if (lastEdit && ((handoff?.lastVerifyAt || 0) < lastEdit || handoff?.lastVerifyExitCode !== 0)) unresolved = ['verification-after-edit-missing'];
+  }
+  if (unresolved.length) {
+    workflow.unresolved = unresolved;
+    if (payload.stop_hook_active) {
+      // Do not loop forever or pretend the retry satisfied the contract.
+      workflow.state = 'blocked';
+      workflow.blockReason = 'unresolved-stop-retry';
+      saveWorkflow(context);
+      console.error('[Workflow Completion Gate] BLOCKED: ' + unresolved.join(', ') + '. Report the blocker; this is not completion.');
+      return;
+    }
+    saveWorkflow(context);
+    throw new Error('Cannot complete: unresolved workflow obligations: ' + unresolved.join(', '));
+  }
+  workflow.state = 'satisfied';
+  workflow.resolvedAt = new Date().toISOString();
+  workflow.unresolved = [];
+  saveWorkflow(context);
+}
+readHookInput(decide);

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {
@@ -26,7 +26,7 @@
     "test:collision": "node ci/description-collision.js",
     "test:routing:skills": "node ci/skill-routing-check.js",
     "test:routing": "node ci/routing-check.js",
-    "test:routing:invariants": "node ci/invariant-routing.test.js && node ci/router-workflow-plan.test.js",
+    "test:routing:invariants": "node ci/invariant-routing.test.js && node ci/router-workflow-plan.test.js && node ci/workflow-execution-contract.test.js",
     "plugin:sync": "node scripts/sync-openai-plugin.js",
     "test:plugin:claude": "node ci/mechanism-2z-claude-plugin-manifest.test.js",
     "plugin:claude:stage": "node scripts/stage-claude-plugin.js",

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/hooks/hooks.json

@@ -24,13 +24,25 @@
             "command": "node \"${PLUGIN_ROOT}/skills/harness-everything/scripts/kernel-router.js\"",
             "commandWindows": "node \"${PLUGIN_ROOT}\\skills\\harness-everything\\scripts\\kernel-router.js\"",
             "timeout": 30,
-            "statusMessage": "Routing with Harness invariants",
+            "statusMessage": "Routing with Harness workflow contract",
             "additionalContextLimit": 2500
           }
         ]
       }
     ],
     "PreToolUse": [
+      {
+        "matcher": "Bash|apply_patch",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/workflow-gate.js\"",
+            "commandWindows": "node \"${PLUGIN_ROOT}\\hooks\\scripts\\workflow-gate.js\"",
+            "timeout": 15,
+            "statusMessage": "Checking Harness workflow and worktree-isolation contract"
+          }
+        ]
+      },
       {
         "matcher": "Bash|apply_patch",
         "hooks": [
@@ -183,6 +195,13 @@
             "timeout": 15,
             "statusMessage": "Closing unresolved Harness action approvals"
           },
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/workflow-stop-gate.js\"",
+            "commandWindows": "node \"${PLUGIN_ROOT}\\hooks\\scripts\\workflow-stop-gate.js\"",
+            "timeout": 15,
+            "statusMessage": "Checking Harness workflow completion gate"
+          },
           {
             "type": "command",
             "command": "node \"${PLUGIN_ROOT}/hooks/scripts/stop-gate.js\"",

package/plugins/harness-everything/hooks/scripts/contract-test.js

@@ -20,7 +20,9 @@ const {
   chooseCorrelatedContract,
   commandMatches,
   listRunContracts,
+  getWorkerId,
 } = require('./lib/fable-contracts');
+const { loadWorkflow, matchingRun } = require('./lib/workflow-runtime');
 
 function resultState(payload) {
   const toolResponse = payload.tool_response || payload.tool_result || {};
@@ -41,6 +43,7 @@ function updateRunContract(entry, payload, command, sessionId) {
   const observedAt = new Date().toISOString();
   const contract = {
     ...entry.contract,
+    workerId: entry.contract.workerId || getWorkerId(payload),
     status: failed ? 'fail' : 'pass',
     lastObservedCommand: command,
     lastObservedExitCode: exitCode ?? null,
@@ -103,8 +106,11 @@ process.stdin.on('end', () => {
     const root = getWorkspaceRoot(payload);
     const stateRoot = getStateRoot(root, payload);
     const sessionId = getSessionId(payload);
+    const workflowContext = loadWorkflow(payload);
+    const activeRun = workflowContext.workflow?.workflowId ? matchingRun(workflowContext) : null;
     const runMatches = listRunContracts(stateRoot).filter(({ contract }) =>
-      ['pending', 'planned', 'running'].includes(contract.status) && commandMatches(contract, command)
+      (contract.workflowId ? ['pending', 'planned', 'running', 'fail', 'pass'] : ['pending', 'planned', 'running']).includes(contract.status) && commandMatches(contract, command) &&
+      (!workflowContext.workflow?.workflowId || (activeRun && contract.runId === activeRun.run.runId && contract.sessionId === sessionId))
     );
 
     if (runMatches.length > 0) {
@@ -115,7 +121,23 @@ process.stdin.on('end', () => {
         process.exit(2);
       }
 
-      const contract = updateRunContract(resolution.match, payload, command, sessionId);
+      const entry = resolution.match;
+      if (entry.contract.workflowId) {
+        const worker = getWorkerId(payload);
+        if (!worker || (entry.contract.workerId && worker !== entry.contract.workerId)) {
+          console.error('[Contract Test] Active workflow check lacks a matching observed worker identity.');
+          process.exit(2);
+        }
+        for (const id of entry.contract.dependsOn || []) {
+          const dependency = JSON.parse(fs.readFileSync(path.join(entry.runRoot, 'contracts', `${id}.json`), 'utf8'));
+          const escaped = workflowContext.workflow.escapes?.some(item => item.stageId === id && item.runId === entry.contract.runId);
+          if (dependency.status !== 'pass' && !escaped) {
+            console.error('[Contract Test] Dependency has not passed: ' + id);
+            process.exit(2);
+          }
+        }
+      }
+      const contract = updateRunContract(entry, payload, command, sessionId);
       console.log(`[Contract Test] ${contract.planId}/${contract.runId}/${contract.stageId}: ${contract.status.toUpperCase()} ${contract.checkCommand}`);
       if (contract.status === 'fail') {
         console.error(`Evidence: ${contract.evidence || '(no output captured)'}`);