harness-everything 0.7.0 → 0.8.1

package/ci/mechanism-2af-worktree-isolation.test.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const GATE = path.join(ROOT, 'hooks', 'scripts', 'workflow-gate.js');
+let failed = 0;
+
+function check(condition, message) {
+  if (condition) console.log(`✅ worktree-isolation: ${message}`);
+  else { console.error(`❌ worktree-isolation: ${message}`); failed++; }
+}
+
+function git(cwd, args) {
+  return spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true });
+}
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-worktree-isolation-'));
+const home = path.join(temp, 'home');
+const repo = path.join(temp, 'repo');
+const linked = path.join(temp, 'repo-linked');
+fs.mkdirSync(home, { recursive: true });
+fs.mkdirSync(repo, { recursive: true });
+
+const env = {
+  ...process.env,
+  HOME: home,
+  USERPROFILE: home,
+  HARNESS_STATE_HOME: path.join(home, '.agents', 'harness-everything'),
+  CLAUDE: '1',
+};
+process.env.HARNESS_STATE_HOME = env.HARNESS_STATE_HOME;
+process.env.HOME = home;
+process.env.USERPROFILE = home;
+
+try {
+  if (process.platform === 'win32') {
+    const { key } = require('../hooks/scripts/lib/workflow-isolation');
+    const shortProgramFiles = path.join(process.env.SystemDrive || 'C:', 'PROGRA~1');
+    if (fs.existsSync(shortProgramFiles)) {
+      check(key(shortProgramFiles) === key(fs.realpathSync.native(shortProgramFiles)), 'Windows short and long path spellings identify the same physical directory');
+    }
+  }
+  check(git(repo, ['init']).status === 0, 'fixture git repository initializes');
+  fs.writeFileSync(path.join(repo, 'README.md'), 'fixture\n', 'utf8');
+  check(git(repo, ['add', 'README.md']).status === 0, 'fixture file stages');
+  check(git(repo, ['-c', 'user.name=Harness Test', '-c', 'user.email=harness@example.invalid', 'commit', '-m', 'fixture']).status === 0, 'fixture baseline commits');
+
+  const workspace = require(path.join(ROOT, 'scripts', 'lib', 'workspace'));
+  const state = require(path.join(ROOT, 'hooks', 'scripts', 'lib', 'harness-state'));
+  const sessionId = 'worktree-isolation-test';
+  const context = { session_id: sessionId, host_id: 'mechanism-test', cwd: repo };
+  workspace.bindWorkspaceSession(sessionId, repo, context, true);
+  const sessionDir = state.getSessionDir(repo, sessionId, context);
+  const workflowFile = path.join(sessionDir, 'workflow-run.json');
+
+  function writeWorkflow(tier, strategy) {
+    fs.writeFileSync(workflowFile, `${JSON.stringify({
+      schemaVersion: 1,
+      createdAt: new Date().toISOString(),
+      createdAtMs: Date.now(),
+      sessionId,
+      tier,
+      strategy,
+      state: 'active',
+    }, null, 2)}\n`, 'utf8');
+  }
+
+  function runGate(tool, cwd, input = {}) {
+    const payload = {
+      session_id: sessionId,
+      host_id: 'mechanism-test',
+      cwd,
+      tool_name: tool,
+      tool_input: input,
+    };
+    return spawnSync(process.execPath, [GATE], {
+      cwd: ROOT,
+      env,
+      input: JSON.stringify(payload),
+      encoding: 'utf8',
+    });
+  }
+
+  // Tier 3 isolation is independent of the selected execution topology.
+  writeWorkflow('tier3', 'iterative-single');
+
+  const primaryWrite = runGate('Write', repo, { file_path: path.join(repo, 'src.js'), content: 'x' });
+  check(primaryWrite.status === 2, 'Tier 3 direct write is blocked in the primary working tree');
+  check(/worktree isolation/i.test(primaryWrite.stderr), 'blocked write explains the isolation requirement');
+
+  const primaryDelete = runGate('Bash', repo, { command: 'rm -rf src' });
+  check(primaryDelete.status === 2, 'Tier 3 destructive shell mutation is blocked in the primary working tree');
+
+  for (const command of ['git status > tracked.txt', 'git log --output=tracked.txt', 'find . -delete', 'fd -x rm', 'rg --pre touch x', 'git show $(touch tracked.txt)', 'Get-Content (Remove-Item src)']) {
+    check(runGate('Bash', repo, { command }).status === 2, `shell side effect is not read-only: ${command}`);
+  }
+
+  const chainedBypass = runGate('Bash', repo, { command: 'git status --short && rm -rf src' });
+  check(chainedBypass.status === 2, 'read-only prefix cannot hide a chained mutation');
+
+  const readOnly = runGate('Bash', repo, { command: 'git status --short' });
+  check(readOnly.status === 0, 'read-only discovery remains allowed before isolation');
+
+  const setup = runGate('Bash', repo, { command: `git worktree add "${linked}" -b harness-isolation-test` });
+  check(setup.status === 0, 'git worktree creation is allowed as the isolation transition');
+
+  const createLinked = git(repo, ['worktree', 'add', linked, '-b', 'harness-isolation-test']);
+  check(createLinked.status === 0, 'fixture linked worktree is created');
+
+  const isolatedWrite = runGate('Write', linked, { file_path: path.join(linked, 'src.js'), content: 'x' });
+  check(isolatedWrite.status === 0, `Tier 3 mutation is allowed after entering a linked worktree (${isolatedWrite.stderr.trim() || 'allowed'})`);
+
+  check(runGate('Write', linked, { file_path: path.join(repo, 'src.js') }).status === 2, 'linked cwd cannot authorize a primary-tree target');
+  check(runGate('Write', linked, { file_path: '../repo/src.js' }).status === 2, 'relative traversal cannot escape the worktree');
+  check(runGate('apply_patch', linked, `*** Begin Patch\n*** Add File: ${path.join(repo, 'src.js')}\n+x\n*** End Patch`).status === 2, 'raw patch targets are checked');
+  check(runGate('apply_patch', linked, { patch: `*** Begin Patch\n*** Update File: README.md\n*** Move to: ${path.join(repo, 'moved.md')}\n@@\n-fixture\n+x\n*** End Patch` }).status === 2, 'patch move destination cannot escape isolation');
+  check(runGate('exec_command', repo, { cmd: 'rm -rf src', workdir: repo }).status === 2, 'native shell alias cannot skip mutation gating');
+  check(runGate('Bash', linked, { command: `rm "${path.join(repo, 'README.md')}"` }).status === 2, 'explicit primary-tree shell target is blocked');
+  check(runGate('Bash', linked, { command: 'cd ../repo && node build.js' }).status === 2, 'shell directory change cannot hide the effective working directory');
+  check(runGate('Write', linked, {}).status === 2, 'unknown direct target is blocked');
+  const junction = path.join(linked, 'outside');
+  fs.symlinkSync(repo, junction, process.platform === 'win32' ? 'junction' : 'dir');
+  check(runGate('Write', linked, { file_path: path.join(junction, 'src.js') }).status === 2, 'symlink or junction escape is blocked');
+  fs.unlinkSync(junction);
+
+  const escaped = JSON.parse(fs.readFileSync(workflowFile, 'utf8'));
+  escaped.state = 'escaped';
+  fs.writeFileSync(workflowFile, JSON.stringify(escaped));
+  check(runGate('Write', repo, { file_path: path.join(repo, 'src.js') }).status === 2, 'legacy escaped state never waives isolation');
+  escaped.state = 'blocked';
+  fs.writeFileSync(workflowFile, JSON.stringify(escaped));
+  check(runGate('Write', linked, { file_path: path.join(linked, 'src.js') }).status === 2, 'blocked workflow cannot mutate even inside isolation');
+  fs.writeFileSync(workflowFile, '{broken');
+  check(runGate('Write', linked, { file_path: path.join(linked, 'src.js') }).status === 2, 'corrupt recorded workflow cannot silently authorize mutation');
+
+  writeWorkflow('tier2', 'iterative-single');
+  const tier2Write = runGate('Write', repo, { file_path: path.join(repo, 'small.js'), content: 'x' });
+  check(tier2Write.status === 0, 'Tier 2 is not globally forced into worktree isolation');
+} finally {
+  try { fs.rmSync(temp, { recursive: true, force: true }); } catch (_) { /* best effort */ }
+}
+
+if (failed > 0) {
+  console.error(`FAIL: worktree isolation gate (${failed} failure${failed === 1 ? '' : 's'})`);
+  process.exit(1);
+}
+console.log('PASS: major-workflow worktree isolation gate');

package/ci/mechanism-2ag-router-worktree-contract.test.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const router = require(path.join(ROOT, 'harness-everything', 'scripts', 'router-contract.js'));
+
+const tier3 = router.buildRouterContract({
+  routingStatus: 'ok',
+  recommendedTier: 'Tier 3',
+  rationale: 'major architecture change',
+  signals: { macroScope: true, dependentStages: true },
+}).workflowPlan;
+
+assert.strictEqual(tier3.strategy, 'fable-staged');
+assert.ok(tier3.requiredInvariants.includes('isolated-worktree-before-mutation'), 'Tier 3 plan must carry mutation isolation invariant');
+assert.ok(tier3.suggestedSkills.includes('using-git-worktrees'), 'Tier 3 plan must surface the worktree workflow');
+assert.strictEqual(tier3.workspace.required, false, 'Git worktree isolation must remain distinct from durable multi-agent workspace state');
+
+const tier2 = router.buildRouterContract({
+  routingStatus: 'ok',
+  recommendedTier: 'Tier 2',
+  rationale: 'bounded bug fix',
+  signals: { tier2Keyword: true },
+}).workflowPlan;
+
+assert.strictEqual(tier2.strategy, 'iterative-single');
+assert.ok(!tier2.requiredInvariants.includes('isolated-worktree-before-mutation'), 'Tier 2 must not be globally forced into major-workflow isolation');
+assert.ok(!tier2.suggestedSkills.includes('using-git-worktrees'), 'Tier 2 keeps worktree use task-dependent');
+
+const explicitFable = router.buildWorkflowPlan({
+  routingStatus: 'ok',
+  tier: 'tier3',
+  taskShape: router.buildTaskShape({
+    tier: 'tier3',
+    signals: { macroScope: true, dependentStages: true },
+    explicitRequest: { strategy: 'fable-staged' },
+  }),
+});
+assert.ok(explicitFable.requiredInvariants.includes('isolated-worktree-before-mutation'), 'direct buildWorkflowPlan callers receive the same isolation contract');
+
+console.log('PASS: router major-workflow plan carries worktree isolation independently of multi-agent workspace state.');

package/ci/mechanism-2ah-workflow-lifecycle.test.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const ROOT = path.resolve(__dirname, '..');
+const plugin = process.argv.includes('--plugin');
+const runtimeRoot = plugin ? path.join(ROOT, 'plugins/harness-everything') : ROOT;
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-workflow-lifecycle-'));
+const repo = path.join(temp, 'repo');
+const linked = path.join(temp, 'linked');
+fs.mkdirSync(repo);
+const env = { ...process.env, HARNESS_STATE_HOME: path.join(temp, 'state'), HARNESS_WORKSPACE_ROOT: repo };
+process.env.HARNESS_STATE_HOME = env.HARNESS_STATE_HOME;
+const state = require(path.join(runtimeRoot, 'hooks/scripts/lib/harness-state'));
+const sessionId = 'workflow-lifecycle';
+const payload = { session_id: sessionId, cwd: repo };
+const sessionDir = state.getSessionDir(repo, sessionId);
+const file = path.join(sessionDir, 'workflow-run.json');
+const read = target => JSON.parse(fs.readFileSync(target, 'utf8'));
+const write = (target, value) => fs.writeFileSync(target, JSON.stringify(value));
+let passed = 0;
+function check(value, message) { assert.ok(value, message); passed++; console.log('PASS ' + message); }
+function node(script, input, args = []) {
+  const relative = plugin && script.startsWith('harness-everything/') ? 'skills/' + script : script;
+  return spawnSync(process.execPath, [path.join(runtimeRoot, relative), ...args], { cwd: repo, env, input: input && JSON.stringify(input), encoding: 'utf8' });
+}
+function git(args) {
+  const result = spawnSync('git', args, { cwd: repo, encoding: 'utf8' });
+  assert.strictEqual(result.status, 0, result.stderr);
+}
+const route = prompt => node('harness-everything/scripts/kernel-router.js', { ...payload, prompt });
+const gate = (tool, input, cwd = linked) => node('hooks/scripts/workflow-gate.js', { ...payload, cwd, tool_name: tool, tool_input: input });
+const stop = extra => node('hooks/scripts/workflow-stop-gate.js', { ...payload, ...extra });
+const control = (...args) => node('hooks/scripts/workflow-disposition.js', null, [args[0], '--session-id', sessionId, ...args.slice(1)]);
+const stages = [
+  { stageId: 'build', goal: 'fix', agent: 'fable-worker', task: 'fix bounded module', dependsOn: [], writeSet: ['src'], checkCommand: 'node test-build.js', passCondition: 'exit 0' },
+  { stageId: 'optional', goal: 'external scope', agent: 'fable-worker', task: 'external task', dependsOn: [], writeSet: [], checkCommand: 'node external.js', passCondition: 'exit 0' },
+  { stageId: 'verify', goal: 'verify', agent: 'fable-verifier', task: 'independent review', dependsOn: ['build', 'optional'], writeSet: [], checkCommand: 'node verify.js', passCondition: 'exit 0' },
+];
+
+try {
+  git(['init']); fs.writeFileSync(path.join(repo, 'README.md'), 'fixture\n'); git(['add', '.']);
+  git(['-c', 'user.name=Harness Test', '-c', 'user.email=harness@example.invalid', 'commit', '-m', 'fixture']);
+  git(['worktree', 'add', linked, '-b', 'isolated']);
+  const routed = route('Refactor the entire repository architecture in dependent stages.');
+  check(routed.status === 0, 'prompt hook creates workflow');
+  const initial = read(file);
+  check(initial.state === 'pending' && initial.workflowId && initial.strategy === 'fable-staged', 'selected route is pending with identity');
+  check(initial.requiredInvariants.includes('stage-contracts') && initial.requiredInvariants.includes('isolated-worktree-before-mutation'), 'persisted contract retains full invariant set');
+  check(!fs.readFileSync(file, 'utf8').includes('Refactor the entire'), 'state stores prompt hash without prompt text');
+  check(gate('Write', { file_path: path.join(linked, 'src.js') }).status === 2, 'Fable entry is required even inside worktree');
+  check(stop().status === 2, 'cannot stop before entry');
+  check(route('continue').status === 0 && read(file).workflowId === initial.workflowId, 'continuation does not erase active obligation');
+  check(route('Update one README typo').status === 0 && read(file).strategy === 'fable-staged', 'simple prompt cannot downgrade unresolved workflow');
+  const spec = path.join(sessionDir, 'workflow-stages.json');
+  check(gate('Write', { file_path: spec }, repo).status === 0, 'bounded stage specification can be bootstrapped without source mutation');
+  fs.linkSync(path.join(repo, 'README.md'), spec);
+  check(gate('Write', { file_path: spec }, repo).status === 2, 'bootstrap file cannot alias a primary-tree artifact');
+  fs.unlinkSync(spec);
+  check(gate('Write', { file_path: file }, repo).status === 2, 'bootstrap exception excludes active workflow state');
+  write(spec, stages);
+  const command = `node "${path.join(runtimeRoot, 'hooks/scripts/workflow-disposition.js')}" start --session-id ${sessionId}`;
+  check(gate('Bash', { command }, repo).status === 0, 'trusted controller can start from bound primary root');
+  check(gate('Bash', { command: command + ' && rm src.js' }, repo).status === 2, 'controller prefix cannot hide shell execution');
+  const started = control('start');
+  check(started.status === 0, 'controller starts a real Fable run: ' + started.stderr);
+  const active = read(file);
+  const runRoot = path.join(state.getStateRoot(repo), 'fable-runs', active.runId);
+  const runFile = path.join(runRoot, 'run.json');
+  const manifest = read(runFile);
+  check(manifest.workflowId === active.workflowId && manifest.sessionId === sessionId, 'run is explicitly bound to workflow and session');
+  const allowedMutation = gate('Write', { file_path: path.join(linked, 'src.js') });
+  check(allowedMutation.status === 0, 'entered workflow allows isolated artifact mutation: ' + allowedMutation.stderr);
+  for (const invalid of [{ sessionId: null }, { workflowId: 'unrelated' }, { createdAt: 'invalid' }]) {
+    write(runFile, { ...manifest, ...invalid });
+    check(stop().status === 2, 'uncorrelated run cannot satisfy completion: ' + JSON.stringify(invalid));
+  }
+  write(runFile, manifest);
+  check(control('escape', '--reason-code', 'routine', '--scope', 'task', '--evidence', 'easy').status === 2, 'confidence escape rejected');
+  check(control('escape', '--reason-code', 'workflow-uncovered-scope', '--scope', 'task', '--evidence', 'uncovered').status === 2, 'unscoped whole-workflow escape rejected');
+  check(control('escape', '--stage-id', 'optional', '--reason-code', 'workflow-uncovered-scope', '--scope', 'external observation', '--evidence', 'fixture external host unavailable').status === 0, 'scoped evidence-backed exception is recorded');
+  check(read(file).state === 'running' && stop().status === 2, 'escape leaves covered obligations unresolved');
+  check(gate('Write', { file_path: path.join(repo, 'src.js') }, repo).status === 2, 'actual escape command cannot waive isolation');
+  check(control('escape', '--stage-id', 'verify', '--reason-code', 'host-capability-unavailable', '--scope', 'verifier', '--evidence', 'missing host').status === 2, 'required verifier cannot be escaped');
+  function observe(stage, worker, exitCode) {
+    return node('hooks/scripts/contract-test.js', { ...payload, worker_id: worker, tool_name: 'Bash', tool_input: { command: stages.find(item => item.stageId === stage).checkCommand }, tool_response: { exitCode, stdout: 'fixture evidence' } });
+  }
+  check(observe('verify', 'reviewer', 0).status === 2, 'verifier cannot pass ahead of its dependency');
+  check(observe('build', 'builder', 1).status === 2 && stop().status === 2, 'failed objective check prevents completion');
+  check(observe('build', 'builder', 0).status === 0, 'failed stage may recover with observed passing evidence');
+  check(observe('verify', 'reviewer', 0).status === 0, 'independent verifier evidence is observed');
+  const buildFile = path.join(runRoot, 'contracts/build.json');
+  const savedBuild = read(buildFile);
+  fs.unlinkSync(buildFile);
+  check(stop().status === 2, 'deleted contract cannot make remaining directory entries look complete');
+  write(buildFile, savedBuild);
+  const evidenceFile = path.join(runRoot, 'evidence/build.json');
+  const savedEvidence = read(evidenceFile);
+  write(evidenceFile, { ...savedEvidence, exitCode: null });
+  check(stop().status === 2, 'status pass without observed exit zero is insufficient');
+  write(evidenceFile, savedEvidence);
+  const mutationState = read(file);
+  write(file, { ...mutationState, lastMutationAt: Date.now() + 10000 });
+  check(stop().status === 2, 'verification predating a new mutation is stale');
+  write(file, mutationState);
+  check(stop().status === 0 && read(file).state === 'satisfied', 'all covered stages and verifier resolve workflow to satisfied');
+  check(route('Refactor the entire repository architecture in dependent stages.').status === 0 && read(file).workflowId !== initial.workflowId, 'next completed-task boundary creates a fresh workflow');
+  check(stop({ stop_hook_active: true }).status === 0 && read(file).state === 'blocked', 'Stop retry reports blocked instead of faking completion');
+  check(gate('Write', { file_path: path.join(linked, 'src.js') }).status === 2, 'blocked state still prohibits mutation');
+  for (let i = 0; i < 3; i++) { check(control('start').status === 0, 'bounded replan attempt ' + i); control('block', '--evidence', 'fixture blocker'); }
+  check(control('start').status === 2 && read(file).state === 'blocked', 'exhausted replan budget remains blocked');
+  fs.writeFileSync(file, '{broken');
+  check(route('continue').status === 2 && fs.readFileSync(file, 'utf8') === '{broken', 'router cannot overwrite unreadable unresolved state');
+  check(stop().status === 2, 'malformed state cannot silently pass completion');
+  write(file, { state: 'active' });
+  check(gate('Write', { file_path: path.join(linked, 'src.js') }).status === 2 && stop().status === 2, 'partial JSON state cannot bypass workflow gates');
+  fs.unlinkSync(file);
+  check(route('Fix this checkout bug with a regression test').status === 0 && read(file).strategy === 'iterative-single', 'bounded fix selects iterative lifecycle');
+  check(gate('Write', { file_path: path.join(repo, 'small.js') }, repo).status === 0, 'ordinary iterative mutation does not require isolation');
+  check(stop().status === 2, 'direct/iterative route cannot complete unverified mutation');
+  check(stop({ stop_hook_active: true }).status === 0 && read(file).state === 'blocked', 'iterative retry reports incomplete state');
+  check(control('start').status === 0, 'blocked iterative route can resume without a Fable stage map');
+  node('hooks/scripts/state-persist.js', { ...payload, tool_name: 'Bash', tool_input: { command: 'npm test' }, tool_response: { stdout: 'no code' } });
+  check(stop().status === 2, 'verification without numeric exit status is unknown');
+  node('hooks/scripts/state-persist.js', { ...payload, tool_name: 'Bash', tool_input: { command: 'npm test' }, tool_response: { exitCode: 0, stdout: 'passed' } });
+  check(stop().status === 0 && read(file).state === 'satisfied', 'observed iterative verification resolves completion');
+  console.log(`PASS: workflow lifecycle (${passed} assertions)`);
+} finally {
+  if (!temp.startsWith(path.join(os.tmpdir(), 'harness-workflow-lifecycle-'))) throw new Error('unsafe fixture cleanup');
+  fs.rmSync(temp, { recursive: true, force: true });
+}
+if (!plugin) {
+  const packaged = spawnSync(process.execPath, [__filename, '--plugin'], { cwd: ROOT, env: process.env, encoding: 'utf8' });
+  assert.strictEqual(packaged.status, 0, packaged.stdout + packaged.stderr);
+  console.log('PASS: packaged OpenAI workflow lifecycle mirrors source (' + passed + ' assertions)');
+}

package/ci/openai-plugin-package.test.js

@@ -14,9 +14,6 @@ const PORTABLE_MANIFEST = JSON.parse(fs.readFileSync(path.join(PLUGIN, 'plugin.j
 
 function sha256(file) {
   const bytes = fs.readFileSync(file);
-  // Git stores text blobs with LF, while a Windows checkout may materialize
-  // canonical files with CRLF. Package parity compares canonical content, not
-  // platform checkout EOL bytes.
   const normalized = bytes.includes(0)
     ? bytes
     : Buffer.from(bytes.toString('utf8').replace(/\r\n/g, '\n'), 'utf8');
@@ -138,6 +135,8 @@ assert.ok(hooks.hooks.Stop?.length, 'Stop hook missing');
 const hookText = JSON.stringify(hooks);
 assert.match(hookText, /PLUGIN_ROOT/, 'plugin hooks must resolve from PLUGIN_ROOT');
 assert.match(hookText, /commandWindows/, 'plugin hooks need a Windows command override');
+assert.match(hookText, /workflow-gate\.js/, 'plugin hooks must package workflow bypass enforcement');
+assert.match(hookText, /workflow-stop-gate\.js/, 'plugin hooks must package workflow completion enforcement');
 
 const session = spawnSync(process.execPath, [path.join(PLUGIN, 'hooks', 'session-start.js')], { encoding: 'utf8' });
 assert.strictEqual(session.status, 0, session.stderr);
@@ -164,14 +163,22 @@ assert.strictEqual(second.status, 0, second.stderr);
 assert.strictEqual(first.stdout, second.stdout, 'identical routing input must produce identical output');
 assert.match(first.stdout, /RECOMMENDED TIER:\s*Tier 2/i);
 assert.match(first.stdout, /REQUIRED HARNESS INVARIANTS/);
-assert.match(first.stdout, /SUGGESTED SKILLS \(ADVISORY/);
+assert.match(first.stdout, /WORKFLOW SKILLS \(EVALUATE APPLICABILITY .*SELECTED WORKFLOW IS MANDATORY\)/);
+assert.match(first.stdout, /evaluate-suggestions-before-skip/);
+assert.match(first.stdout, /read its complete SKILL\.md entry/);
 assert.doesNotMatch(first.stdout, /BASE EXECUTION LOOP/);
-assert.match(first.stdout, /Do not enforce workflow order/);
+assert.match(first.stdout, /ORCHESTRATION POLICY: Mandatory applicable workflow/);
+assert.match(first.stdout, /WORKFLOW EXECUTION CONTRACT \(MANDATORY WHEN SELECTED\)/);
+assert.match(first.stdout, /Selected workflow: iterative-single/);
+assert.match(first.stdout, /Completion requires the workflow obligations and objective verification/);
+assert.doesNotMatch(first.stdout, /execution remains advisory after evaluation/);
 
 const trivial = route('Update one README typo');
 assert.strictEqual(trivial.status, 0, trivial.stderr);
 assert.match(trivial.stdout, /RECOMMENDED TIER:\s*Tier 1/i);
-assert.match(trivial.stdout, /No mandatory domain skill/);
+assert.match(trivial.stdout, /Suggested skills: none/);
+assert.match(trivial.stdout, /No domain skill was suggested/);
+assert.doesNotMatch(trivial.stdout, /evaluate-suggestions-before-skip/);
 
 const unmatched = route('frobnicate the quux');
 assert.strictEqual(unmatched.status, 0, unmatched.stderr);
@@ -179,4 +186,4 @@ assert.match(unmatched.stdout, /RECOMMENDED TIER:\s*Unclassified/i);
 assert.match(unmatched.stdout, /"tier":"unclassified"/i);
 assert.doesNotMatch(unmatched.stdout, /RECOMMENDED TIER:\s*Tier 1/i);
 
-console.log(`OpenAI plugin package verified: ${skillNames.length} skills, publication metadata, hooks, marketplace, deterministic routing.`);
+console.log(`OpenAI plugin package verified: ${skillNames.length} skills, publication metadata, hooks, marketplace, deterministic mandatory-workflow routing.`);

package/ci/workflow-execution-contract.test.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+let failed = 0;
+
+function check(condition, message) {
+  if (condition) console.log(`  PASS ${message}`);
+  else { console.error(`  FAIL ${message}`); failed++; }
+}
+
+function runNode(args, options = {}) {
+  return spawnSync(process.execPath, args, { cwd: ROOT, encoding: 'utf8', ...options });
+}
+
+console.log('=== Workflow Execution Enforcement ===');
+
+for (const rel of [
+  'harness-everything/scripts/kernel-router.js',
+  'harness-everything/scripts/kernel-router-core.js',
+  'hooks/scripts/workflow-gate.js',
+  'hooks/scripts/workflow-stop-gate.js',
+  'hooks/scripts/workflow-disposition.js',
+]) {
+  const result = runNode(['--check', path.join(ROOT, rel)]);
+  check(result.status === 0, `${rel} parses as valid JavaScript`);
+}
+
+const routed = runNode([
+  path.join(ROOT, 'harness-everything/scripts/kernel-router.js'),
+  'audit the entire repository architecture and coordinate multiple modules',
+]);
+check(routed.status === 0, 'enforced kernel route exits successfully');
+check(routed.stdout.includes('"strategy":"fable-staged"'), 'macro prompt selects fable-staged');
+check(routed.stdout.includes('WORKFLOW EXECUTION CONTRACT (MANDATORY WHEN SELECTED)'), 'wrapper emits mandatory execution contract');
+check(routed.stdout.includes('Execute the selected workflow to resolution'), 'wrapper requires workflow resolution');
+check(routed.stdout.includes('workflow-uncovered-scope'), 'wrapper exposes only explicit evidence-backed escape path');
+check(!routed.stdout.includes('execution remains advisory after evaluation'), 'wrapper removes advisory-execution runtime wording');
+
+const disposition = fs.readFileSync(path.join(ROOT, 'hooks/scripts/workflow-disposition.js'), 'utf8');
+check(disposition.includes("'workflow-uncovered-scope'"), 'escape supports workflow-uncovered-scope');
+check(disposition.includes("'host-capability-unavailable'"), 'escape supports host-capability-unavailable');
+check(disposition.includes('generic simple/routine/already-clear reasons are intentionally rejected'), 'generic confidence-based escape reasons are rejected');
+check(disposition.includes('--scope is required') && disposition.includes('--evidence is required') && disposition.includes('--stage-id must name'), 'escape requires a declared stage, scope and evidence');
+
+const hooks = JSON.parse(fs.readFileSync(path.join(ROOT, 'hooks/hooks.json'), 'utf8'));
+check((hooks.hooks.PreToolUse || []).some(entry => entry.id === 'harness:pre:workflow-gate'), 'Claude hook wiring includes pre-mutation workflow gate');
+check((hooks.hooks.Stop || []).some(entry => entry.id === 'harness:stop:workflow-completion-gate'), 'Claude hook wiring includes workflow completion gate');
+
+const pluginHooks = JSON.parse(fs.readFileSync(path.join(ROOT, 'plugins/harness-everything/hooks/hooks.json'), 'utf8'));
+check((pluginHooks.hooks.PreToolUse || []).some(entry => (entry.hooks || []).some(hook => /workflow-gate\.js/.test(hook.command || ''))), 'OpenAI plugin hook package carries workflow gate adapter');
+check((pluginHooks.hooks.Stop || []).some(entry => (entry.hooks || []).some(hook => /workflow-stop-gate\.js/.test(hook.command || ''))), 'OpenAI plugin hook package carries workflow completion adapter');
+
+console.log(`\n${failed === 0 ? 'PASS' : 'FAIL'}: workflow execution enforcement (${failed} failure${failed === 1 ? '' : 's'})`);
+process.exit(failed === 0 ? 0 : 1);