harness-everything 0.11.6 → 0.11.7

package/docs/workflows/verification-loop.md

@@ -1,71 +1,66 @@
 # Workflow: Verification Loop
 
-> Comprehensive pre-PR quality gate executing builds, linting, type-checking, test suites, and security scans before claiming a task complete.
+> Run the objective gates — build, types, lint, tests, security, diff — and only claim done when the evidence-backed report passes.
 
----
+Source of truth: `verification-loop/SKILL.md`.
 
-## 1. Skill Behavior Workflow
+Contract summary from SKILL.md — Trigger: completed implementation or change awaiting delivery. Output: evidence-backed verification report and delivery decision. USE FOR: verify a feature or change before delivery, run quality gates before a PR. DO NOT USE FOR: fixing failures without re-running the loop, writing new features or tests (use `tdd`).
 
-This section visualizes how the `verification-loop` skill executes internally, detailing the sequence of operations, state transitions, and evaluation steps.
+## 1. Skill Behavior Workflow
 
 ```mermaid
 graph TD
-  Start([Pre-PR Quality Check Triggered]) --> RunBuild["1. Phase 1: Build Verification"]
-  RunBuild --> RunTypeCheck["2. Phase 2: Type Check (tsc / pyright)"]
-  RunTypeCheck --> RunLint["3. Phase 3: Lint Check"]
-  RunLint --> RunTests["4. Phase 4: Test Suite Execution"]
-  RunTests --> RunSecurity["5. Phase 5: Security & Secret Scan"]
-  RunSecurity --> DiffReview["6. Phase 6: Diff Review"]
-  
-  DiffReview --> CheckScript{7. Is verify-gate.js / Template Available?}
-  CheckScript -->|Yes| ScriptReport["Run harness-everything/scripts/verify-gate.js & Fill Template"]
-  CheckScript -->|No| DirectReport["Output Verification Report Inline"]
-  
-  ScriptReport --> CheckGate{All Verification Gates Passed?}
-  DirectReport --> CheckGate
-  
-  CheckGate -->|No| FixIssues["Fix Issues in Code & Re-verify"] --> RunBuild
-  CheckGate -->|Yes| End([Pre-PR Verification Gate Cleared])
+  Start[Completed Change Awaiting Delivery] --> Build[Gate1 Build npm run build]
+  Build --> Types[Gate2 Types tsc noEmit or pyright]
+  Types --> Lint[Gate3 Lint npm run lint or ruff]
+  Lint --> Tests[Gate4 Tests npm run test coverage]
+  Tests --> Security[Gate5 Security Secrets StrayLogs]
+  Security --> Diff[Gate6 Diff git diff stat]
+  Diff --> Report[Fill verification-report template]
+  Report --> Decision{All Gates Pass?}
+  Decision -->|yes| Deliver([Delivery Decision Ready])
+  Decision -->|no| Fix[Fix Cause Rerun From First Affected Gate]
+  Fix --> Build
 ```
 
----
-
 ## 2. Triggering and Routing Path
 
-This diagram illustrates how the `verification-loop` skill is triggered through user requests or developer actions, and how it integrates or chains together with other companion skills in the Harness OS ecosystem to form unified workflows.
-
 ```mermaid
-graph LR
-  Router["harness-everything / tier-router.js"] -->|Pre-PR checks / gate| VerLoop["verification-loop / SKILL.md"]
-  VerLoop -->|Guards finalize step in| Todo["todo-driven-workflow / SKILL.md"]
-  VerLoop -->|Requires test environment setup from| Env["environment-detection / SKILL.md"]
-  VerLoop -->|Precedes safe commit push in| GitCommit["git-commit / SKILL.md"]
+graph TD
+  VerifyReq[Run Full Verification Loop Request] --> Skill[verification-loop SKILL]
+  DeliveryReq[Verify Before Delivery Request] --> Skill
+  PRReq[Quality Gates Before PR] --> Skill
+  DesignOnly[Design Discussion No Completed Work] --> Decline[Do Not Route]
+  PlanOnly[Planning Without Code Changes] --> Decline
+  NewWork[Write New Features Tests] --> TDD[tdd SKILL]
+  Skill --> Gates[Build Type Lint Test Security Diff]
 ```
 
----
-
-## 3. Real-World Use Case Flowchart
-
-Here we model concrete real-world scenarios and use cases of the `verification-loop` skill, illustrating standard success paths, error handling, or recovery loops.
+## 3. Real-World Use Case
 
 ```mermaid
 graph TD
-  Start["Feature code written; ready to claim task complete"] --> Trigger["verification-loop skill runs"]
-  Trigger --> Build["Run 'npm run build' -> Succeeded"]
-  Build --> Type["Run 'npm run typecheck' -> Found 2 type mismatches in routes.ts"]
-  Type --> FixT["Fix incorrect type casting in routes.ts"]
-  FixT --> Recheck["Re-run typecheck -> Succeeded"]
-  Recheck --> Lint["Run 'npm run lint' -> Clean"]
-  Lint --> Tests["Run 'npm run test' -> 24 tests passed"]
-  Tests --> Done([Verification loop complete; safe to open PR])
+  Done[Feature Implemented Awaiting PR] --> B[Run npm run build]
+  B -->|pass| T[Run npx tsc noEmit]
+  T -->|fail| FixT[Fix Type Errors]
+  FixT --> B
+  T -->|pass| L[Run npm run lint]
+  L -->|pass| TS[Run npm run test coverage]
+  TS -->|pass| Sec[Check Secrets And Stray Logs]
+  Sec --> D[Check git diff stat For Unintended Changes]
+  D --> R[Fill templates verification-report template md]
+  R --> PR[Report Evidence And Delivery Decision]
 ```
 
----
+Template: `verification-loop/templates/verification-report.template.md`. Deep dive: `verification-loop/references/verification-phases.md`.
 
 ## 4. Verification Check
 
-To ensure that the `verification-loop` skill is operating in strict compliance with Harness OS design laws, verify the following:
-
-- [ ] **Physical Boundary Verification**: The skill boundaries are respected and do not leak context.
-- [ ] **State Checkpoint Verification**: The active state is established, validated, and recorded at the beginning and end of each execution branch.
-- [ ] **Cognitive Alignment**: The skill conforms to the **Think > Try > Summarize > Record** cognitive loop.
+- [ ] No completion was claimed until every applicable gate passed
+- [ ] Build gate ran (`npm run build`) with evidence recorded
+- [ ] Type gate ran (`npx tsc --noEmit` or `pyright .`) with evidence recorded
+- [ ] Lint gate ran (`npm run lint` or `ruff check .`) with evidence recorded
+- [ ] Test and coverage gate ran (`npm run test -- --coverage`) with evidence recorded
+- [ ] Security gate checked secrets and stray logs with evidence recorded
+- [ ] Diff gate checked `git diff --stat` and unintended changes with evidence recorded
+- [ ] `templates/verification-report.template.md` was filled with evidence, and any failure was fixed then rerun from the first affected gate rather than patched without a rerun

package/docs/workflows/verify-before-claim.md

@@ -1,64 +1,61 @@
 # Workflow: Verify Before Claim
 
-> Fact-audit discipline requiring empirical verification of external claims, SDK configurations, defaults, and unmeasured performance estimates.
+> Check external framework, SDK, CLI, and API claims plus any unmeasured performance or cost numbers against an authoritative source, then deliver a cited claim, a real measurement, or a labeled estimate.
 
----
+Source of truth: `verify-before-claim/SKILL.md`.
 
-## 1. Skill Behavior Workflow
+Contract summary from SKILL.md — Trigger: external behavior, version/config/exit-code claim, or unmeasured number. Output: official citation, real measurement, or explicitly labeled estimate. State mutation: none; evidence travels with the claim. Gate: official source or real measurement; unresolved claims stay inconclusive. USE FOR: stating how an external framework, SDK, CLI tool, or API behaves; quoting performance, cost, latency, or timing numbers; answering "does X support Y" or version-specific questions; citing defaults, exit codes, config flags, pricing, or rate limits. DO NOT USE FOR: claims about this repository's own code, facts the user supplied directly, generic CS knowledge such as Big-O.
 
-This section visualizes how the `verify-before-claim` skill executes internally, detailing the sequence of operations, state transitions, and evaluation steps.
+## 1. Skill Behavior Workflow
 
 ```mermaid
 graph TD
-  Start([About to Assert External Framework / API Behavior or Perf Number]) --> CheckScope{Claim Scope Check}
-  CheckScope -->|Internal Repo Code| ReadSource["Read Local Source Code -> State Facts"]
-  CheckScope -->|External Framework / API / Number| CheckNet{Web Fetch / Search / Measurement Available?}
-  
-  CheckNet -->|Yes| FetchDocs["WebFetch Official Docs / Measure Real Execution"]
-  CheckNet -->|No / Offline| EstimateFallback["Explicitly Label Response as Unverified Estimate"]
-  
-  FetchDocs --> CiteDocs["Quote Authoritative Source / State Measured Data"]
-  ReadSource --> End([Verified Output Delivered])
-  CiteDocs --> End
-  EstimateFallback --> End
+  Claim[External Claim Or Unmeasured Number] --> Scope{Claim Scope?}
+  Scope -->|this repo own code| Local[Read Local Source Report Observed Facts]
+  Scope -->|external behavior or number| Official[Consult Official Docs First]
+  Official --> Numbers{Needs Number?}
+  Numbers -->|yes| Measure[Real Measurement Or Labeled Estimate]
+  Numbers -->|no| Cite[Return Cited Claim]
+  Measure --> Output[Claim With Evidence]
+  Cite --> Output
+  Local --> Output2[Fact From Source]
+  Official -->|contradiction or missing evidence| Inconclusive[Report Inconclusive]
 ```
 
----
-
 ## 2. Triggering and Routing Path
 
-This diagram illustrates how the `verify-before-claim` skill is triggered through user requests or developer actions, and how it integrates or chains together with other companion skills in the Harness OS ecosystem to form unified workflows.
-
 ```mermaid
-graph LR
-  Router["harness-everything / tier-router.js"] -->|Requires fact checking or estimates| VBC["verify-before-claim / SKILL.md"]
-  VBC -->|Empirical verification helper| RunCode["Run a real Node/terminal measurement"]
-  VBC -->|Secures quality of decisions in| GWD["grill-with-docs / SKILL.md"]
-  VBC -->|Verifies assertions in testing suite| TDD["tdd / SKILL.md"]
+graph TD
+  ExtBehave[State External Framework SDK CLI API Behavior] --> Skill[verify-before-claim SKILL]
+  PerfNum[Quote Perf Cost Latency Timing] --> Skill
+  SupportQ[Does X Support Y Version Question] --> Skill
+  ConfigQ[Cite Default ExitCode Flag Pricing Limit] --> Skill
+  OwnCode[Claim About This Repo Own Code] --> LocalSrc[Read Actual Source]
+  UserFact[Fact User Supplied Directly] --> Decline[Do Not Route]
+  GenericCS[Generic CS Knowledge BigO] --> Decline
+  Skill --> Cited[Cited Claim Or Measurement Or Estimate]
 ```
 
----
-
-## 3. Real-World Use Case Flowchart
+## 3. Real-World Use Case
 
-Here we model concrete real-world scenarios and use cases of the `verify-before-claim` skill, illustrating standard success paths, error handling, or recovery loops.
+A developer is about to assert a version-specific SDK default and a latency number in a design note. The skill routes the default to official documentation for a citation, routes the latency claim to a real measurement, and labels the value an estimate when no run exists. If sources contradict each other or no authoritative source exists, the result is reported as inconclusive rather than asserted as certain, even under time pressure.
 
 ```mermaid
 graph TD
-  Start["Developer assumes: 'Node.js fs.rmSync returns boolean upon success'"] --> Trigger["verify-before-claim skill triggered"]
-  Trigger --> ReadDocs["Checks Node.js documentation via WebSearch"]
-  ReadDocs --> FindTrue["Discovers fs.rmSync returns 'undefined' on success, and throws on failure"]
-  FindTrue --> TestCode["Executes quick Node snippet to confirm empirical behavior"]
-  TestCode --> UpdateCode["Refactors proposed catch-blocks to handle exceptions instead of checking booleans"]
-  UpdateCode --> Done([Potential production runtime crash prevented])
+  Draft[Draft Asserts SDK Default And Latency] --> CheckDocs[Check Official Docs For Default]
+  CheckDocs --> CheckNum[Require Real Measurement For Number]
+  CheckNum -->|measured| Cited2[Cited Default Plus Measured Number]
+  CheckNum -->|no run| Labeled[Labeled Estimate]
+  CheckDocs -->|conflict or gap| Inconc[Inconclusive Report]
 ```
 
----
+Deep dive: `verify-before-claim/references/verification-guide.md`.
 
 ## 4. Verification Check
 
-To ensure that the `verify-before-claim` skill is operating in strict compliance with Harness OS design laws, verify the following:
-
-- [ ] **Physical Boundary Verification**: The skill boundaries are respected and do not leak context.
-- [ ] **State Checkpoint Verification**: The active state is established, validated, and recorded at the beginning and end of each execution branch.
-- [ ] **Cognitive Alignment**: The skill conforms to the **Think > Try > Summarize > Record** cognitive loop.
+- [ ] Local-repository claims were settled by reading the actual source, not by external citation
+- [ ] External framework, SDK, CLI, or API behavior used official documentation first with a citation
+- [ ] Performance, cost, latency, or timing numbers came from a real measurement or were explicitly labeled as estimates
+- [ ] Defaults, exit codes, config flags, pricing, and rate limits were cited rather than asserted from memory
+- [ ] Contradictions or missing evidence were reported as inconclusive
+- [ ] No unverified external fact was claimed as certain, even under time pressure

package/docs/workflows/zoom-out.md

@@ -1,74 +1,62 @@
 # Workflow: Zoom Out
 
-> High-level reflection report generation to break out of error loops, analyze failure patterns, and backtrack to alternative paths.
+> Reflect-first breaker after three failures: stop edits, rebuild the full picture with read-only tools, write a fact-check report, then resume or escalate.
 
----
+Source of truth: `zoom-out/SKILL.md`.
 
-## 1. Skill Behavior Workflow
+Contract summary from SKILL.md — Trigger: three same-signature failures or an explicit loop/rethink request. Output: fact-checked report ending in `RESUME` or `ESCALATE`. State: writes the session `zoom-out-report.md`; reset may clear breaker state. Gate: `hooks/scripts/rule-of-3.js` plus a valid report; reset only after the second cycle. USE FOR: "you are stuck in a loop", "the same error keeps failing", "rethink your assumptions". DO NOT USE FOR: routine single-failure debugging, greenfield planning without failures.
 
-This section visualizes how the `zoom-out` skill executes internally, detailing the sequence of operations, state transitions, and evaluation steps.
+## 1. Skill Behavior Workflow
 
 ```mermaid
 graph TD
-  Start([3 Consecutive Failures / Goal Drift Triggered]) --> CeaseFire["1. Phase 1: Cease Fire - Stop Code Edits Immediately"]
-  CeaseFire --> Rebuild["2. Phase 2: Rebuild Full Picture using Read-Only Tools"]
-  Rebuild --> CheckPath{3. Resolve Reflection Report Path}
-  
-  CheckPath -->|Session Path Provided| WriteSession["Copy template to Session zoom-out-report.md"]
-  CheckPath -->|Template / Path Unavailable| WritePlatform["Write to .github/harness-everything/zoom-out-report.md or Inline"]
-  
-  WriteSession --> DecisionGate{4. Phase 4: Decision Gate}
-  WritePlatform --> DecisionGate
-  
-  DecisionGate -->|Untried Path Identified| Resume["RESUME: Execute Fresh Diagnosis in TDD / Fable"]
-  DecisionGate -->|Requirement Conflict / Access Gap| Escalate["ESCALATE: Present 2-3 Options + Recommendation to Human"]
-  
-  Resume --> Resolved{5. Problem Cracking Succeeds?}
-  Resolved -->|Yes| SelfEvolve["Call self-evolve to Persist Insight"]
-  Resolved -->|No: 3 More Failures| Escalate
-  SelfEvolve --> End([Reflection Completed & Lessons Persisted])
-  Escalate --> End
+  Third[Third Same Signature Failure] --> Stop[Stop Edits No User Ask Yet]
+  Stop --> ReadOnly[ReadOnly Restate Goal Check Files Config Logs]
+  ReadOnly --> Fill[Fill zoom-out-report template]
+  Fill --> Decide{RESUME or ESCALATE?}
+  Decide -->|untried path| Resume[RESUME On Untried Path]
+  Decide -->|genuine user decision| Escalate[ESCALATE With Options]
+  Resume --> Again{Repeated Breaker Cycle?}
+  Again -->|second cycle| Reset[npm run harness reset]
+  Reset --> Evolve[Record Insight With self-evolve]
+  Again -->|no| Done([Report Complete])
+  Escalate --> Done
 ```
 
----
-
 ## 2. Triggering and Routing Path
 
-This diagram illustrates how the `zoom-out` skill is triggered through user requests or developer actions, and how it integrates or chains together with other companion skills in the Harness OS ecosystem to form unified workflows.
-
 ```mermaid
-graph LR
-  RuleOf3["Rule of 3 Circuit Breaker"] -->|Tripped!| ZoomOut["zoom-out / SKILL.md"]
-  ZoomOut -->|Halts execution for| ActiveWork["Active workspace edits"]
-  ZoomOut -->|Asks for human direction via| AskQuestions["host user-input mechanism"]
-  ZoomOut -->|Unlocks workspace state after| HumanReset["Human Partner Response"]
+graph TD
+  LoopReq[Stuck In Loop Request] --> Skill[zoom-out SKILL]
+  SameErr[Same Error Keeps Failing] --> Skill
+  Rethink[Rethink Assumptions Request] --> Skill
+  ThreeFail[Three Same Signature Failures] --> Breaker[hooks scripts rule-of-3 js]
+  Breaker --> Skill
+  SingleFail[Routine Single Failure] --> DirectFix[Fix Directly]
+  Greenfield[Greenfield Planning No Failures] --> Fable[fable-mode SKILL]
+  Skill --> ReportGate[Valid Report RESUME or ESCALATE]
 ```
 
----
-
-## 3. Real-World Use Case Flowchart
-
-Here we model concrete real-world scenarios and use cases of the `zoom-out` skill, illustrating standard success paths, error handling, or recovery loops.
+## 3. Real-World Use Case
 
 ```mermaid
 graph TD
-  Start["Attempting to fix Python import error; fails 3 times consecutively with same trace"] --> Trigger["Rule of 3 circuit breaker trips"]
-  Trigger --> Lock["Workspace writes locked"]
-  Trigger --> Awaken["Awaken: Stop error-fixing; review imports design & requirements (Law 2)"]
-  Awaken --> Collect["Collect error traces and diff history"]
-  Collect --> WriteReport["Create the session zoom-out-report.md detailing the import cyclic dependency"]
-  WriteReport --> Present["Present options to human: Option A - Merge imports, Option B - Extract shared modules"]
-  Present --> UserChoice["User select: 'Option B'"]
-  UserChoice --> Unlock["Unlock workspace and execute Option B"]
-  Unlock --> Done([Error loop successfully broken and resolved])
+  Fail[Same Test Fails Three Times Same Signature] --> Halt[Stop Edits Rebuild Picture ReadOnly]
+  Halt --> Inspect[Restate Goal Check Files Config Logs]
+  Inspect --> Write[Fill templates zoom-out-report template md]
+  Write --> Choice{Untried Path Exists?}
+  Choice -->|yes| Resume2[RESUME On Untried Path]
+  Choice -->|no| Esc2[ESCALATE With Options]
+  Resume2 -->|repeated cycle| Reset2[npm run harness reset Then self-evolve]
 ```
 
----
+Template: `zoom-out/templates/zoom-out-report.template.md`. Enforcement: `hooks/scripts/rule-of-3.js`. Deep dive: `zoom-out/references/circuit-breaker.md`.
 
 ## 4. Verification Check
 
-To ensure that the `zoom-out` skill is operating in strict compliance with Harness OS design laws, verify the following:
-
-- [ ] **Physical Boundary Verification**: The skill boundaries are respected and do not leak context.
-- [ ] **State Checkpoint Verification**: The active state is established, validated, and recorded at the beginning and end of each execution branch.
-- [ ] **Cognitive Alignment**: The skill conforms to the **Think > Try > Summarize > Record** cognitive loop.
+- [ ] After three same-signature failures, edits stopped and the same approach was not retried
+- [ ] Goal, files, configuration, and logs were rechecked with read-only tools before any resume
+- [ ] `templates/zoom-out-report.template.md` was filled and the session `zoom-out-report.md` ends in `RESUME` or `ESCALATE`
+- [ ] Resume targeted only an untried path; genuine user decisions were escalated with options
+- [ ] Reset via `npm run harness:reset` happened only after the second cycle, with the insight recorded via `self-evolve`
+- [ ] Routine single-failure debugging and greenfield planning without failures were not routed here

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.11.2
+  version: 0.11.7
 ---
 
 # Harness Everything

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

@@ -33,12 +33,26 @@ function issueMemoryCapability(workflow) {
   return token;
 }
 
+// Host-generated background-task notifications arrive as UserPromptSubmit
+// hook payloads but are not user input (#168). Routing them like prompts
+// replaces the workflow contract mid-turn (e.g. deferred -> a new Tier-2).
+// A prompt that is entirely a notification envelope must never create or
+// replace a workflow; the current contract is kept unchanged.
+function isHostNotificationPrompt(prompt) {
+  const text = String(prompt || '').trim();
+  if (!text) return false;
+  return /^<task-notification[\s>][\s\S]*<\/task-notification>\s*$/i.test(text);
+}
+
 function persistWorkflow(plan, payload, prompt) {
   if (!payload || !(payload.session_id || payload.sessionId)) return null;
   const { runtime, hooksRoot } = loadRuntime();
   const context = runtime.loadWorkflow(payload);
   const { writeCurrentSession } = require(path.join(hooksRoot, 'lib/harness-state'));
   writeCurrentSession(context.root, context.sessionId);
+  if (isHostNotificationPrompt(prompt)) {
+    return { ...context, hooksRoot, retained: true, hostNotification: true };
+  }
   if (context.workflow && runtime.OPEN_STATES.has(context.workflow.state)) {
     if (!context.workflow.workflowPlan) throw new Error('legacy unresolved workflow needs explicit migration; refusing to replace its obligations');
     // Steering/status prompts cannot drop an unresolved execution contract.
@@ -92,17 +106,30 @@ function run(raw) {
     try { payload = JSON.parse(raw); } catch (_) { console.error('[Workflow Router] Invalid hook payload; lifecycle persistence unavailable.'); }
   }
   const prompt = promptArg || (typeof payload?.prompt === 'string' ? payload.prompt : '');
-  const result = core.route(promptArg, raw || null);
-  let plan = result.contract.workflowPlan;
+  const hostNotification = isHostNotificationPrompt(prompt);
+  // Host-generated notifications are lifecycle events, not user-authored task
+  // input. Never feed their text into the router: when there is an active
+  // contract we retain it below; when there is none, the event is a no-op.
+  const result = hostNotification ? null : core.route(promptArg, raw || null);
+  let plan = result?.contract?.workflowPlan || null;
   let persisted = null;
   let failure = null;
   try {
     persisted = persistWorkflow(plan, payload, prompt);
-    if (persisted?.retained) plan = persisted.workflow.workflowPlan;
+    if (persisted?.retained && persisted.workflow) plan = persisted.workflow.workflowPlan;
   } catch (error) { failure = error; }
-  if (result.sanitized) console.log(result.sanitized);
-  if (result.stderr) process.stderr.write(result.stderr);
-  if (persisted?.retained) console.log('\n=> Retaining unresolved workflow from earlier prompts; the checkpoint below is the active execution contract.');
+  if (hostNotification && !persisted?.workflow) {
+    console.log('\n=> Host notification — no active execution contract; ignored for routing.');
+    if (failure) {
+      console.error('[Workflow Router] ' + failure.message);
+      process.exitCode = 2;
+    }
+    return;
+  }
+  if (result?.sanitized) console.log(result.sanitized);
+  if (result?.stderr) process.stderr.write(result.stderr);
+  if (persisted?.hostNotification) console.log('\n=> Host notification — routing unchanged; keeping the active execution contract.');
+  else if (persisted?.retained) console.log('\n=> Retaining unresolved workflow from earlier prompts; the checkpoint below is the active execution contract.');
   core.printWorkflowPlan(plan);
   core.printRoutingCheckpoint(plan);
   core.printKernelContract(plan);
@@ -116,7 +143,7 @@ function run(raw) {
     console.log('   - Tier 3 / Fable source and artifact mutations require Git worktree isolation; unavailable isolation means BLOCKED.');
     console.log('   - Escape is limited to workflow-uncovered-scope or host-capability-unavailable, with stage, scope and evidence; other obligations remain mandatory.');
   }
-  if (persisted) {
+  if (persisted?.workflow) {
     const controller = path.join(persisted.hooksRoot, 'workflow-disposition.js');
     console.log('   - Workflow id: ' + persisted.workflow.workflowId);
     console.log('   - Memory write disposition: ' + (persisted.workflow.workflowPlan.memory?.write || 'none'));
@@ -130,12 +157,13 @@ function run(raw) {
   if (failure) {
     console.error('[Workflow Router] ' + failure.message);
     process.exitCode = 2;
-  } else if (result.status !== 0) process.exitCode = result.status || 1;
+  } else if (result && result.status !== 0) process.exitCode = result.status || 1;
 }
 
+if (typeof module !== 'undefined') module.exports = { isHostNotificationPrompt };
+
 if (process.argv.length > 2 || process.stdin.isTTY) run('');
-else {
-  let input = '';
+else {  let input = '';
   let finished = false;
   const finish = () => { if (finished) return; finished = true; clearTimeout(timeout); run(input); };
   const timeout = setTimeout(finish, 500);

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

@@ -248,6 +248,35 @@ function mutationPaths(payload) {
   }
   return [input.file_path || input.filePath || input.path].filter(value => typeof value === 'string' && value.trim());
 }
+
+// Bound workspace root plus its linked worktrees. Git failures (e.g. a
+// non-git workspace) degrade to the root alone instead of throwing, so
+// Tier-2 accounting never blocks on this enumeration (#165; cf. #162).
+function worktreeRoots(root) {
+  const roots = [root];
+  try {
+    for (const field of git(root, ['worktree', 'list', '--porcelain', '-z']).split('\0')) {
+      if (field.startsWith('worktree ')) {
+        const candidate = field.slice('worktree '.length).trim();
+        if (candidate) roots.push(candidate);
+      }
+    }
+  } catch (_) { /* root alone */ }
+  return roots;
+}
+
+// Direct-tool (Edit/Write/apply_patch) targets count against the Tier-2
+// budget only when at least one target lies inside the workspace (#165).
+// Unknown targets (no parseable path) stay conservative and count.
+function directMutationInWorkspace(payload, cwd, root) {
+  const targets = mutationPaths(payload);
+  if (!targets.length) return true;
+  const roots = worktreeRoots(root);
+  return targets.some(target => {
+    const resolved = path.resolve(cwd, target);
+    return roots.some(candidate => within(candidate, resolved));
+  });
+}
 function assertTargets(payload, cwd, isolatedRoot) {
   const targets = mutationPaths(payload);
   if (!targets.length) throw new Error('mutation target is unknown; cannot verify worktree isolation');
@@ -274,4 +303,4 @@ function assertShellScope(command, cwd, isolatedRoot) {
   }
 }
 
-module.exports = { canonical, key, within, linkedWorktree, classifyShell, workspaceFingerprint, shellProbeKey, inputOf, cwdOf, commandOf, mutationPaths, assertTargets, assertShellScope };
+module.exports = { canonical, key, within, linkedWorktree, classifyShell, workspaceFingerprint, shellProbeKey, inputOf, cwdOf, commandOf, mutationPaths, worktreeRoots, directMutationInWorkspace, assertTargets, assertShellScope };

package/hooks/scripts/rule-of-3-tracker.js

@@ -17,6 +17,7 @@ process.stdin.on('end', () => {
     const payload = JSON.parse(inputData);
     const hookEventName = payload.hook_event_name || payload.hookEventName || '';
     const isFailureEvent = hookEventName === 'PostToolUseFailure';
+    const isSuccessEvent = hookEventName === 'PostToolUse';
     const toolResponse = payload.tool_response || {};
     const stdout = toolResponse.stdout ?? payload.stdout ?? '';
     const stderr = toolResponse.stderr ?? payload.stderr ?? '';
@@ -25,10 +26,10 @@ process.stdin.on('end', () => {
     const exitCode = typeof rawExitCode === 'number' ? rawExitCode : undefined;
 
     const explicitFailure = exitCode !== undefined && exitCode !== 0;
-    const explicitSuccess = exitCode === 0;
     const stderrSignal = typeof stderr === 'string' && stderr.trim().length > 0;
     const looksLikeError = /\b(error|fail|failed|failure|exception|fatal|panic|traceback|denied|refused|cannot|unable)\b/i.test(stderr);
-    const isFailure = isFailureEvent || explicitFailure || (exitCode === undefined && stderrSignal && looksLikeError);
+    const isFailure = isFailureEvent || explicitFailure ||
+      (!isSuccessEvent && exitCode === undefined && stderrSignal && looksLikeError);
     const errorText = isFailureEvent
       ? (failureText || (stderrSignal ? stderr : stdout) || '')
       : ((stderrSignal ? stderr : stdout) || failureText || '');
@@ -47,19 +48,22 @@ process.stdin.on('end', () => {
       const filePath = payload.tool_input?.file_path || payload.tool_input?.filePath || '';
       const command = payload.tool_input?.command || '';
 
-      // Categorize failure type for context-aware thresholds
+      // Categorize failure type for context-aware thresholds.
+      // NOTE (#167): match anchored diagnostic phrases, not bare substrings.
+      // A bare `denied`/`timeout` substring matches file names such as
+      // `workflow-mutation-denied.js` and misclassifies the failure.
       let category = 'unknown';
-      if (/SyntaxError|Unexpected token|Syntax Error/i.test(errorText)) {
+      if (/\bSyntaxError\b|Unexpected token|Syntax Error/i.test(errorText)) {
         category = 'syntax';
-      } else if (/ENOENT|not found|No such file|找不到|不存在/i.test(errorText)) {
+      } else if (/\bENOENT\b|\bnot found\b|No such file|找不到|不存在/i.test(errorText)) {
         category = 'environment';
-      } else if (/timeout|timed out|超時|逾時/i.test(errorText)) {
+      } else if (/\bETIMEDOUT\b|TimeoutError|\btimeout\b|\btimed out\b|\btiming out\b|超時|逾時/i.test(errorText)) {
         category = 'timeout';
       } else if (/test.*fail|assertion|AssertionError|測試.*失敗|斷言.*錯誤/i.test(errorText)) {
         category = 'test';
-      } else if (/permission|denied|EACCES|權限/i.test(errorText)) {
+      } else if (/\bpermission denied\b|\bEACCES\b|\bEPERM\b|權限.*(拒絕|不足|被拒)|拒絕.*權限/i.test(errorText)) {
         category = 'permission';
-      } else if (/dependency|module not found|Cannot find module|模組.*找不到/i.test(errorText)) {
+      } else if (/\bdependency\b|\bmodule not found\b|Cannot find module|模組.*找不到/i.test(errorText)) {
         category = 'dependency';
       }
 
@@ -114,7 +118,11 @@ process.stdin.on('end', () => {
       state.lastFailureAt = Date.now();
 
       fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
-    } else if (!isFailureEvent && explicitSuccess) {
+    } else if (!isFailure) {
+      // NOTE (#166, follows #153): Claude Code PostToolUse success payloads
+      // carry no numeric exit code. The lifecycle event is authoritative:
+      // PostToolUse is success unless a numeric non-zero status contradicts it;
+      // hosts without lifecycle event names keep the conservative stderr fallback.
       // A successful action after an accepted zoom-out is an objective recovery
       // boundary. Emit only IDs/hashes/category; never copy command/output text.
       if ((state.zoomOutCycles || 0) > 0 && state.lastHash) {

package/hooks/scripts/state-persist.js

@@ -3,7 +3,7 @@ const fs = require('fs');
 const path = require('path');
 const { getWorkspaceRoot, getSessionDir } = require('./lib/harness-state');
 const { loadWorkflow, saveWorkflow, peekMutationProbe, settleMutationProbe } = require('./lib/workflow-runtime');
-const { cwdOf, shellProbeKey, workspaceFingerprint } = require('./lib/workflow-isolation');
+const { cwdOf, shellProbeKey, workspaceFingerprint, directMutationInWorkspace } = require('./lib/workflow-isolation');
 const { observeTool } = require('./lib/telemetry');
 
 // Commands that count as "verification ran" for the Stop gate
@@ -79,9 +79,10 @@ function processState(payload) {
       const exitCode = typeof rawExitCode === 'number' ? rawExitCode : undefined;
       const stderrSignal = typeof stderr === 'string' && stderr.trim().length > 0;
       const hookEvent = payload.hook_event_name || payload.hookEventName || '';
+      const isSuccessEvent = hookEvent === 'PostToolUse';
       const isFailed = hookEvent === 'PostToolUseFailure' ||
         (exitCode !== undefined && exitCode !== 0) ||
-        (exitCode === undefined && stderrSignal);
+        (!isSuccessEvent && exitCode === undefined && stderrSignal);
       const toolName = payload.tool_name || payload.tool || 'command';
       const observedMutation = observeWorkspaceMutation(payload, root);
 
@@ -97,8 +98,13 @@ function processState(payload) {
         state.tool = toolName;
         state.exitCode = exitCode;
         state.errorSummary = output.trim();
-      } else if (exitCode === 0 && state.status === 'failed') {
-        // Clear failed state or mark as idle/resolved
+      } else if (!isFailed && state.status === 'failed') {
+        // Clear failed state or mark as idle/resolved.
+        // NOTE (#166, follows #153): Claude Code Bash PostToolUse payloads
+        // carry no numeric exit code, so `exitCode === 0` never holds there.
+        // A PostToolUse event with no numeric non-zero exit status counts as
+        // success even when stderr contains diagnostics. Hosts that omit the
+        // lifecycle event name retain the conservative stderr fallback.
         state.lastResolved = { tool: state.tool, timestamp: state.timestamp };
         state.status = 'idle';
         state.timestamp = new Date().toISOString();
@@ -107,8 +113,10 @@ function processState(payload) {
       }
 
       // Milestones for the Stop gate: when did the last mutation happen, and
-      // has any verification-ish command succeeded since.
-      if (toolName === 'Edit' || toolName === 'Write' || toolName === 'apply_patch' || observedMutation) {
+      // has any verification-ish command succeeded since. Direct-tool edits
+      // outside the workspace advance neither milestone (#165).
+      const isDirectTool = toolName === 'Edit' || toolName === 'Write' || toolName === 'apply_patch';
+      if ((isDirectTool && directMutationInWorkspace(payload, cwdOf(payload, root), root)) || observedMutation) {
         state.lastEditAt = Date.now();
       }
       if ((toolName === 'Bash' || toolName === 'PowerShell') && !isFailed) {