harness-everything 0.16.5 → 0.17.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.16.5",
+      "version": "0.17.0",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.16.5",
+  "version": "0.17.0",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.17.0](https://github.com/dyphn1/Harness-everything/compare/v0.16.6...v0.17.0) (2026-09-21)
+
+### Features
+
+* **router:** expose obligation resolution contract ([767f8ef](https://github.com/dyphn1/Harness-everything/commit/767f8ef20b97fe8da2dcbe11a49f00fd03d0976b))
+* **router:** retain task shape for post-decomposition composition ([cff0e48](https://github.com/dyphn1/Harness-everything/commit/cff0e489cdb5cd8a80b48370ab9905e508eac4e7))
+* **router:** surface requirements-first planning ([3ad82ae](https://github.com/dyphn1/Harness-everything/commit/3ad82aedbae7943b66cf686b05a685d247f8c0b0))
+* **workflow:** add non-Fable obligation contract ([d31bb0e](https://github.com/dyphn1/Harness-everything/commit/d31bb0e3b997a597692ae0af8741d5963bddc3aa))
+* **workflow:** add planning transition ([5f5855b](https://github.com/dyphn1/Harness-everything/commit/5f5855bb2219efcc6a0964319324e7d8215a775d))
+* **workflow:** confirm recomposed post-decomposition plan ([a5b2698](https://github.com/dyphn1/Harness-everything/commit/a5b26989da664c8f9e4c276210ba23fc67e2aeda))
+* **workflow:** decompose intent before start ([d1aba6d](https://github.com/dyphn1/Harness-everything/commit/d1aba6d01a2e3e260fc79b996b7e754fa3cd53e8))
+* **workflow:** expose obligation controller command ([4235144](https://github.com/dyphn1/Harness-everything/commit/42351443f315c130b302e120f382929f84cf5896))
+* **workflow:** keep unresolved obligations visible ([926dc2b](https://github.com/dyphn1/Harness-everything/commit/926dc2bb900b5891a3f217989216eeb5fc1917fd))
+* **workflow:** materialize and resolve obligations ([3cc25ad](https://github.com/dyphn1/Harness-everything/commit/3cc25ad18fa6325a6fd93b69749a7dadb605e099))
+* **workflow:** recompose topology after requirement decomposition ([bbb3ed7](https://github.com/dyphn1/Harness-everything/commit/bbb3ed7ca6bf9cfd24b8089428db0eb6b6cd52c0))
+* **workflow:** report unresolved planning obligations ([0c088d7](https://github.com/dyphn1/Harness-everything/commit/0c088d7cc7bf2c75631bf9b9b56dcd8b5851600a))
+
+### Bug Fixes
+
+* **workflow:** keep composition pre-execution ([a22e1de](https://github.com/dyphn1/Harness-everything/commit/a22e1de876bcc6a1bc36a6c679c2dcbcac1ce672))
+* **workflow:** keep recomposed pending execution unresolved ([f29672a](https://github.com/dyphn1/Harness-everything/commit/f29672a55d2b764a8e0dd909cd700af851bda415))
+* **workflow:** preserve decomposition before replan ([8400383](https://github.com/dyphn1/Harness-everything/commit/840038349cb11636152f68be560961f75a9859f2))
+
+## [0.16.6](https://github.com/dyphn1/Harness-everything/compare/v0.16.5...v0.16.6) (2026-09-21)
+
+### Bug Fixes
+
+* **environment-detection:** keep discovery read-only ([#214](https://github.com/dyphn1/Harness-everything/issues/214)) ([f6fa7ec](https://github.com/dyphn1/Harness-everything/commit/f6fa7ec57fb95072dce1177ee4e93718b77b21ef))
+
 ## [0.16.5](https://github.com/dyphn1/Harness-everything/compare/v0.16.4...v0.16.5) (2026-09-21)
 
 ### Bug Fixes

package/ci/mechanism-2ai-workspace-fingerprint-batch.test.js

@@ -188,8 +188,18 @@ try {
     prompt: 'Fix this checkout bug with a regression test',
   });
   check(routed.status === 0, '#169 large-workspace Tier-2 fixture routes normally');
+  const requirements = JSON.stringify([
+    { id: 'req-fingerprint', summary: 'Exercise large-workspace shell admission', acceptance: 'the shell call remains available above the fingerprint observation cap' },
+  ]);
+  const planned = node('hooks/scripts/workflow-disposition.js', undefined, [
+    'plan', '--session-id', sessionId,
+    '--requirements-json', requirements,
+    '--strategy', 'iterative-single',
+    '--evidence', 'single bounded runtime regression uses the iterative workflow',
+  ]);
+  check(planned.status === 0, '#169 large-workspace Tier-2 fixture resolves requirements/workflow planning');
   const started = node('hooks/scripts/workflow-disposition.js', undefined, ['start', '--session-id', sessionId]);
-  check(started.status === 0, '#169 large-workspace Tier-2 fixture starts normally');
+  check(started.status === 0, '#169 large-workspace Tier-2 fixture starts after planning');
 
   const admitted = node('hooks/scripts/workflow-gate.js', {
     ...payload,

package/ci/mechanism-2am-openai-packaged-helper-runtime.test.js

@@ -45,6 +45,34 @@ try {
   });
   assert.strictEqual(selfHeal.status, 0, `packaged self-heal --check failed:\n${describe(selfHeal)}`);
 
+  // Public OpenAI skills-only submissions intentionally omit the plugin-root
+  // installer/runtime. The read-only audit must degrade safely instead of
+  // searching arbitrary parent/cache paths or failing skill execution.
+  const skillsOnlyRoot = path.join(tempRoot, 'skills-only');
+  const skillsOnlyWorkspace = path.join(tempRoot, 'skills-only-workspace');
+  fs.cpSync(path.join(pluginRoot, 'skills'), path.join(skillsOnlyRoot, 'skills'), { recursive: true });
+  fs.mkdirSync(path.join(skillsOnlyWorkspace, '.git'), { recursive: true });
+  fs.writeFileSync(path.join(skillsOnlyWorkspace, 'AGENTS.md'), '# skills-only workspace\n', 'utf8');
+  const skillsOnlyAgentsBefore = fs.readFileSync(path.join(skillsOnlyWorkspace, 'AGENTS.md'), 'utf8');
+  const skillsOnlyCheck = runNode(
+    path.join(skillsOnlyRoot, 'skills', 'harness-everything', 'scripts', 'self-heal.js'),
+    ['--check'],
+    {
+      cwd: skillsOnlyWorkspace,
+      env: {
+        HARNESS_STATE_HOME: path.join(tempRoot, 'skills-only-state'),
+        HARNESS_WORKSPACE_ROOT: skillsOnlyWorkspace,
+      },
+    }
+  );
+  assert.strictEqual(skillsOnlyCheck.status, 0, `skills-only self-heal --check failed:\n${describe(skillsOnlyCheck)}`);
+  assert.match(describe(skillsOnlyCheck), /Local repair runtime unavailable on this distribution surface/);
+  assert.strictEqual(
+    fs.readFileSync(path.join(skillsOnlyWorkspace, 'AGENTS.md'), 'utf8'),
+    skillsOnlyAgentsBefore,
+    'skills-only read-only audit must not rewrite workspace integration files'
+  );
+
   const installer = runNode(path.join(pluginRoot, 'scripts', 'installer.js'), ['--codex', '--no-skills', '--yes'], {
     cwd: workspaceRoot,
     env,

package/ci/mechanism-2an-environment-detection-readonly.test.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const assert = require('assert');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const SELF_HEAL = path.join(ROOT, 'harness-everything', 'scripts', 'self-heal.js');
+const SKILL = path.join(ROOT, 'environment-detection', 'SKILL.md');
+const OPENCODE = path.join(ROOT, 'opencode-plugin', 'index.mjs');
+
+function write(root, relative, content) {
+  const target = path.join(root, relative);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, content, 'utf8');
+  return target;
+}
+
+function treeDigest(root) {
+  const hash = crypto.createHash('sha256');
+  function walk(dir, relative = '') {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const rel = relative ? `${relative}/${entry.name}` : entry.name;
+      const full = path.join(dir, entry.name);
+      hash.update(`${entry.isDirectory() ? 'D' : 'F'}:${rel}\0`);
+      if (entry.isDirectory()) walk(full, rel);
+      else hash.update(fs.readFileSync(full));
+    }
+  }
+  walk(root);
+  return hash.digest('hex');
+}
+
+function run(workspace, home, args) {
+  const env = {
+    ...process.env,
+    HARNESS_WORKSPACE_ROOT: workspace,
+    HARNESS_STATE_HOME: path.join(home, 'state'),
+    HOME: home,
+    USERPROFILE: home,
+    APPDATA: path.join(home, 'AppData', 'Roaming'),
+    VSCODE_USER_PROMPTS_FOLDER: path.join(home, 'vscode-prompts'),
+  };
+  for (const key of ['CLAUDE', 'CLAUDECODE', 'CLAUDE_CODE', 'CURSOR_SANDBOX', 'GITHUB_COPILOT_CHAT', 'COPILOT_AGENT', 'AI_AGENT']) {
+    delete env[key];
+  }
+  return spawnSync(process.execPath, [SELF_HEAL, ...args], {
+    cwd: workspace,
+    env,
+    encoding: 'utf8',
+  });
+}
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-213-readonly-'));
+try {
+  const workspace = path.join(tempRoot, 'workspace');
+  const home = path.join(tempRoot, 'home');
+  fs.mkdirSync(path.join(workspace, '.git'), { recursive: true });
+  fs.mkdirSync(home, { recursive: true });
+
+  // Seed all six installer/self-heal adapter surfaces with user-owned content.
+  write(workspace, '.claude/settings.json', JSON.stringify({ customSetting: true, hooks: {} }, null, 2));
+  write(workspace, '.cursorrules', 'user cursor rule\n');
+  write(workspace, '.github/copilot-instructions.md', 'user copilot instruction\n');
+  write(workspace, 'AGENTS.md', 'user codex instruction\n');
+  write(workspace, '.continue/rules/user.md', '# user continue rule\n');
+  write(workspace, '.hermes.md', 'user hermes context\n');
+
+  const beforeAudit = treeDigest(workspace);
+  const audit = run(workspace, home, ['--check']);
+  assert.strictEqual(audit.status, 0, `read-only audit failed:\n${audit.stdout}\n${audit.stderr}`);
+  assert.strictEqual(treeDigest(workspace), beforeAudit, '--check changed the workspace');
+  for (const label of ['Claude Code hooks', 'Cursor rules', 'Copilot instructions', 'Codex instructions', 'Continue.dev rules', 'Hermes Agent instructions']) {
+    assert.ok(audit.stdout.includes(label), `audit omitted ${label}`);
+  }
+
+  // Explicit repair remains available, preserves user-owned content, and is
+  // idempotent on the second run.
+  const repair = run(workspace, home, []);
+  assert.strictEqual(repair.status, 0, `explicit repair failed:\n${repair.stdout}\n${repair.stderr}`);
+  assert.strictEqual(JSON.parse(fs.readFileSync(path.join(workspace, '.claude/settings.json'), 'utf8')).customSetting, true);
+  assert.match(fs.readFileSync(path.join(workspace, '.cursorrules'), 'utf8'), /user cursor rule/);
+  assert.match(fs.readFileSync(path.join(workspace, '.github', 'copilot-instructions.md'), 'utf8'), /user copilot instruction/);
+  assert.match(fs.readFileSync(path.join(workspace, 'AGENTS.md'), 'utf8'), /user codex instruction/);
+  assert.match(fs.readFileSync(path.join(workspace, '.hermes.md'), 'utf8'), /user hermes context/);
+  assert.strictEqual(fs.readFileSync(path.join(workspace, '.continue', 'rules', 'user.md'), 'utf8'), '# user continue rule\n');
+
+  const afterRepair = treeDigest(workspace);
+  const secondRepair = run(workspace, home, []);
+  assert.strictEqual(secondRepair.status, 0, `second repair failed:\n${secondRepair.stdout}\n${secondRepair.stderr}`);
+  assert.strictEqual(treeDigest(workspace), afterRepair, 'explicit repair is not idempotent');
+
+  // The routed skill contract must keep default detection observational and
+  // use a portable sibling-skill path rather than a repository/cache root.
+  const skill = fs.readFileSync(SKILL, 'utf8');
+  assert.ok(skill.includes('self-heal.js" --check'));
+  assert.doesNotMatch(skill, /<skills-repo-root>/);
+  assert.match(skill, /Only explicit install\/setup\/repair intent may omit/);
+  assert.match(skill, /OpenCode has its own plugin runtime/);
+  assert.match(skill, /skills-only surfaces may lack repair/);
+
+  // OpenCode is a separate runtime surface; its session/plugin startup must
+  // not import or invoke the six-adapter installer/self-heal path implicitly.
+  const opencode = fs.readFileSync(OPENCODE, 'utf8');
+  assert.doesNotMatch(opencode, /self-heal\.js|scripts[\\/]installer\.js/);
+
+  console.log('Issue #213 verified: detection is read-only across six adapters, repair is explicit/idempotent, and OpenCode stays separate.');
+} finally {
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+}

package/ci/mechanism-2an-workflow-obligations.test.js

@@ -0,0 +1,201 @@
+#!/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 stateHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-issue85-obligations-'));
+process.env.HARNESS_STATE_HOME = stateHome;
+process.env.HARNESS_WORKSPACE_ROOT = ROOT;
+
+const { getSessionDir } = require(path.join(ROOT, 'hooks/scripts/lib/harness-state.js'));
+const kernel = path.join(ROOT, 'harness-everything/scripts/kernel-router.js');
+const controller = path.join(ROOT, 'hooks/scripts/workflow-disposition.js');
+const stopGate = path.join(ROOT, 'hooks/scripts/workflow-stop-gate.js');
+const workflowGate = path.join(ROOT, 'hooks/scripts/workflow-gate.js');
+const statePersist = path.join(ROOT, 'hooks/scripts/state-persist.js');
+
+let failed = 0;
+function check(condition, message) {
+  if (condition) console.log('  PASS ' + message);
+  else { console.error('  FAIL ' + message); failed++; }
+}
+function run(script, args = [], input = null) {
+  return spawnSync(process.execPath, [script, ...args], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    input: input === null ? undefined : JSON.stringify(input),
+    env: { ...process.env, HARNESS_STATE_HOME: stateHome, HARNESS_WORKSPACE_ROOT: ROOT },
+  });
+}
+function readJson(file) { return JSON.parse(fs.readFileSync(file, 'utf8')); }
+
+console.log('=== Issue #85 requirements-first workflow contract ===');
+
+const sessionId = 'issue85-tier2';
+const payload = { session_id: sessionId, cwd: ROOT, prompt: 'Fix this checkout bug and add a regression test.' };
+const routed = run(kernel, [], payload);
+check(routed.status === 0, 'Tier 2 route persists successfully');
+
+const sessionDir = getSessionDir(ROOT, sessionId, payload);
+const workflowFile = path.join(sessionDir, 'workflow-run.json');
+const obligationFile = path.join(sessionDir, 'workflow-obligations.json');
+let workflow = readJson(workflowFile);
+let obligations = readJson(obligationFile);
+check(workflow.tier === 'tier2' && workflow.strategy === 'iterative-single', 'Tier 2 receives a preliminary iterative-single route');
+check(workflow.state === 'pending', 'selected Tier 2 workflow begins pending');
+check(obligations.phase === 'planning', 'Tier 2 immediately materializes a planning contract');
+check(obligations.obligations.map(item => item.id).join(',') === 'decompose,compose', 'planning starts with decompose then compose');
+check(obligations.requirements.length === 0, 'requirements begin empty instead of being invented by the router');
+check(obligations.workflowSelection.candidateStrategy === 'iterative-single', 'router topology is recorded only as candidate strategy');
+
+const prematureStart = run(controller, ['start', '--session-id', sessionId]);
+check(prematureStart.status !== 0, 'workflow start refuses to pretend planning is complete');
+workflow = readJson(workflowFile);
+check(workflow.state === 'pending', 'failed start leaves workflow pending');
+
+const mutationReminder = run(workflowGate, [], {
+  session_id: sessionId, cwd: ROOT, hook_event_name: 'PreToolUse',
+  tool_name: 'Write', tool_input: { file_path: path.join(ROOT, 'tmp-issue85.txt'), content: 'x' },
+});
+check(mutationReminder.status === 0, 'unresolved planning does not hard-block ordinary tools');
+
+const beforePlanStop = run(stopGate, [], { session_id: sessionId, cwd: ROOT, hook_event_name: 'Stop' });
+workflow = readJson(workflowFile);
+check(beforePlanStop.status === 0, 'Stop remains fail-open while planning is unresolved');
+check(workflow.state === 'pending', 'unresolved planning cannot silently become satisfied');
+check((workflow.unresolved || []).includes('decompose:pending'), 'decomposition gap is visible');
+check((workflow.unresolved || []).includes('compose:pending'), 'workflow-composition gap is visible');
+
+const requirements = JSON.stringify([
+  { id: 'req-fix', summary: 'Correct the checkout failure', acceptance: 'the failing scenario succeeds', suggestedSkills: ['tdd'] },
+  { id: 'req-regression', summary: 'Protect the behavior with a regression test', acceptance: 'the test fails before the fix and passes after it', suggestedSkills: ['tdd', 'verification-loop'] },
+]);
+const planned = run(controller, [
+  'plan', '--session-id', sessionId,
+  '--requirements-json', requirements,
+  '--strategy', 'iterative-single',
+  '--evidence', 'two dependent requirements fit a bounded single-agent test/fix/verify loop',
+]);
+check(planned.status === 0, 'requirements and workflow selection are recorded before execution');
+obligations = readJson(obligationFile);
+check(obligations.requirements.map(item => item.id).join(',') === 'req-fix,req-regression', 'requirement fragments are machine-readable');
+check(obligations.workflowSelection.disposition === 'confirmed', 'workflow choice is explicitly confirmed after decomposition');
+check(obligations.obligations.find(item => item.id === 'decompose').status === 'pass', 'decompose obligation resolves from requirement fragments');
+check(obligations.obligations.find(item => item.id === 'compose').status === 'pass', 'compose obligation resolves from workflow-selection evidence');
+
+const started = run(controller, ['start', '--session-id', sessionId]);
+check(started.status === 0, 'start activates the confirmed non-Fable workflow');
+workflow = readJson(workflowFile);
+obligations = readJson(obligationFile);
+check(workflow.state === 'running', 'confirmed workflow becomes running');
+check(obligations.phase === 'execution', 'planning contract advances to execution phase');
+check(obligations.obligations.map(item => item.id).join(',') === 'decompose,compose,execute,verify', 'execution adds execute/verify without losing planning evidence');
+
+check(run(controller, ['obligation', '--session-id', sessionId, '--obligation-id', 'execute', '--disposition', 'escaped', '--reason-code', 'workflow-uncovered-scope', '--scope', 'optional unrelated cleanup', '--evidence', 'outside requested bug-fix requirements']).status === 0,
+  'execution obligation accepts bounded evidence-backed escape');
+check(run(controller, ['obligation', '--session-id', sessionId, '--obligation-id', 'verify', '--disposition', 'escaped', '--reason-code', 'workflow-uncovered-scope', '--scope', 'tests', '--evidence', 'attempt']).status !== 0,
+  'verification obligation cannot be escaped');
+check(run(controller, ['obligation', '--session-id', sessionId, '--obligation-id', 'verify', '--disposition', 'blocked', '--reason-code', 'verification-environment-unavailable', '--evidence', 'fixture intentionally blocks verification']).status === 0,
+  'verification obligation can record explicit blocked evidence');
+
+const blockedStop = run(stopGate, [], { session_id: sessionId, cwd: ROOT, hook_event_name: 'Stop' });
+workflow = readJson(workflowFile);
+check(blockedStop.status === 0, 'blocked obligation still reminds without trapping Stop');
+check(workflow.state === 'running', 'blocked obligation keeps workflow unresolved rather than satisfied');
+check((workflow.unresolved || []).includes('verify:blocked'), 'blocked verification remains visible');
+
+check(run(controller, ['obligation', '--session-id', sessionId, '--obligation-id', 'verify', '--disposition', 'pass', '--evidence', 'npm test and focused regression passed']).status === 0,
+  'verification can later resolve to pass with evidence');
+check(run(statePersist, [], {
+  session_id: sessionId, cwd: ROOT, hook_event_name: 'PostToolUse',
+  tool_name: 'Bash', tool_input: { command: 'npm test' },
+  tool_response: { stdout: 'pass', stderr: '', exitCode: 0 },
+}).status === 0, 'objective verification milestone is observed after the earlier mutation');
+const resolvedStop = run(stopGate, [], { session_id: sessionId, cwd: ROOT, hook_event_name: 'Stop' });
+workflow = readJson(workflowFile);
+check(resolvedStop.status === 0, 'resolved workflow Stop remains fail-open');
+check(workflow.state === 'satisfied', 'planning + execution + verification allow satisfied');
+check((workflow.unresolved || []).length === 0, 'satisfied workflow has no unresolved obligations');
+
+const mismatchSession = 'issue85-replan';
+const mismatchPayload = { session_id: mismatchSession, cwd: ROOT, prompt: 'Fix this checkout bug and add a regression test.' };
+check(run(kernel, [], mismatchPayload).status === 0, 'second Tier 2 route persists for replan discriminator');
+const mismatchDir = getSessionDir(ROOT, mismatchSession, mismatchPayload);
+const mismatchPlan = run(controller, [
+  'plan', '--session-id', mismatchSession,
+  '--requirements-json', requirements,
+  '--strategy', 'fable-staged',
+  '--evidence', 'decomposition indicates dependent multi-stage work instead',
+]);
+check(mismatchPlan.status === 0, 'post-decomposition workflow can be recomposed through the router contract');
+const mismatchObligations = readJson(path.join(mismatchDir, 'workflow-obligations.json'));
+const mismatchWorkflow = readJson(path.join(mismatchDir, 'workflow-run.json'));
+check(mismatchObligations.workflowSelection.disposition === 'confirmed', 'recomposed workflow receives an explicit confirmed disposition');
+check(mismatchObligations.workflowSelection.requestedStrategy === 'fable-staged' &&
+  mismatchObligations.workflowSelection.confirmedStrategy === 'fable-staged',
+  'requested and router-confirmed post-decomposition strategy are preserved');
+check(mismatchWorkflow.pendingPlan?.strategy === 'fable-staged', 'recomposed plan becomes the pending execution contract');
+const mismatchStop = run(stopGate, [], { session_id: mismatchSession, cwd: ROOT, hook_event_name: 'Stop' });
+const mismatchAfterStop = readJson(path.join(mismatchDir, 'workflow-run.json'));
+check(mismatchStop.status === 0 && mismatchAfterStop.state === 'pending' &&
+  (mismatchAfterStop.unresolved || []).includes('execution:not-started'),
+  'recomposed workflow cannot become satisfied before its selected topology starts');
+const mismatchStart = run(controller, ['start', '--session-id', mismatchSession]);
+check(mismatchStart.status !== 0 && /workflow-stages\.json/.test(mismatchStart.stderr || ''),
+  'recomposed Fable topology proceeds to its native stage-contract requirement');
+check(run(workflowGate, [], {
+  session_id: mismatchSession, cwd: ROOT, hook_event_name: 'PreToolUse',
+  tool_name: 'Write', tool_input: { file_path: path.join(ROOT, 'tmp-replan.txt'), content: 'x' },
+}).status === 0, 'recomposed planning state still does not recreate a tool lock');
+
+const prohibitedSession = 'issue85-prohibited-recompose';
+const prohibitedPayload = { session_id: prohibitedSession, cwd: ROOT, prompt: 'Fix this checkout bug with a regression test. Do not use fable.' };
+check(run(kernel, [], prohibitedPayload).status === 0, 'prohibition fixture routes successfully');
+const prohibitedRequirements = JSON.stringify([
+  { id: 'req-safe', summary: 'Resolve the bug under the user constraints', acceptance: 'the fix is verified without prohibited topology' },
+]);
+const prohibitedPlan = run(controller, [
+  'plan', '--session-id', prohibitedSession,
+  '--requirements-json', prohibitedRequirements,
+  '--strategy', 'fable-staged',
+  '--evidence', 'candidate considered after decomposition',
+]);
+check(prohibitedPlan.status === 0, 'prohibited post-decomposition choice is evaluated by router policy');
+const prohibitedDir = getSessionDir(ROOT, prohibitedSession, prohibitedPayload);
+const prohibitedObligations = readJson(path.join(prohibitedDir, 'workflow-obligations.json'));
+check(prohibitedObligations.workflowSelection.disposition === 'blocked', 'original user prohibition survives recomposition');
+check(prohibitedObligations.obligations.find(item => item.id === 'decompose').status === 'pass' &&
+  prohibitedObligations.obligations.find(item => item.id === 'compose').status === 'blocked',
+  'requirements remain valid while only the prohibited workflow choice stays unresolved');
+
+const fableSession = 'issue85-fable';
+const fablePayload = { session_id: fableSession, cwd: ROOT, prompt: 'Refactor the entire authentication architecture in dependent stages.' };
+check(run(kernel, [], fablePayload).status === 0, 'Tier 3 Fable candidate persists successfully');
+const fableDir = getSessionDir(ROOT, fableSession, fablePayload);
+const fableWorkflow = readJson(path.join(fableDir, 'workflow-run.json'));
+const fablePlanning = readJson(path.join(fableDir, 'workflow-obligations.json'));
+check(fableWorkflow.strategy === 'fable-staged', 'Tier 3 keeps Fable as preliminary candidate');
+check(fablePlanning.obligations.map(item => item.id).join(',') === 'decompose,compose', 'Fable also requires requirements/workflow planning before stage execution');
+check(run(controller, ['start', '--session-id', fableSession]).status !== 0, 'Fable cannot enter stage execution before planning contract resolves');
+
+const tier1Session = 'issue85-tier1';
+const tier1Payload = { session_id: tier1Session, cwd: ROOT, prompt: 'Update one README typo' };
+check(run(kernel, [], tier1Payload).status === 0, 'Tier 1 route persists successfully');
+const tier1Dir = getSessionDir(ROOT, tier1Session, tier1Payload);
+const tier1WorkflowFile = path.join(tier1Dir, 'workflow-run.json');
+check(!fs.existsSync(path.join(tier1Dir, 'workflow-obligations.json')), 'clear bounded Tier 1 intent has no decomposition overhead');
+check(run(stopGate, [], { session_id: tier1Session, cwd: ROOT, hook_event_name: 'Stop' }).status === 0, 'Tier 1 direct Stop remains lightweight');
+const tier1Workflow = readJson(tier1WorkflowFile);
+check(tier1Workflow.strategy === 'direct-single' && tier1Workflow.state === 'satisfied', 'Tier 1 remains a minimal direct path');
+
+const runtimeSource = fs.readFileSync(path.join(ROOT, 'hooks/scripts/lib/workflow-runtime.js'), 'utf8');
+check(!runtimeSource.includes('.mutation-probes.lock'), '#190 mutation-probe lock remains retired');
+check(!runtimeSource.includes('budget-exhausted'), '#190 hard budget state remains retired');
+
+fs.rmSync(stateHome, { recursive: true, force: true });
+console.log('\n' + (failed === 0 ? 'PASS' : 'FAIL') + ': issue #85 requirements-first workflow contract (' + failed + ' failures)');
+process.exit(failed === 0 ? 0 : 1);

package/docs/workflows/environment-detection.md

@@ -13,8 +13,12 @@ graph TD
   PreflightOk -->|yes| ParseOut[Parse OS shell PATH and CLIs]
   PreflightOk -->|no| FallbackProbe[Inspect environment_info and probe shell]
   FallbackProbe --> ParseOut
-  ParseOut --> SelfHealAudit[Audit harness touchpoints with self-heal.js]
-  SelfHealAudit --> AdoptSyntax[Adopt shell-specific syntax]
+  ParseOut --> SelfHealAudit[Run self-heal.js --check when supported]
+  SelfHealAudit --> Drift{Integration drift found?}
+  Drift -->|ordinary detection| ReportOnly[Report only; do not mutate]
+  Drift -->|explicit repair intent| Repair[Run supported platform repair]
+  ReportOnly --> AdoptSyntax[Adopt shell-specific syntax]
+  Repair --> AdoptSyntax
   AdoptSyntax --> DoneCtx([Session context aligned])
 ```
 
@@ -48,10 +52,11 @@ graph LR
 A session starts on Windows with PowerShell as the active shell. The agent needs to list files and check Node availability before running tests.
 
 1. Run `node "<skill-dir>/scripts/preflight.js"` to detect Windows + PowerShell + available CLIs.
-2. Adopt PowerShell syntax for paths and env vars instead of Git Bash assumptions.
-3. If `preflight.js` cannot run, inspect `<environment_info>` and probe with minimal echo/env commands, then adopt syntax.
-4. Stay inside `process.cwd()`; ignore other workspace, history, or temp paths shown by the IDE.
-5. If the same aligned command still fails three times, stop retrying the syntax and trigger `zoom-out`.
+2. Where the local Harness runtime exists, run self-heal in `--check` mode only; report drift without changing hooks or advisory files.
+3. If the helper/runtime is absent (for example a skills-only distribution), report that the local repair surface is unavailable and continue without searching parent/cache paths.
+4. Only an explicit install/setup/repair request may invoke mutating self-heal. OpenCode keeps its separate plugin installation/runtime boundary.
+5. Adopt PowerShell syntax for paths and env vars instead of Git Bash assumptions. If `preflight.js` cannot run, inspect `<environment_info>` and probe minimally.
+6. Stay inside `process.cwd()`; if the same aligned command still fails three times, trigger `zoom-out`.
 
 ```mermaid
 graph TD
@@ -68,6 +73,9 @@ graph TD
 - [ ] Detection ran at session start via `environment-detection/scripts/preflight.js`, with `<environment_info>` inspection and probing used only as fallback
 - [ ] Adopted syntax matches detected shell: Git Bash uses `/`, `$VAR`, Unix cmds without `dir`/`del`; PowerShell uses `$env:VAR` and cmdlets; CMD uses `\`, `%VAR%`, `dir`/`del`/`copy` without Unix cmds
 - [ ] All commands stayed inside `process.cwd()`; no commands ran outside the current project root
-- [ ] No toolchain installation was attempted; scope stayed to detection, alignment, and touchpoint repair
+- [ ] Ordinary detection changed no workspace integration files; touchpoint inspection used `--check` or safely skipped an unavailable local runtime
+- [ ] Mutating self-heal ran only for explicit install/setup/repair intent and only on a supported local platform surface
+- [ ] OpenCode was kept on its separate plugin runtime; skills-only distributions did not assume a local installer
+- [ ] No toolchain installation was attempted; scope stayed to detection and alignment
 - [ ] After three failures of the same command, execution stopped blind retry and triggered `zoom-out`
 - [ ] Shell detail followed `environment-detection/references/shell-syntax-rules.md` where needed

package/environment-detection/SKILL.md

@@ -4,38 +4,37 @@ description: Use at session start (Discover phase) to detect and align with the
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.4.0
+  version: 0.16.6
 ---
 
 # Environment Detection & Shell Alignment
 
-Think > Try > Summarize > Record: detect before executing.
-
 ## 📋 Skill Contract
 
 | Component | Specification |
 | :--- | :--- |
 | **Trigger / Input** | Session start or complex terminal sequences. |
-| **Expected Output** | Detected OS, shell, PATH via script or heuristics. |
-| **State Mutations** | Session context adopts path/env-var syntax. |
-| **Enforcement Gate** | Preflight; fall back to `<environment_info>` inspection and probing. |
+| **Expected Output** | OS, shell, PATH, available CLIs. |
+| **State Mutations** | Read-only by default; explicit repair may update Harness files. |
+| **Enforcement Gate** | Preflight; fall back to `<environment_info>` and minimal probes. |
 
-Boundary: operate solely within `process.cwd()`; ignore other workspaces, history, or temp paths surfaced by the IDE — never run commands outside the current project root.
+Boundary: stay inside `process.cwd()`. Detection never writes integrations or searches parent/cache paths for another runtime.
 
 ## Workflow
 
-1. Preflight from this skill's own directory; parse OS, shell, available CLIs: `node "<this-skill-dir>/scripts/preflight.js"`
-2. Self-heal harness touchpoints (idempotent): `node "<skills-repo-root>/harness-everything/scripts/self-heal.js"` — audits `<workspace>/.claude/settings.json`, `<workspace>/.cursorrules`, `<workspace>/.github/copilot-instructions.md`, `<workspace>/AGENTS.md`.
-3. Adopt syntax: Git Bash → forward `/`, `$VAR`, Unix cmds (`ls`, `rm -rf`), never `dir`/`del`/PowerShell · PowerShell → `$env:VAR`, cmdlets · CMD → `\`, `%VAR%`, `dir`/`del`/`copy`, never Unix.
-4. On failure don't blindly retry — suspect wrong-shell syntax. Three failures → trigger `zoom-out`.
+1. Run `node "<this-skill-dir>/scripts/preflight.js"`; detect OS, shell, CLIs.
+2. Where supported, audit read-only: `node "<this-skill-dir>/../harness-everything/scripts/self-heal.js" --check`. If unavailable, report and continue.
+3. Only explicit install/setup/repair intent may omit `--check`. Repair covers Claude, Codex, Copilot, Cursor, Continue, Hermes. OpenCode has its own plugin runtime; skills-only surfaces may lack repair.
+4. Adopt shell syntax: Git Bash → `/`, `$VAR`, Unix commands; PowerShell → `$env:VAR`, cmdlets; CMD → `\`, `%VAR%`, Windows commands. Three repeated failures → `zoom-out`.
 
 Deep dive: <this-skill-dir>/references/shell-syntax-rules.md
 
 ## USE FOR:
-- session-start OS/shell/toolchain detection
-- per-terminal command/path/env-var alignment
-- repairing missing harness touchpoints
+- session-start environment detection
+- shell/path/toolchain alignment
+- read-only audit or explicit repair
 
 ## DO NOT USE FOR:
-- operating outside the current workspace
-- installing toolchains from scratch
+- implicit repair during detection
+- six-adapter repair on OpenCode/skills-only surfaces
+- work outside the workspace or toolchain installation

package/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through the Harness kernel: classify T
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.16.5
+  version: 0.17.0
 ---
 
 # Harness Everything

package/harness-everything/scripts/kernel-router.js

@@ -44,7 +44,8 @@ function isHostNotificationPrompt(prompt) {
   return /^<task-notification[\s>][\s\S]*<\/task-notification>\s*$/i.test(text);
 }
 
-function persistWorkflow(plan, payload, prompt) {
+function persistWorkflow(contract, payload, prompt) {
+  const plan = contract && contract.workflowPlan;
   if (!payload || !(payload.session_id || payload.sessionId)) return null;
   const { runtime, hooksRoot } = loadRuntime();
   const context = runtime.loadWorkflow(payload);
@@ -83,6 +84,7 @@ function persistWorkflow(plan, payload, prompt) {
     verification: plan.verification,
     mutationIsolation: plan.mutationIsolation || { required: false },
     workflowPlan: plan,
+    taskShape: contract.taskShape || null,
     state: selected ? 'pending' : 'deferred',
     planningWarnings: plan.fallback?.disposition === 'none' ? [] : [...(plan.fallback?.reasonCodes || [])],
     runId: null,
@@ -94,6 +96,10 @@ function persistWorkflow(plan, payload, prompt) {
       hardBoundaries: ['rule-of-3-reflection', 'user-host-permission'],
     },
   };
+  if (selected && ['tier2', 'tier3'].includes(plan.tier)) {
+    const { initializePlanningContract } = require(path.join(hooksRoot, 'lib/workflow-obligations'));
+    initializePlanningContract(context, plan);
+  }
   const memoryCapability = issueMemoryCapability(context.workflow);
   runtime.saveWorkflow(context);
   return { ...context, hooksRoot, retained: false, memoryCapability };
@@ -115,7 +121,7 @@ function run(raw) {
   let persisted = null;
   let failure = null;
   try {
-    persisted = persistWorkflow(plan, payload, prompt);
+    persisted = persistWorkflow(result?.contract || null, payload, prompt);
     if (persisted?.retained && persisted.workflow) plan = persisted.workflow.workflowPlan;
   } catch (error) { failure = error; }
   if (hostNotification && !persisted?.workflow) {
@@ -146,7 +152,12 @@ function run(raw) {
     console.log('   - Memory write disposition: ' + (persisted.workflow.workflowPlan.memory?.write || 'none'));
     if (persisted.memoryCapability) console.log('   - Memory capability (single-use, workflow/session-bound): ' + persisted.memoryCapability);
     console.log('   - Stage specification: ' + path.join(persisted.sessionDir, 'workflow-stages.json'));
-    console.log('   - Enter/replan: node "' + controller + '" start --session-id "' + persisted.sessionId + '"');
+    if (plan.strategySelection === 'selected' && ['tier2', 'tier3'].includes(plan.tier)) {
+      console.log('   - Planning contract: ' + path.join(persisted.sessionDir, 'workflow-obligations.json'));
+      console.log('   - Requirements first: decompose intent into requirement fragments, then confirm the smallest sufficient workflow.');
+      console.log('   - Record plan: node "' + controller + '" plan --session-id "' + persisted.sessionId + '" --requirements-json "[{\\\"id\\\":\\\"req-1\\\",\\\"summary\\\":\\\"...\\\",\\\"acceptance\\\":\\\"...\\\"}]" --strategy "' + plan.strategy + '" --evidence "<why this workflow fits>"');
+    }
+    console.log('   - Enter selected workflow after planning: node "' + controller + '" start --session-id "' + persisted.sessionId + '"');
     console.log('   - Escape one declared stage: node "' + controller + '" escape --session-id "' + persisted.sessionId + '" --stage-id "<id>" --reason-code workflow-uncovered-scope --scope "<uncovered scope>" --evidence "<evidence>"');
   } else {
     console.log('   - Runtime state was not persisted; reminders may be less precise, but execution remains available.');