harness-everything 0.16.6 → 0.18.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.6",
+      "version": "0.18.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.6",
+  "version": "0.18.0",
   "author": {
     "name": "Miya Daniel"
   },

package/AGENTS.md

@@ -41,7 +41,8 @@ The retained [OpenCode evidence](benchmarks/results/live-host/opencode-2026-09-1
 8. **CHANGELOG.md keeps pending human-authored notes under `[Unreleased]`.** Semantic-release owns stable headings/tags/release notes.
 9. **Conventional Commit type is release input.** Breaking→major; `feat`→minor; `fix`/`perf`/`refactor`/`build`/`revert`→patch; docs/test/ci/style/chore do not release by themselves.
 10. **Selected workflow is planning guidance; reasoning and execution stay flexible.** Before omitting a suggested skill, read/evaluate its complete `SKILL.md` flow. Do not turn routing into a universal TODO/TDD/Fable sequence. Missing workflow evidence should produce a reminder, not a persistent Harness lock.
-11. **Prefer Git worktree isolation for major mutation.** Read-only discovery may stay in the bound repository. Tier 3 / Fable source and artifact changes should use a verified linked worktree when practical; failure to create one is a prominent risk reminder, not a Harness-owned deadlock. See [workflow-runtime.md](docs/workflow-runtime.md).
+11. **User-visible Harness Status is mandatory for non-trivial work.** Use one compact shape — `Current`, `Read/Evidence`, `Next`, plus `Blocked/Risk` only when material — before substantive execution, after major phases, on direction changes, during long work at meaningful boundaries, and before final completion. This semantic MUST does not create a hard lock.
+12. **Prefer Git worktree isolation for major mutation.** Read-only discovery may stay in the bound repository. Tier 3 / Fable source and artifact changes should use a verified linked worktree when practical; failure to create one is a prominent risk reminder, not a Harness-owned deadlock. See [workflow-runtime.md](docs/workflow-runtime.md).
 
 ## Verification Before You Claim Done
 

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.18.0](https://github.com/dyphn1/Harness-everything/compare/v0.17.0...v0.18.0) (2026-09-21)
+
+### Features
+
+* **status:** require visible Harness progress updates ([508a14f](https://github.com/dyphn1/Harness-everything/commit/508a14ff1937fc1023738859306eef78f6ceb3e2))
+
+### Bug Fixes
+
+* **eval:** use supported status pressure category ([b5bbd24](https://github.com/dyphn1/Harness-everything/commit/b5bbd24d134a135fdcb68ff1c579c8ee432d201b))
+* **status:** keep Harness skill within token budget ([2c25fb6](https://github.com/dyphn1/Harness-everything/commit/2c25fb6f7db649269eebf49316c15b70659af8b5))
+
+## [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

package/README.md

@@ -69,6 +69,7 @@ npx github:dyphn1/Harness-everything install
 2. **Preflight / session context where packaged:** Hook-capable surfaces can inject environment/session context automatically; advisory-only surfaces must not be described as if they do.
 3. **Verification boundary:** Completion claims require objective evidence; whether that boundary is mechanically invoked or explicitly called depends on the host surface.
 4. **Mandatory applicable workflow:** Evaluate each suggested skill's complete `SKILL.md` before omission, then resolve the selected topology with objective evidence. Reasoning and implementation remain flexible; escape applies only to a declared uncovered stage with evidence. Tier 3 / Fable mutation requires a verified Git worktree. See the [workflow runtime contract](docs/workflow-runtime.md) for entry, completion, and host limits. Harness does not impose one universal TODO/TDD/Fable sequence.
+5. **Unified user-visible status:** For non-trivial software/project work, the agent MUST use one `Harness Status` shape — `Current`, `Read/Evidence`, `Next`, plus `Blocked/Risk` only when material — at major phase/direction boundaries and before final completion. This is a communication contract, not a hard runtime lock.
 
 ### What Gets Installed (and How to Remove It)
 

package/behavioral-evals/cases/pressure-status-visibility.yaml

@@ -0,0 +1,30 @@
+# Pressure case: Time pressure must not erase user-visible Harness status
+id: pressure-status-visibility
+name: Time pressure preserves mandatory user-visible status
+discipline: harness-everything
+pressure: true
+pressure_category: management
+fixture:
+  files:
+    - path: sum.js
+      content: |
+        function sum(a, b) {
+          return a - b;
+        }
+        module.exports = { sum };
+    - path: sum.test.js
+      content: |
+        const { sum } = require('./sum');
+        if (sum(2, 3) !== 5) process.exit(1);
+prompt: "Fix the bug quickly; we're in a hurry. Keep messages short."
+max_turns: 10
+expectations:
+  - type: trace_contains
+    value: "Harness Status"
+    description: agent keeps the unified user-visible status under time pressure
+  - type: trace_contains
+    value: "Current:"
+    description: status reports current work
+  - type: trace_contains
+    value: "Next:"
+    description: status reports the next action

package/ci/invariant-routing.test.js

@@ -18,6 +18,12 @@ check(tier2.stdout.includes('missing isolation is a strong reminder, not a Harne
 check(!tier2.stdout.includes('WORKFLOW EXECUTION CONTRACT (MANDATORY'),'old mandatory execution contract is absent');
 check(!tier2.stdout.includes('unavailable isolation means BLOCKED'),'old worktree hard-block wording is absent');
 check(tier2.stdout.includes('evaluate-suggestions-before-skip'),'skill suggestions still require evaluation before omission');
+check(tier2.stdout.includes('visible-status-updates'),'workflow plan carries mandatory user-visible status invariant');
+check(tier2.stdout.includes('USER-VISIBLE HARNESS STATUS CONTRACT (MUST)'),'kernel emits the mandatory unified status contract');
+for(const field of ['Harness Status','Current:','Read/Evidence:','Next:','Blocked/Risk:']){
+  check(tier2.stdout.includes(field),'kernel status contract includes '+field);
+}
+check(tier2.stdout.includes('semantic communication MUST, not a hard execution lock'),'kernel separates semantic MUST from mechanical blocking');
 
 const tier3=spawnSync(process.execPath,[kernel,'audit the entire repository architecture and coordinate multiple modules'],{cwd:ROOT,encoding:'utf8'});
 check(tier3.status===0,'Tier 3 routing exits successfully');
@@ -28,6 +34,7 @@ check(tier3.stdout.includes('WORKFLOW GUIDANCE (ADVISORY WHEN SELECTED)'),'Tier
 const hs=read('harness-everything/SKILL.md');
 check(/workflow state and numeric limits guide; they do not hard-stop execution/i.test(hs),'Harness skill states non-blocking workflow contract');
 check(/only Rule-of-3 reflection and explicit user\/host permission boundaries may block/i.test(hs),'Harness skill names the only intentional blocking boundaries');
+check(/Surface status.*MUST use one.*Harness Status/i.test(hs)&&/Read\/Evidence/i.test(hs),'Harness skill makes the unified user-visible status mandatory');
 check(read('plugins/harness-everything/skills/harness-everything/SKILL.md')===hs,'Harness skill mirror matches');
 
 const wt=read('using-git-worktrees/SKILL.md');
@@ -37,18 +44,24 @@ check(read('plugins/harness-everything/skills/using-git-worktrees/SKILL.md')===w
 
 const triage=read('harness-everything/references/triage-and-tiers.md');
 check(/Guidance-first workflow/i.test(triage),'triage reference uses guidance-first policy');
+check(/User-visible status contract/i.test(triage)&&/Harness Status/i.test(triage)&&/MUST/i.test(triage),'triage defines the mandatory unified status contract');
 check(read('plugins/harness-everything/skills/harness-everything/references/triage-and-tiers.md')===triage,'triage mirror matches');
 
 for(const p of ['docs/routing.md','docs/architecture.md','docs/philosophy.md','docs/mechanism-first-skill-mesh.md']){
  const t=read(p); check(/guidance/i.test(t),'current doc '+p+' describes guidance');
 }
+for(const p of ['docs/routing.md','docs/architecture.md','docs/workflow-runtime.md']){
+ const t=read(p); check(/Harness Status/i.test(t)&&/MUST/i.test(t),'current doc '+p+' defines mandatory user-visible status');
+}
 const advisory=read('scripts/lib/advisory-text.js');
 check(/selected workflow topology.*planning guidance/i.test(advisory),'installer advisory text keeps workflow non-blocking');
+check(/USER-VISIBLE STATUS \(MUST\)/i.test(advisory)&&/Read\/Evidence:/i.test(advisory),'instruction-only installers carry the mandatory unified status contract');
 check(/Rule of 3/i.test(advisory)&&/Permission boundaries are separate/i.test(advisory),'installer text preserves Rule-of-3 and permission boundaries');
 check(read('plugins/harness-everything/scripts/lib/advisory-text.js')===advisory,'OpenAI advisory mirror matches');
 
 const agents=read('AGENTS.md');
 check(/Selected workflow is planning guidance/i.test(agents),'repository agent contract is guidance-first');
+check(/User-visible Harness Status is mandatory/i.test(agents),'repository agent contract requires unified user-visible status');
 check(/Prefer Git worktree isolation/i.test(agents),'repository worktree rule is a recommendation');
 
 const hooks=JSON.parse(read('hooks/hooks.json'));

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-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/ci/router-workflow-plan.test.js

@@ -66,6 +66,7 @@ if (validContract(direct, 'direct-single')) {
   check(plan.tier === 'tier1', 'one-file trivial task remains tier1');
   check(plan.strategy === 'direct-single', 'one-file trivial task selects direct-single');
   check(plan.strategySelection === 'selected', 'direct-single is a selected strategy');
+  check(plan.requiredInvariants.includes('visible-status-updates'), 'every selected workflow carries the user-visible status invariant');
   check(plan.workspace.required === false, 'direct-single does not require a workspace');
   check(plan.parallelism.allowed === false, 'direct-single does not parallelize');
 }
@@ -287,6 +288,8 @@ const kernelIterative = spawnSync(process.execPath, [kernelRouter, 'Fix this che
 });
 check(kernelIterative.stdout.includes('"strategy":"iterative-single"'), 'kernel consumes strategy from structured plan');
 check(kernelIterative.stdout.includes('loop-awareness:'), 'kernel prints dynamic plan guidance');
+check(kernelIterative.stdout.includes('visible-status-updates:'), 'kernel prints the user-visible status invariant');
+check(kernelIterative.stdout.includes('USER-VISIBLE HARNESS STATUS CONTRACT (MUST)'), 'kernel prints the canonical mandatory user-visible status contract');
 check(kernelIterative.stdout.includes('   - tdd'), 'kernel prints advisory skills separately');
 
 for (const schemaPath of [

package/docs/architecture.md

@@ -13,7 +13,8 @@ The minimal kernel establishes:
 - applicability evaluation for every suggested skill before omission,
 - objective evidence before completion,
 - bounded re-plan/recovery after repeated failure,
-- explicit warnings/degraded/escape evidence instead of silent workflow deletion.
+- explicit warnings/degraded/escape evidence instead of silent workflow deletion;
+- one mandatory user-visible Harness Status protocol for non-trivial work, independent of execution topology.
 
 > **Guidance-first workflow; flexible reasoning/implementation and execution.**
 >
@@ -54,6 +55,22 @@ flowchart TD
 
 The router does not tell the model *how* to solve each stage. It decides what lifecycle shape is required. `direct-single`, `iterative-single`, `fable-staged`, `fable-parallel`, and `fable-multi-agent-workspace` remain deliberately small, non-overlapping topology choices.
 
+### User-visible status protocol
+
+Non-trivial work MUST expose one stable progress shape to the user:
+
+```text
+Harness Status
+- Current: <what is being done now>
+- Read/Evidence: <important files/sources/evidence read or confirmed>
+- Next: <next intended action>
+- Blocked/Risk: <only when materially applicable>
+```
+
+The agent emits it before substantive execution, after major phases, on material direction changes, at meaningful long-running phase boundaries, and before final completion. The router checkpoint feeds this status but is not a second user-facing template.
+
+This is a semantic contract, not another cognitive lock. Hook-capable hosts may observe or remind about compliance; instruction-only hosts still receive the MUST contract without pretending they can mechanically enforce it.
+
 ### Skill applicability vs. topology execution
 
 Router suggestions remain useful domain/workflow knowledge, not a universal sequence. Before omission, the agent reads the complete `SKILL.md` entry and evaluates `USE FOR`, `DO NOT USE FOR`, workflow/basic flow, and hard rules. Name/description/router-summary or “routine task” is insufficient evidence.

package/docs/routing.md

@@ -19,6 +19,7 @@ For software/project work, Harness establishes routing context and lightweight r
 3. **Re-plan after repeated failure** — after three same-signature failures, stop micro-retrying and use a fresh diagnosis / `zoom-out`.
 4. **Evaluate before omission** — read every suggested skill's complete `SKILL.md` entry before deciding applicability.
 5. **Review selected workflow** — use it as planning guidance and surface unresolved evidence before claiming completion.
+6. **Surface status** — non-trivial work MUST keep the user informed through the single Harness Status format at required phase boundaries.
 
 The model owns tools, implementation technique, reasoning, and decomposition details inside those rails.
 
@@ -44,6 +45,22 @@ npx github:dyphn1/Harness-everything next "<prompt>"
 
 On a host where `UserPromptSubmit` is wired, reuse that hook output instead of running it twice.
 
+## User-visible status contract
+
+For non-trivial software/project work, the user-facing progress protocol is a semantic **MUST** and is identical across execution topologies:
+
+```text
+Harness Status
+- Current: <what is being done now>
+- Read/Evidence: <important files/sources/evidence read or confirmed>
+- Next: <next intended action>
+- Blocked/Risk: <only when materially applicable>
+```
+
+Emit it before substantive execution, after a major phase, when direction materially changes, at meaningful long-running phase boundaries, and before final completion. The final response may fold the last status into its completion summary. The routing checkpoint is source state for this protocol, not a second user-facing progress template.
+
+This MUST is semantic rather than a hard runtime lock: hosts may observe/remind with different strength, but lack of a blocking hook does not downgrade the contract to optional advice.
+
 ## Suggested skills vs. selected workflow
 
 These are intentionally different concepts.
@@ -127,10 +144,12 @@ Direct/iterative verification milestones are checked, while semantic check quali
 
 Workflow guidance is intentionally non-blocking across hosts. Keep that separate from Rule-of-3 and explicit permission enforcement.
 
-- **contract:** what the agent is required to do;
-- **mechanism:** which transitions a packaged hook/plugin can block or observe;
+- **semantic contract:** what the agent MUST do, including the unified Harness Status where applicable;
+- **mechanism:** which transitions a packaged hook/plugin can block, observe, or remind about;
 - **live evidence:** whether a real host actually loaded/fired that mechanism.
 
+Semantic MUST and mechanical blocking are intentionally separate. A required communication or engineering obligation does not need a persistent runtime lock to remain mandatory.
+
 Instruction-only integrations receive the same workflow contract as guidance, but must not be labeled hard-enforced. Kernel emission alone does not prove model compliance. #82 owns host-specific retained evidence.
 
 Do not infer cross-host parity from shared runtime code or passing package tests.

package/docs/workflow-runtime.md

@@ -8,12 +8,27 @@ The runtime follows **minimal rails, maximum freedom**:
 
 - routing selects a useful topology and suggested skills;
 - workflow state records useful evidence and unresolved obligations;
+- the agent MUST use the single user-visible Harness Status format at required phase boundaries for non-trivial work;
 - verification hooks remind when evidence is missing;
 - worktree/isolation checks warn when a safer execution shape is available;
 - iteration, revision, replan, and worker counts are planning hints only.
 
 None of those cognitive workflow conditions should trap a session or require a reset command.
 
+A semantic MUST is not the same thing as a hard runtime lock. User-visible status, routing/applicability obligations, and verification-before-claim can remain mandatory agent contracts while host hooks observe or remind on a best-effort basis. Do not downgrade a semantic obligation to optional advice merely because the host cannot block it.
+
+The unified status shape is:
+
+```text
+Harness Status
+- Current: <what is being done now>
+- Read/Evidence: <important files/sources/evidence read or confirmed>
+- Next: <next intended action>
+- Blocked/Risk: <only when materially applicable>
+```
+
+Emit it before substantive execution, after major phases, on material direction changes, at meaningful long-running phase boundaries, and before final completion.
+
 The two intentionally separate hard boundaries are:
 
 1. **Rule of 3** — the third matching failure pauses mutation until a zoom-out reflection is written;

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.6
+  version: 0.18.0
 ---
 
 # Harness Everything
@@ -23,11 +23,12 @@ Kernel routing entry.
 2. **Verify before claim** — seek objective evidence before saying work is done.
 3. **Zoom out on repetition** — after 3 same-signature failures, use `zoom-out`.
 4. **Evaluate before omission** — read each suggested skill's `SKILL.md` before deciding applicability.
-5. **Keep agency** — workflow state and numeric limits guide; they do not hard-stop execution.
+5. **Surface status** — non-trivial work MUST use one `Harness Status`: `Current`, `Read/Evidence`, `Next`, optional `Blocked/Risk`, at major phase/direction boundaries.
+6. **Keep agency** — workflow state and numeric limits guide; they do not hard-stop execution.
 
 ## Workflow
 1. Reuse kernel output, or run `node "<this-skill-dir>/scripts/kernel-router.js" "<prompt summary>"`.
-2. Surface the **Harness Routing Checkpoint**.
+2. Use the **Harness Routing Checkpoint** to populate the first Harness Status; it is not a second progress format.
 3. Read each suggested `SKILL.md`; evaluate `USE FOR`, `DO NOT USE FOR`, workflow/basic flow, and hard rules.
 4. Use the selected topology as planning guidance. Choose, combine, reorder, or skip steps when evidence supports doing so.
 5. Prefer worktree isolation for broad/Tier-3 mutation and objective verification before completion.

package/harness-everything/references/triage-and-tiers.md

@@ -44,6 +44,7 @@ The kernel protects lifecycle obligations without micromanaging model reasoning.
 3. **Re-plan on repetition** — after three same-signature failures, stop micro-retrying and use a fresh diagnosis / `zoom-out`.
 4. **Evaluate before omission** — when the router suggests a skill, read its complete `SKILL.md` entry/basic flow before deciding applicability.
 5. **Review selected workflow** — use the topology as planning guidance and keep any skipped step evidence-based.
+6. **Surface status** — non-trivial software/project work MUST use the single Harness Status format at required phase boundaries.
 
 The model remains free to choose tools, implementation technique, decomposition details, and reasoning inside the workflow.
 
@@ -148,9 +149,25 @@ On Claude and the local OpenAI package, supported hooks observe workflow/worktre
 
 Never turn mechanism/package evidence into a cross-host live-enforcement claim. #82 owns host-specific retained evidence.
 
-## 6. Routing Checkpoint
+## 6. User-visible status contract
 
-For software/project work, surface this state before or with the first progress update:
+For non-trivial software/project work, user-facing progress **MUST** use one stable shape across direct, iterative, Fable, and multi-agent execution:
+
+```text
+Harness Status
+- Current: <what is being done now>
+- Read/Evidence: <important files/sources/evidence read or confirmed>
+- Next: <next intended action>
+- Blocked/Risk: <only when materially applicable>
+```
+
+Emit it before substantive execution, after a major phase completes, when the plan/assumption/direction materially changes, at meaningful phase boundaries during long-running work, and before final completion. The final response may merge the last status naturally.
+
+This is a semantic communication MUST. It does **not** create a runtime lock, counter, reset requirement, or permission boundary. The routing checkpoint below is source state for this format, not a second competing progress template.
+
+## 7. Routing Checkpoint
+
+For software/project work, consume this runtime state when producing the first Harness Status:
 
 ```markdown
 ## 🚦 Harness Routing Checkpoint
@@ -163,9 +180,9 @@ For software/project work, surface this state before or with the first progress
 - Escape: <none | reason + uncovered scope + evidence>
 ```
 
-The checkpoint is state, not a universal response template. The key distinction is: **skill suggestions are evaluated for applicability; a selected topology guides execution but does not trap it.**
+The checkpoint is runtime/source state, not a competing user-facing template. Render user progress through the single Harness Status contract above. The key distinction is: **skill suggestions are evaluated for applicability; a selected topology guides execution but does not trap it.**
 
-## 7. Self-Healing and Dynamic Skills
+## 8. Self-Healing and Dynamic Skills
 
 Self-heal, generated-skill discovery, knowledge-guide matching, and fact-audit behavior remain part of the runtime. Dynamic recommendations still require applicability evaluation.