harness-everything 0.46.0 → 0.46.1

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.46.0",
+      "version": "0.46.1",
       "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.46.0",
+  "version": "0.46.1",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.46.1](https://github.com/dyphn1/Harness-everything/compare/v0.46.0...v0.46.1) (2026-10-28)
+
+### Bug Fixes
+
+* **doc-reconciliation:** correlate outline dispatch by observed agent result ([c63e1ef](https://github.com/dyphn1/Harness-everything/commit/c63e1efa299496283bffb1019983b0dd54595f64))
+
 ## [0.46.0](https://github.com/dyphn1/Harness-everything/compare/v0.45.0...v0.46.0) (2026-10-28)
 
 ### Features
@@ -45,6 +51,7 @@ All notable changes to this project are documented in this file.
 
 ### Fixed
 
+- **doc-reconciliation:** correlate outline dispatches through completed Agent/Task results and unique worker start/stop events while keeping live credit gated.
 - **doc-governance:** allow regular governed-content revisions and expand base-owned governed/derived globs against Git trees, while retaining review for membership, structural, policy, trust-surface, fixture, and derived-output changes; run the guard in its own CI job.
 
 ## [0.43.0](https://github.com/dyphn1/Harness-everything/compare/v0.42.2...v0.43.0) (2026-10-27)

package/benchmarks/results/live-host/claude-341-outline-dispatch-2026-10-28/README.md

@@ -0,0 +1,75 @@
+# Live-host capture: claude-341-outline-dispatch (2026-10-28)
+
+**Verdict: the outline live gate stays UNMET.** Claude Code 2.1.312 carries the `HARNESS_OUTLINE_DISPATCH_V1` prompt, the coordinator `session_id` and a synchronous PreToolUse boundary. It does not carry two fields that `outlineCaptureMappingValid` requires: `SubagentStart.parent_tool_use_id` and an `interrupted` field on the Agent PostToolUse. This is field-availability evidence, not live-host credit. `hooks/scripts/lib/doc-reconciliation-qualification.json` is unchanged, so positive outline credit stays disabled.
+
+## What was captured
+
+```mermaid
+sequenceDiagram
+  participant C as Coordinator (session_id)
+  participant H as PreToolUse hook (held 2 s)
+  participant W as Worker (agent_id)
+  C->>H: PreToolUse Agent, tool_input.prompt = marker
+  H-->>C: hook ends (+2000 ms)
+  C->>W: SubagentStart (+30–100 ms after hook end)<br/>no parent_tool_use_id
+  W-->>C: SubagentStop
+  C->>C: PostToolUse Agent, tool_use_id matches Pre<br/>agent id only in tool_response.agentId, no interrupted
+```
+
+## Pins
+
+| Item | Value |
+|---|---|
+| Harness HEAD (staged) | `f1e6ab4e45fefa908c06f4f6fe96750b731987f9` (main after #387), clean tree |
+| Staging | `node scripts/stage-claude-plugin.js <scratch>/plugin` (1788 tracked files) |
+| Host | Claude Code `2.1.312`, macOS (darwin 25.6.0), zsh, `--model haiku` |
+| Pilot | `HARNESS_DOC_RECONCILIATION_PILOT=1`, fresh `HARNESS_STATE_HOME` per run |
+
+| File | sha256 |
+|---|---|
+| `capture.sanitized.jsonl` (this dir) | `cf1ea56c3d329edcb0a18fc6437af9d9aedf56c76a829f3949de382d07c5a657` |
+| `capture-settings.json` (session `--settings`: PreToolUse/PostToolUse `Agent\|Task`, SubagentStart, SubagentStop) | `1c3081a86a0b1e0aa894f2f09a7884ca9bf5dbf55a08ab84074d8a318bd9c587` |
+| `wrapper.js` (log-only, holds PreToolUse 2 s, runs no Harness hook) | `9071ab6b482fc31b1753df242fcf5983f1dd75ce6c5acf8ba78b1a5921f6b2fe` |
+| staged `hooks/hooks.json` | `aca70167da0fa792e34fb55e2904e2935c83f8f087de9e3cd130dd536b01eafd` |
+| staged `hooks/scripts/lib/doc-reconciliation-provider.js` | `1e0a9cc6fd040c074d96a79ec6445c328957951a7c0074427687d0a22179ec3b` |
+
+## Command (sanitized)
+
+```text
+cd <scratch>/project            # fresh git repo, one commit
+HARNESS_DOC_RECONCILIATION_PILOT=1 HARNESS_STATE_HOME=<scratch>/state \
+claude -p "<fixed prompt: dispatch outline-worker twice via Agent; 1 = no isolation, 2 = isolation worktree; each prompt = marker line + 'Reply with: worker done'>" \
+  --model haiku --plugin-dir <scratch>/plugin --settings <scratch>/capture-settings.json \
+  --agents '{"outline-worker":{"description":"Capture worker that replies once and uses no tools","prompt":"Use no tools. Reply exactly: worker done"}}' \
+  --allowedTools Agent Task --session-id <fresh UUID> --setting-sources project,local \
+  --output-format stream-json --verbose
+```
+
+No bypass flag. Marker: `HARNESS_OUTLINE_DISPATCH_V1 taskId=<id> attemptId=a1 token=<token-n> workerRoot=<scratch>/project`. Both runs exited `0`.
+
+- **Run 1** used `taskId=cap-00N`. The plugin rejected it as `dispatch-marker-invalid`, because task ids must match `task-*`. This was a fixture error. The raw host payloads are still valid field evidence.
+- **Run 2** used `taskId=task-cap-00N`. The plugin parsed the marker and recorded `workflow-task-binding-invalid`. That rejection is expected, since no accepted review, handoff or lease exists in this bounded fixture.
+
+## Must-report table (mapping in `outlineCaptureMappingValid`)
+
+| Mapping clause | 2.1.312 observed | Evidence |
+|---|---|---|
+| `promptField: tool_input.prompt` | **yes**, verbatim marker | PreToolUse Agent `tool_input.prompt`, 4/4 dispatches |
+| `coordinatorPrincipalField: session_id` | **yes**, but the worker's SubagentStart/Stop carry the **same** `session_id` | Coordinator and worker differ only by `agent_id` presence |
+| `synchronousPreToolUse` | **yes** | 4/4: SubagentStart 30–100 ms after the 2 s PreToolUse hold ended |
+| `workerStartDispatchField: parent_tool_use_id` | **no**, the field is absent | 0/4 SubagentStart payloads. Only `session_id`, `prompt_id` (shared by both dispatches), `agent_id`, `agent_type`, `cwd` |
+| `workerStartRootField: cwd` | **partial** | No isolation: `cwd` = coordinator cwd. `isolation: worktree`: `cwd` = `<project>/.claude/worktrees/agent-<agent_id>`, which is unknown before dispatch, so it cannot equal the marker's `workerRoot` |
+| `taskResultDispatchField: tool_use_id` | **yes** | PostToolUse `tool_use_id` equals the Pre's, 4/4 |
+| Result `agent_id` + `interrupted === false` | **no** | No top-level `agent_id` (the plugin journal lifts `tool_response.agentId`). No `interrupted` field on the Agent result at all |
+
+## Extra finding: async launch
+
+In Run 2 dispatch 1 the model omitted `run_in_background`. The host launched the worker asynchronously: PostToolUse `status: async_launched`, `isAsync: true`, and it fired **before** SubagentStop (+2040 ms vs +3490 ms). A PostToolUse is therefore not proof that the worker finished. Any result correlation must require `status: completed` or an explicit `run_in_background: false`.
+
+## What would unblock the gate (owner/advisor decision, not done here)
+
+- Correlate worker start without `parent_tool_use_id`: for example, by the order of Pre end → next SubagentStart within the same `session_id` while one dispatch is in flight, or by `tool_response.agentId` ↔ SubagentStart `agent_id` after the fact.
+- Replace `interrupted === false` with `tool_response.status === 'completed'`.
+- Define worker-root for isolation worktrees, where the path is derived from `agent_id`, not predeclared.
+
+Each of these changes the mapping in `doc-reconciliation-provider.js`, so it needs advisor adjudication against answer-10 item 2/3 before any implementation.

package/benchmarks/results/live-host/claude-341-outline-dispatch-2026-10-28/capture.sanitized.jsonl

@@ -0,0 +1,32 @@
+{"run":"run1","phase":"start","ms":0,"event":"PreToolUse","payload":{"session_id":"<session-1>","cwd":"<scratch>/project","prompt_id":"<prompt-1>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture worker dispatch 1","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=cap-001 attemptId=a1 token=<token-1> workerRoot=<scratch>/project\nReply with: worker done","subagent_type":"outline-worker","run_in_background":false},"tool_use_id":"<tool-use-1>"}}
+{"run":"run1","phase":"end","ms":2002,"event":"PreToolUse","tool_use_id":"<tool-use-1>"}
+{"run":"run1","phase":"start","ms":2032,"event":"SubagentStart","payload":{"session_id":"<session-1>","cwd":"<scratch>/project","prompt_id":"<prompt-1>","agent_id":"<agent-1>","agent_type":"outline-worker","hook_event_name":"SubagentStart"}}
+{"run":"run1","phase":"end","ms":2033,"event":"SubagentStart","tool_use_id":null}
+{"run":"run1","phase":"start","ms":3307,"event":"SubagentStop","payload":{"session_id":"<session-1>","cwd":"<scratch>/project","prompt_id":"<prompt-1>","permission_mode":"default","agent_id":"<agent-1>","agent_type":"outline-worker","effort":{"level":"medium"},"hook_event_name":"SubagentStop","stop_hook_active":false,"last_assistant_message":"worker done","background_tasks":[],"session_crons":[]}}
+{"run":"run1","phase":"end","ms":3308,"event":"SubagentStop","tool_use_id":null}
+{"run":"run1","phase":"start","ms":3360,"event":"PostToolUse","payload":{"session_id":"<session-1>","cwd":"<scratch>/project","prompt_id":"<prompt-1>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PostToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture worker dispatch 1","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=cap-001 attemptId=a1 token=<token-1> workerRoot=<scratch>/project\nReply with: worker done","subagent_type":"outline-worker","run_in_background":false},"tool_response":{"keys":["agentId","agentType","canContinueAgent","content","harnessNoteCount","harnessSectionHash","harnessTailCount","prompt","resolvedModel","status","totalDurationMs","totalTokens","totalToolUseCount","usage"],"status":"completed","agentId":"<agent-1>"},"tool_use_id":"<tool-use-1>","duration_ms":1327}}
+{"run":"run1","phase":"end","ms":3361,"event":"PostToolUse","tool_use_id":"<tool-use-1>"}
+{"run":"run1","phase":"start","ms":6198,"event":"PreToolUse","payload":{"session_id":"<session-1>","cwd":"<scratch>/project","prompt_id":"<prompt-1>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture worker dispatch 2","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=cap-002 attemptId=a1 token=<token-2> workerRoot=<scratch>/project\nReply with: worker done","subagent_type":"outline-worker","run_in_background":false,"isolation":"worktree"},"tool_use_id":"<tool-use-2>"}}
+{"run":"run1","phase":"end","ms":8199,"event":"PreToolUse","tool_use_id":"<tool-use-2>"}
+{"run":"run1","phase":"start","ms":8299,"event":"SubagentStart","payload":{"session_id":"<session-1>","cwd":"<scratch>/project/.claude/worktrees/agent-<agent-2>","prompt_id":"<prompt-1>","agent_id":"<agent-2>","agent_type":"outline-worker","hook_event_name":"SubagentStart"}}
+{"run":"run1","phase":"end","ms":8300,"event":"SubagentStart","tool_use_id":null}
+{"run":"run1","phase":"start","ms":9757,"event":"SubagentStop","payload":{"session_id":"<session-1>","cwd":"<scratch>/project/.claude/worktrees/agent-<agent-2>","prompt_id":"<prompt-1>","permission_mode":"default","agent_id":"<agent-2>","agent_type":"outline-worker","effort":{"level":"medium"},"hook_event_name":"SubagentStop","stop_hook_active":false,"last_assistant_message":"worker done","background_tasks":[],"session_crons":[]}}
+{"run":"run1","phase":"end","ms":9758,"event":"SubagentStop","tool_use_id":null}
+{"run":"run1","phase":"start","ms":9864,"event":"PostToolUse","payload":{"session_id":"<session-1>","cwd":"<scratch>/project","prompt_id":"<prompt-1>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PostToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture worker dispatch 2","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=cap-002 attemptId=a1 token=<token-2> workerRoot=<scratch>/project\nReply with: worker done","subagent_type":"outline-worker","run_in_background":false,"isolation":"worktree"},"tool_response":{"keys":["agentId","agentType","canContinueAgent","content","harnessNoteCount","harnessSectionHash","harnessTailCount","prompt","resolvedModel","status","totalDurationMs","totalTokens","totalToolUseCount","usage"],"status":"completed","agentId":"<agent-2>"},"tool_use_id":"<tool-use-2>","duration_ms":1635}}
+{"run":"run1","phase":"end","ms":9865,"event":"PostToolUse","tool_use_id":"<tool-use-2>"}
+{"run":"run2","phase":"start","ms":0,"event":"PreToolUse","payload":{"session_id":"<session-2>","cwd":"<scratch>/project","prompt_id":"<prompt-2>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture dispatch task-cap-001","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=task-cap-001 attemptId=a1 token=<token-3> workerRoot=<scratch>/project","subagent_type":"outline-worker"},"tool_use_id":"<tool-use-3>"}}
+{"run":"run2","phase":"end","ms":2001,"event":"PreToolUse","tool_use_id":"<tool-use-3>"}
+{"run":"run2","phase":"start","ms":2039,"event":"SubagentStart","payload":{"session_id":"<session-2>","cwd":"<scratch>/project","prompt_id":"<prompt-2>","agent_id":"<agent-3>","agent_type":"outline-worker","hook_event_name":"SubagentStart"}}
+{"run":"run2","phase":"start","ms":2040,"event":"PostToolUse","payload":{"session_id":"<session-2>","cwd":"<scratch>/project","prompt_id":"<prompt-2>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PostToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture dispatch task-cap-001","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=task-cap-001 attemptId=a1 token=<token-3> workerRoot=<scratch>/project","subagent_type":"outline-worker"},"tool_response":{"keys":["agentId","canContinueAgent","canReadOutputFile","description","isAsync","outputFile","prompt","resolvedModel","status"],"status":"async_launched","isAsync":true,"agentId":"<agent-3>"},"tool_use_id":"<tool-use-3>","duration_ms":3}}
+{"run":"run2","phase":"end","ms":2041,"event":"SubagentStart","tool_use_id":null}
+{"run":"run2","phase":"end","ms":2042,"event":"PostToolUse","tool_use_id":"<tool-use-3>"}
+{"run":"run2","phase":"start","ms":3490,"event":"SubagentStop","payload":{"session_id":"<session-2>","cwd":"<scratch>/project","prompt_id":"<prompt-2>","permission_mode":"default","agent_id":"<agent-3>","agent_type":"outline-worker","effort":{"level":"medium"},"hook_event_name":"SubagentStop","stop_hook_active":false,"last_assistant_message":"worker done","background_tasks":[{"id":"<agent-3>","type":"subagent","status":"running","description":"Outline capture dispatch task-cap-001","agent_type":"outline-worker"}],"session_crons":[]}}
+{"run":"run2","phase":"end","ms":3492,"event":"SubagentStop","tool_use_id":null}
+{"run":"run2","phase":"start","ms":7846,"event":"PreToolUse","payload":{"session_id":"<session-2>","cwd":"<scratch>/project","prompt_id":"<prompt-3>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture dispatch task-cap-002","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=task-cap-002 attemptId=a1 token=<token-4> workerRoot=<scratch>/project","subagent_type":"outline-worker","run_in_background":false,"isolation":"worktree"},"tool_use_id":"<tool-use-4>"}}
+{"run":"run2","phase":"end","ms":9848,"event":"PreToolUse","tool_use_id":"<tool-use-4>"}
+{"run":"run2","phase":"start","ms":9942,"event":"SubagentStart","payload":{"session_id":"<session-2>","cwd":"<scratch>/project/.claude/worktrees/agent-<agent-4>","prompt_id":"<prompt-3>","agent_id":"<agent-4>","agent_type":"outline-worker","hook_event_name":"SubagentStart"}}
+{"run":"run2","phase":"end","ms":9943,"event":"SubagentStart","tool_use_id":null}
+{"run":"run2","phase":"start","ms":11161,"event":"SubagentStop","payload":{"session_id":"<session-2>","cwd":"<scratch>/project/.claude/worktrees/agent-<agent-4>","prompt_id":"<prompt-3>","permission_mode":"default","agent_id":"<agent-4>","agent_type":"outline-worker","effort":{"level":"medium"},"hook_event_name":"SubagentStop","stop_hook_active":false,"last_assistant_message":"worker done","background_tasks":[],"session_crons":[]}}
+{"run":"run2","phase":"end","ms":11162,"event":"SubagentStop","tool_use_id":null}
+{"run":"run2","phase":"start","ms":11263,"event":"PostToolUse","payload":{"session_id":"<session-2>","cwd":"<scratch>/project","prompt_id":"<prompt-3>","permission_mode":"default","effort":{"level":"medium"},"hook_event_name":"PostToolUse","tool_name":"Agent","tool_input":{"description":"Outline capture dispatch task-cap-002","prompt":"HARNESS_OUTLINE_DISPATCH_V1 taskId=task-cap-002 attemptId=a1 token=<token-4> workerRoot=<scratch>/project","subagent_type":"outline-worker","run_in_background":false,"isolation":"worktree"},"tool_response":{"keys":["agentId","agentType","canContinueAgent","content","harnessNoteCount","harnessSectionHash","harnessTailCount","prompt","resolvedModel","status","totalDurationMs","totalTokens","totalToolUseCount","usage"],"status":"completed","agentId":"<agent-4>"},"tool_use_id":"<tool-use-4>","duration_ms":1388}}
+{"run":"run2","phase":"end","ms":11264,"event":"PostToolUse","tool_use_id":"<tool-use-4>"}

package/ci/mechanism-prb-outline-review.test.js

@@ -188,7 +188,7 @@ function createOutlineFixture(options = {}) {
   const reviewResultPayload = {
     session_id: sessionId, cwd: root, hook_event_name: 'PostToolUse', tool_name: 'Task',
     tool_use_id: 'review-dispatch', tool_input: { command: 'Task' },
-    tool_response: { agentId: reviewerPrincipal, interrupted: false },
+    tool_response: { agentId: reviewerPrincipal, interrupted: false, status: 'completed' },
   };
   const reviewStopPayload = {
     session_id: sessionId, cwd: root, hook_event_name: 'SubagentStop', agent_id: reviewerPrincipal,
@@ -239,7 +239,7 @@ function createOutlineFixture(options = {}) {
 
   const payload = {
     session_id: sessionId, cwd: root, hook_event_name: 'PreToolUse', tool_name: 'Task',
-    tool_use_id: options.toolUseId || 'dispatch-1', tool_input: { prompt: marker },
+    tool_use_id: options.toolUseId || 'dispatch-1', tool_input: { prompt: marker, run_in_background: false },
   };
   if (options.blockSeamStorage) {
     fs.mkdirSync(path.join(attemptDir, 'seams', `${sha(String(payload.tool_use_id))}.json`), { recursive: true });
@@ -281,7 +281,7 @@ function createOutlineFixture(options = {}) {
   if (seam) capture.outlineDispatch = seam;
   const workerStartPayload = {
     session_id: sessionId, cwd: options.workerStartRoot || root, hook_event_name: 'SubagentStart',
-    agent_id: options.workerPrincipal || 'draft-worker', agent_type: 'worker', parent_tool_use_id: capture?.tool_use_id || payload.tool_use_id,
+    agent_id: options.workerPrincipal || 'draft-worker', agent_type: 'worker',
   };
   let workerStart;
   if (options.realHook) {
@@ -295,7 +295,7 @@ function createOutlineFixture(options = {}) {
   const extraCaptures = [];
 
   function dispatchAgain({ toolUseId = capture.tool_use_id, prompt = payload.tool_input.prompt } = {}) {
-    const extraPayload = { ...payload, tool_use_id: toolUseId, tool_input: { prompt } };
+    const extraPayload = { ...payload, tool_use_id: toolUseId, tool_input: { prompt, run_in_background: false } };
     const extra = provider.buildCaptureRecord(extraPayload, 'PreToolUse', root);
     extra.observedIdentity = capture.observedIdentity;
     if (internals.captureOutlineDispatch) {
@@ -309,7 +309,7 @@ function createOutlineFixture(options = {}) {
   }
 
   function finishDraft({ draft = true, nonDescendant = false, finalReview = false, baselineRoot = root,
-    omitWorkerStart = false, omitWorkerResult = false, tamperHandoff = false,
+    omitWorkerStart = false, omitWorkerResult = false, omitWorkerStop = false, tamperHandoff = false,
     providerSessionId = sessionId, providerTaskId = taskId, providerBaseline = { root, commit: baselineCommit },
     runPilot = false, handAuthoredCapture = false, removeSeam = false, mutateAfterFinalReview = false } = {}) {
     if (draft) {
@@ -337,7 +337,11 @@ function createOutlineFixture(options = {}) {
       if (!omitWorkerResult) runHook({
         session_id: sessionId, cwd: root, hook_event_name: 'PostToolUse', tool_name: 'Task',
         tool_use_id: capture.tool_use_id, tool_input: { command: 'Task' },
-        tool_response: { agentId: options.workerPrincipal || 'draft-worker', interrupted: false },
+        tool_response: { agentId: options.workerPrincipal || 'draft-worker', interrupted: false, status: 'completed' },
+      });
+      if (!omitWorkerStop) runHook({
+        session_id: sessionId, cwd: root, hook_event_name: 'SubagentStop',
+        agent_id: options.workerPrincipal || 'draft-worker', agent_type: 'worker',
       });
     }
     if (finalReview) {
@@ -345,7 +349,7 @@ function createOutlineFixture(options = {}) {
       const finalResultPayload = {
         session_id: sessionId, cwd: root, hook_event_name: 'PostToolUse', tool_name: 'Task',
         tool_use_id: 'final-review-dispatch', tool_input: { command: 'Task' },
-        tool_response: { agentId: finalReviewer, interrupted: false },
+        tool_response: { agentId: finalReviewer, interrupted: false, status: 'completed' },
       };
       const finalStopPayload = {
         session_id: sessionId, cwd: root, hook_event_name: 'SubagentStop', agent_id: finalReviewer,
@@ -374,8 +378,10 @@ function createOutlineFixture(options = {}) {
       : [...reviewCaptures, capture, ...extraCaptures, ...(!omitWorkerStart ? [workerStart] : []), ...(!omitWorkerResult ? [provider.buildCaptureRecord({
         session_id: sessionId, cwd: root, hook_event_name: 'PostToolUse', tool_name: 'Task',
         tool_use_id: capture.tool_use_id, tool_input: { command: 'Task' },
-        tool_response: { agentId: options.workerPrincipal || 'draft-worker', interrupted: false },
-      }, 'PostToolUse', root)] : [])];
+        tool_response: { agentId: options.workerPrincipal || 'draft-worker', interrupted: false, status: 'completed' },
+      }, 'PostToolUse', root)] : []), ...(!omitWorkerStop ? [provider.buildCaptureRecord({
+        session_id: sessionId, cwd: root, hook_event_name: 'SubagentStop', agent_id: options.workerPrincipal || 'draft-worker', agent_type: 'worker',
+      }, 'SubagentStop', root)] : [])];
     const qualification = { source: 'fake-test-fixture', faked: true, toolUseIdPopulated: true,
       agentIdPopulated: true, outlineDispatchCaptureVerified: true };
     if (removeSeam && capture.outlineDispatch?.seamRef) {
@@ -805,14 +811,14 @@ test('canonical root identity accepts an alias across marker, handoff, lease, an
   } finally { fixture.cleanup(); }
 });
 
-test('one-use token and tool correlation allow only an identical same-ID duplicate', () => {
+test('one-use token deduplicates identical seams but replayed tool-use records stay unresolved', () => {
   assert.strictEqual(typeof internals.captureOutlineDispatch, 'function', 'missing token-consuming seam');
   const duplicate = createOutlineFixture();
   try {
     const same = duplicate.dispatchAgain();
     assert.strictEqual(same.outlineDispatch.state, 'accepted', JSON.stringify(same.outlineDispatch));
     assert.strictEqual(same.outlineDispatch.duplicate, true);
-    assert.strictEqual(duplicate.finishDraft().result.status, 'accepted', 'same ID and same input deduplicate to one seam');
+    assert.notStrictEqual(duplicate.finishDraft().result.status, 'accepted', 'a replayed host PreToolUse record is not a unique dispatch anchor');
   } finally { duplicate.cleanup(); }
 
   for (const [name, replay] of [
@@ -949,24 +955,202 @@ test('baseline integrity, callback order, delayed result, stash/restore, and uno
   } finally { shellWriter.cleanup(); }
 });
 
-test('live qualification requires same-session dispatch, worker-start root, and result correlation', () => {
+const outlineMappingV2 = {
+  version: 'claude-outline-dispatch-mapping/2',
+  promptField: 'tool_input.prompt',
+  dispatchKey: 'session_id+tool_use_id',
+  runInBackgroundField: 'tool_input.run_in_background',
+  isolationPresenceField: 'tool_input.isolation',
+  resultAgentIdField: 'tool_response.agentId',
+  resultStatusField: 'tool_response.status',
+  workerStartEvent: 'SubagentStart',
+  workerStopEvent: 'SubagentStop',
+  workerIdentity: 'session_id+agent_id',
+  workerRootField: 'cwd',
+};
+
+function qualificationDispatch({ id = 'dispatch-1', promptId = 'shared-prompt', background = false, hasBackground = true,
+  isolation, hasIsolation = false, session = 'coordinator' } = {}) {
+  const toolInput = { prompt: dispatchLine, ...(hasBackground ? { run_in_background: background } : {}) };
+  if (hasIsolation) toolInput.isolation = isolation;
+  return { event: 'PreToolUse', tool_name: 'Task', tool_use_id: id, session_id: session, prompt_id: promptId, tool_input: toolInput };
+}
+
+function qualificationStart(agentId = 'worker', { session = 'coordinator', cwd = '/tmp/prb-worker', id } = {}) {
+  return { event: 'SubagentStart', ...(id ? { tool_use_id: id } : {}), agent_id: agentId, session_id: session, cwd };
+}
+
+function qualificationStop(agentId = 'worker', { session = 'coordinator', cwd = '/tmp/prb-worker' } = {}) {
+  return { event: 'SubagentStop', agent_id: agentId, session_id: session, cwd };
+}
+
+function qualificationResult(id = 'dispatch-1', agentId = 'worker', status = 'completed', { session = 'coordinator', legacyAgentId } = {}) {
+  const toolResponse = { agentId };
+  if (status !== null) toolResponse.status = status;
+  return { event: 'PostToolUse', tool_name: 'Task', tool_use_id: id, session_id: session,
+    ...(legacyAgentId !== undefined ? { agent_id: legacyAgentId } : {}), tool_response: toolResponse };
+}
+
+function outlineCorrelation(records, anchor = records.find(item => item.event === 'PreToolUse')) {
+  return internals.correlateOutlineDispatch(records, anchor, '/tmp/prb-worker');
+}
+
+test('live qualification accepts the versioned Claude 2.1.312 dispatch/result/worker field contract', () => {
   assert.strictEqual(typeof internals.outlineCaptureMappingValid, 'function', 'missing qualification correlation validator');
-  const mapping = { promptField: 'tool_input.prompt', coordinatorPrincipalField: 'session_id', synchronousPreToolUse: true,
-    workerStartDispatchField: 'parent_tool_use_id', workerStartRootField: 'cwd', taskResultDispatchField: 'tool_use_id' };
-  const records = [
-    { event: 'PreToolUse', tool_name: 'Task', tool_use_id: 'dispatch-1', session_id: 'coordinator',
-      tool_input: { prompt: 'HARNESS_OUTLINE_DISPATCH_V1 taskId=task-prb attemptId=attempt-1 token=token-1 workerRoot=/tmp/worker' } },
-    { event: 'SubagentStart', parent_tool_use_id: 'dispatch-1', agent_id: 'worker', session_id: 'coordinator', cwd: '/tmp/worker' },
-    { event: 'PostToolUse', tool_name: 'Task', tool_use_id: 'dispatch-1', agent_id: 'worker', session_id: 'coordinator', interrupted: false },
-  ];
-  assert.strictEqual(internals.outlineCaptureMappingValid(mapping, records), true);
+  assert.deepStrictEqual(internals.OUTLINE_CAPTURE_MAPPING, outlineMappingV2, 'mapping field contract must be explicitly versioned');
+  const pre = qualificationDispatch();
+  const records = [pre, qualificationStart(), qualificationResult(), qualificationStop()];
+  assert.strictEqual(internals.outlineCaptureMappingValid(outlineMappingV2, records), true,
+    'PreToolUse → completed tool_response.agentId → unique Start/Stop is the 2.1.312 host shape');
   const crossSession = records.map(item => ({ ...item }));
   crossSession[2].session_id = 'different-session';
-  assert.strictEqual(internals.outlineCaptureMappingValid(mapping, crossSession), false,
+  assert.strictEqual(internals.outlineCaptureMappingValid(outlineMappingV2, crossSession), false,
     'matching tool IDs across different coordinator sessions do not qualify the live mapping');
   const wrongRoot = records.map(item => ({ ...item }));
   wrongRoot[1].cwd = '/tmp/other-worker';
-  assert.strictEqual(internals.outlineCaptureMappingValid(mapping, wrongRoot), false);
+  assert.strictEqual(internals.outlineCaptureMappingValid(outlineMappingV2, wrongRoot), false);
+});
+
+test('capture record retains only explicit outline result and dispatch fields', () => {
+  const pre = provider.buildCaptureRecord({ session_id: 'coordinator', tool_name: 'Task', tool_use_id: 'explicit',
+    tool_input: { prompt: dispatchLine, run_in_background: false } }, 'PreToolUse', '/tmp/prb-worker');
+  assert.strictEqual(pre.run_in_background, false);
+  assert.strictEqual(pre.isolationSet, false);
+  const omitted = provider.buildCaptureRecord({ session_id: 'coordinator', tool_name: 'Agent', tool_use_id: 'omitted',
+    tool_input: { prompt: dispatchLine } }, 'PreToolUse', '/tmp/prb-worker');
+  assert.strictEqual(Object.hasOwn(omitted, 'run_in_background'), false, 'missing background input stays absent');
+  const isolated = provider.buildCaptureRecord({ session_id: 'coordinator', tool_name: 'Agent', tool_use_id: 'isolated',
+    tool_input: { prompt: dispatchLine, run_in_background: false, isolation: null } }, 'PreToolUse', '/tmp/prb-worker');
+  assert.strictEqual(isolated.isolationSet, true, 'present null isolation is not normalized to absence');
+  const result = provider.buildCaptureRecord({ session_id: 'coordinator', tool_name: 'Task', tool_use_id: 'result',
+    tool_response: { agentId: 'worker', status: 'completed' } }, 'PostToolUse', '/tmp/prb-worker');
+  assert.strictEqual(result.tool_response_status, 'completed');
+  const noStatus = provider.buildCaptureRecord({ session_id: 'coordinator', tool_name: 'Task', tool_use_id: 'no-status',
+    tool_response: { agentId: 'worker' } }, 'PostToolUse', '/tmp/prb-worker');
+  assert.strictEqual(Object.hasOwn(noStatus, 'tool_response_status'), false, 'missing result status stays absent');
+});
+
+for (const [name, make, reason] of [
+  ['concurrent same-session dispatches cannot reuse one worker result', () => {
+    const one = qualificationDispatch({ id: 'dispatch-1' });
+    const two = qualificationDispatch({ id: 'dispatch-2' });
+    return { records: [one, two, qualificationStart(), qualificationResult('dispatch-1'),
+      qualificationResult('dispatch-2'), qualificationStop()], anchor: one };
+  }, 'outline-worker-agent-id-replayed'],
+  ['a shared prompt_id cannot replace the target tool_use_id', () => {
+    const one = qualificationDispatch({ id: 'dispatch-1' });
+    const two = qualificationDispatch({ id: 'dispatch-2' });
+    return { records: [one, two, qualificationStart('worker-2'), qualificationResult('dispatch-2', 'worker-2'),
+      qualificationStop('worker-2')], anchor: one };
+  }, 'outline-worker-result-missing-or-ambiguous'],
+  ['reordered Stop-before-Start is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStop(), qualificationStart(), qualificationResult()], anchor: pre };
+  }, 'outline-worker-stop-before-start'],
+  ['Start-before-Pre is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [qualificationStart(), pre, qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-worker-start-before-dispatch'],
+  ['missing result is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-missing-or-ambiguous'],
+  ['duplicate result is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult(), qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-missing-or-ambiguous'],
+  ['duplicate worker start is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationStart(), qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-worker-start-missing-or-ambiguous'],
+  ['duplicate worker stop is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult(), qualificationStop(), qualificationStop()], anchor: pre };
+  }, 'outline-worker-stop-missing-or-ambiguous'],
+  ['conflicting top-level and observed agentId is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult('dispatch-1', 'worker', 'completed', { legacyAgentId: 'other-worker' }),
+      qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-agent-id-conflict'],
+  ['async_launched is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult('dispatch-1', 'worker', 'async_launched'), qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-async'],
+  ['absent result status is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult('dispatch-1', 'worker', null), qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-status-missing'],
+  ['failed result status is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult('dispatch-1', 'worker', 'failed'), qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-failed'],
+  ['cancelled result status is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult('dispatch-1', 'worker', 'cancelled'), qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-failed'],
+  ['missing Stop is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult()], anchor: pre };
+  }, 'outline-worker-stop-missing-or-ambiguous'],
+  ['worker-root mismatch is unresolved', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart('worker', { cwd: '/tmp/other-worker' }), qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-worker-root-mismatch'],
+  ['worktree isolation is unresolved', () => {
+    const pre = qualificationDispatch({ hasIsolation: true, isolation: 'worktree' });
+    return { records: [pre, qualificationStart(), qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-dispatch-isolation-unsupported'],
+  ['present null isolation is unresolved', () => {
+    const pre = qualificationDispatch({ hasIsolation: true, isolation: null });
+    return { records: [pre, qualificationStart(), qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-dispatch-isolation-unsupported'],
+  ['omitted run_in_background is unresolved', () => {
+    const pre = qualificationDispatch({ hasBackground: false });
+    return { records: [pre, qualificationStart(), qualificationResult(), qualificationStop()], anchor: pre };
+  }, 'outline-dispatch-background-unobserved'],
+  ['an Agent PostToolUseFailure invalidates a completed result', () => {
+    const pre = qualificationDispatch();
+    return { records: [pre, qualificationStart(), qualificationResult(),
+      { event: 'PostToolUseFailure', tool_name: 'Task', tool_use_id: 'dispatch-1', session_id: 'coordinator' }, qualificationStop()], anchor: pre };
+  }, 'outline-worker-result-failed'],
+]) {
+  test(`outline correlation rejects ${name}`, () => {
+    const { records, anchor } = make();
+    const result = outlineCorrelation(records, anchor);
+    assert.deepStrictEqual(result, { state: 'unresolved', reason });
+  });
+}
+
+test('runtime resolution accepts Stop after the completed result through the synthetic qualification seam', () => {
+  const fixture = createOutlineFixture();
+  try {
+    const completed = fixture.finishDraft();
+    assert.strictEqual(completed.result.status, 'accepted', JSON.stringify(completed.result));
+    const workerResultIndex = completed.captures.findIndex(item => item.event === 'PostToolUse'
+      && item.tool_use_id === fixture.capture.tool_use_id);
+    const workerStopIndex = completed.captures.findIndex(item => item.event === 'SubagentStop'
+      && item.agent_id === 'draft-worker');
+    assert.ok(workerResultIndex >= 0 && workerStopIndex > workerResultIndex,
+      'the 2.1.312 field shape allows result before Stop; no Stop-before-result condition is implied');
+  } finally { fixture.cleanup(); }
+});
+
+test('production export without an outline mapping keeps outline-live-gate-unmet', () => {
+  const fixture = createOutlineFixture();
+  try {
+    const completed = fixture.finishDraft();
+    const production = provider.createClaudeOriginProvider({
+      hostId: 'claude-code', sessionId: fixture.sessionId, workspaceRoot: fixture.root,
+      workflowId: fixture.workflowId, workflowRevision: fixture.workflowRevision, taskId: fixture.taskId,
+      principals: { author: fixture.sessionId, executors: [] },
+      baseline: { root: fixture.root, commit: fixture.baselineCommit }, captures: completed.captures,
+      sessionDir: fixture.sessionDir, taskBinding: fixture.taskBinding,
+      outlineFixture: { expectedPin: fixture.expectedPin },
+    });
+    const result = production.resolveEvent({ reference: `${fixture.capture.ref}#outline-confirmation`, identity: completed.identity });
+    assert.strictEqual(result.status, 'unavailable');
+    assert.ok(result.diagnostics.some(item => item.code === 'outline-live-gate-unmet'), JSON.stringify(result));
+  } finally { fixture.cleanup(); }
 });
 
 test('original B and immutable attempt chain survive reconfirmation; stale attempts/tokens never cover new scope', () => {

package/docs/doc-workflow-reconciliation.md

@@ -966,7 +966,7 @@ fields through sanitization; a transcript alone, synthetic payload or screenshot
 this hook-capture evidence.
 
 The origin provider's qualification check MUST resolve that retained evidence reference (or its
-verified export), validate captured host/event kinds, nonempty tool/subagent IDs, parent/session
+verified export), validate captured host/event kinds, nonempty tool/subagent IDs, session/tool-use
 correlation and recorded digests, and match the supported host/capture implementation being used.
 Missing, malformed, mismatched or unresolvable qualification evidence returns unavailable and no
 credit. Do not enable qualification from a caller `trusted` flag, environment toggle, populated
@@ -976,6 +976,22 @@ host capture path exposed the fields; every later event still needs current orig
 A retained capture does not authenticate arbitrary local journals or imply E1 GO. Record the live
 gate as unmet until this check actually passes; do not label the docs or deterministic tests as live.
 
+For PR-B outline dispatches, the versioned mapping contract is
+`claude-outline-dispatch-mapping/2`. A Task/Agent `PreToolUse` anchor requires `session_id` plus
+`tool_use_id`, one valid marker in `tool_input.prompt`, explicit
+`tool_input.run_in_background === false`, and no `tool_input.isolation` property. Exactly one
+Task/Agent `PostToolUse` with that key must report `tool_response.status === 'completed'` and a
+nonempty `tool_response.agentId`; that observed ID must match exactly one `SubagentStart` and one
+`SubagentStop` with the same session. Journal order requires PreToolUse before SubagentStart before
+SubagentStop; the completed PostToolUse may appear before or after SubagentStop. The Start and Stop
+must each report a canonical `cwd` equal to the marker's worker root. `prompt_id` is shared across
+dispatches, and neither `parent_tool_use_id` nor `interrupted` is an outline dispatch key or
+completion signal. Captured records retain `tool_response.status` as `tool_response_status`, the
+explicit `run_in_background` value, and whether `isolation` was present; absent status or background
+fields remain absent. Async launches and ambiguous or contradictory matches stay unresolved.
+The retained qualification export still has no outline mapping, so production remains
+`outline-live-gate-unmet` and this contract does not enable positive credit.
+
 ### Workflow credit, review progression and freshness
 
 Every ON + supported credit attempt MUST invoke the following current chain, with the same
@@ -1236,10 +1252,10 @@ flowchart LR
 | B and task | Keep the workflow-start B commit/root/tree and ordered requirement IDs for every attempt. Config scope must still match B. An attempt cannot reset B to O. |
 | Inventory | The coordinator supplies exact bytes and `inventory-pin.json` outside the candidate tree. The pinned source is `report-inv.md`, SHA-256 `2741bd4514d2cd68f57d93a2b3ce94cbe597ca62d30e26f0ca58e882df5b03c6`, run `e1-inv-1`, input SHA `0ef0541c6cae550e8269ba712e03797e0e987dfb`, approval `#325` comment `6436207729`, decision 1. The provider rehashes the bytes and compares every pin field before resolving one row and domain. Missing, stale, duplicate, ambiguous, wrong-target or unavailable evidence is unresolved with no fallback. Synthetic test pins prove parser/mechanism binding only. |
 | O and review | O is bound to its commit, tree, target blobs and stored-byte digests. Its `proposed` ADR frontmatter cites one `Inventory row: <id>`, target and domain, and contains no completed Decision text. A host-captured `SubagentStop` review must approve those exact O bytes and the pinned inventory, with a distinct host `agent_id` and correlated Agent/Task result. |
-| Handoff and dispatch | One immutable attempt handoff binds B, O, scope, inventory, accepted review, coordinator principal, lease and one-use token. Agent/Task dispatch accepts exactly one `HARNESS_OUTLINE_DISPATCH_V1` block in `tool_input.prompt`, whose token must equal the handoff token; it does not search free-form text or use another field or cwd as a fallback. Before worker start, PreToolUse verifies the handoff, review, pin, exclusive lease, canonical root, HEAD/tree at O and clean index/worktree including untracked files; it creates a write-once handoff-digest seal, stores validation digests/reasons, then consumes the token by exclusive creation. Every predecessor seal, seam and token remains bound to the original handoff bytes, so an overwritten predecessor invalidates the chain. |
-| Worker and D | Worker start must correlate to the dispatch token/tool ID, principal and declared root; the eventual Task/Agent result must name that same worker. D is checked against the current candidate separately from O. O must be a strict ancestor of D. A squash may retain the cycle only when a coordinator correspondence record proves identical target blobs between retained pre-merge D and the merged tree; changed bytes need fresh final quality review. |
+| Handoff and dispatch | One immutable attempt handoff binds B, O, scope, inventory, accepted review, coordinator principal, lease and one-use token. Agent/Task dispatch accepts exactly one `HARNESS_OUTLINE_DISPATCH_V1` block in `tool_input.prompt`, whose token must equal the handoff token; it does not search free-form text or use another field or cwd as a fallback. The outline anchor also requires explicit `run_in_background === false` and absence of any `isolation` key, including null or empty values. Before worker start, PreToolUse verifies the handoff, review, pin, exclusive lease, canonical root, HEAD/tree at O and clean index/worktree including untracked files; it creates a write-once handoff-digest seal, stores validation digests/reasons, then consumes the token by exclusive creation. Every predecessor seal, seam and token remains bound to the original handoff bytes, so an overwritten predecessor invalidates the chain. |
+| Worker and D | The dispatch key is `(session_id, tool_use_id)`. Exactly one matching Task/Agent result must carry `tool_response.status === 'completed'`; its observed `tool_response.agentId` must map to exactly one `SubagentStart` and one `SubagentStop` with the same `session_id` and `agent_id`. Require PreToolUse < SubagentStart < SubagentStop in journal order, but do not order the completed result against Stop. Both worker events need exact canonical `cwd === workerRoot`. `prompt_id` and `parent_tool_use_id` are not correlation keys; `interrupted` is not completion proof. Async launches, failures, cancellation, missing/duplicate events, replayed IDs, worktree isolation and root mismatch stay unresolved. D is checked against the current candidate separately from O. O must be a strict ancestor of D. A squash may retain the cycle only when a coordinator correspondence record proves identical target blobs between retained pre-merge D and the merged tree; changed bytes need fresh final quality review. |
 | Checker outcome | `outline-confirmation` has its own pass/unresolved lane. Generic command success and waivers never satisfy it. No D is incomplete/unresolved. Its result is separate from the aggregate result over every MUST derived from original B→D; an outline pass never waives lint, conflict, quality review, requirement-sync or other MUSTs. |
 
-Capture and validation failures stay fail-open to host tools and withhold evidence credit. Unclassified shell commands and writes outside the correlated worker/root remain unresolved. Retries use a fresh attempt, token, clean worktree and immutable handoff; only one non-superseded leaf is current. Exact same-tool-ID/input duplicates may resolve to one seam; changed input or token reuse is unresolved. OpenCode and Codex remain unsupported for positive outline credit.
+Capture and validation failures stay fail-open to host tools and withhold evidence credit. Unclassified shell commands and writes outside the correlated worker/root remain unresolved. Retries use a fresh attempt, token, clean worktree and immutable handoff; only one non-superseded leaf is current. An identical same-tool-ID/input callback may reuse its stored seam, but repeated PreToolUse records remain ambiguous for evidence credit; changed input or token reuse is unresolved. OpenCode and Codex remain unsupported for positive outline credit.
 
-The current retained Claude qualification does not establish the frozen prompt field, coordinator principal, synchronous PreToolUse boundary or worker-root mapping. The outline provider therefore grants no positive live-host credit until a retained Claude capture validates those mappings. Deterministic fixtures exercise the real hook/provider/adapter/checker/pilot path with a synthetic inventory pin; they are mechanism evidence, not live-host behavior or E1 readiness.
+The current retained Claude qualification does not establish the versioned `claude-outline-dispatch-mapping/2` contract. The outline provider therefore grants no positive live-host credit until a retained Claude capture validates the prompt, coordinator, result status/agent ID, explicit non-background boundary, isolation absence and exact worker-root mapping. Deterministic fixtures exercise the real hook/provider/adapter/checker/pilot path with a synthetic inventory pin; they are mechanism evidence, not live-host behavior or E1 readiness.

package/hooks/scripts/lib/doc-reconciliation-provider.js

@@ -52,6 +52,19 @@ const DOC_CHECK_BOOLEAN_FLAGS = new Set(['--conflict-assessment']);
 const DOC_CHECK_SCHEMA = 'harness.doc-check.check.v1';
 const DOC_CHECK_CONFLICT_SCHEMA = 'harness.doc-check.conflict-assessment.v1';
 const OUTLINE_DISPATCH_SCHEMA = 'harness.outline-dispatch.v1';
+const OUTLINE_CAPTURE_MAPPING = Object.freeze({
+  version: 'claude-outline-dispatch-mapping/2',
+  promptField: 'tool_input.prompt',
+  dispatchKey: 'session_id+tool_use_id',
+  runInBackgroundField: 'tool_input.run_in_background',
+  isolationPresenceField: 'tool_input.isolation',
+  resultAgentIdField: 'tool_response.agentId',
+  resultStatusField: 'tool_response.status',
+  workerStartEvent: 'SubagentStart',
+  workerStopEvent: 'SubagentStop',
+  workerIdentity: 'session_id+agent_id',
+  workerRootField: 'cwd',
+});
 const OUTLINE_SEAM_SCHEMA = 'harness.outline-dispatch-seam.v1';
 const OUTLINE_HANDOFF_SCHEMA = 'harness.outline-handoff.v1';
 const OUTLINE_LEASE_SCHEMA = 'harness.outline-writer-lease.v1';
@@ -1163,28 +1176,125 @@ function validateOutlineCaptureQualification(input, expectedHost = HOST_ID) {
 }
 
 function outlineCaptureMappingValid(mapping, records) {
-  if (!recordOf(mapping) || mapping.promptField !== 'tool_input.prompt'
-    || mapping.coordinatorPrincipalField !== 'session_id' || mapping.synchronousPreToolUse !== true
-    || mapping.workerStartDispatchField !== 'parent_tool_use_id' || mapping.workerStartRootField !== 'cwd'
-    || mapping.taskResultDispatchField !== 'tool_use_id' || !Array.isArray(records)) return false;
+  if (!recordOf(mapping) || captureJson(mapping) !== captureJson(OUTLINE_CAPTURE_MAPPING) || !Array.isArray(records)) return false;
   const pres = records.filter(item => recordOf(item) && item.event === 'PreToolUse'
     && ['Task', 'Agent'].includes(item.tool_name) && recordOf(item.tool_input)
     && typeof item.tool_input.prompt === 'string' && textOf(item.session_id) && textOf(item.tool_use_id));
-  return pres.some(pre => {
+  return pres.some(pre => correlateOutlineDispatch(records, pre).state === 'accepted');
+}
+
+function outlineCorrelationFailure(reason) { return { state: 'unresolved', reason }; }
+
+function outlineDispatchKeyMatches(item, pre) {
+  return recordOf(item) && item.session_id === pre.session_id && item.tool_use_id === pre.tool_use_id;
+}
+
+function outlineResultAgentId(result) {
+  if (recordOf(result.tool_response)) {
+    const observed = result.tool_response.agentId;
+    if (textOf(result.agent_id) && textOf(observed) && result.agent_id !== observed) {
+      return { state: 'unresolved', reason: 'outline-worker-result-agent-id-conflict' };
+    }
+    return { state: textOf(observed) ? 'accepted' : 'unresolved', agentId: observed,
+      ...(textOf(observed) ? {} : { reason: 'outline-worker-result-agent-id-missing' }) };
+  }
+  return textOf(result.agent_id)
+    ? { state: 'accepted', agentId: result.agent_id }
+    : { state: 'unresolved', reason: 'outline-worker-result-agent-id-missing' };
+}
+
+function outlineResultStatus(result) {
+  if (recordOf(result.tool_response)) return Object.prototype.hasOwnProperty.call(result.tool_response, 'status')
+    ? { present: true, value: result.tool_response.status } : { present: false };
+  return Object.prototype.hasOwnProperty.call(result, 'tool_response_status')
+    ? { present: true, value: result.tool_response_status } : { present: false };
+}
+
+function correlateOutlineDispatch(records, anchor, expectedWorkerRoot) {
+  if (!Array.isArray(records)) return outlineCorrelationFailure('outline-capture-records-missing');
+  if (!recordOf(anchor) || anchor.event !== 'PreToolUse' || !['Task', 'Agent'].includes(anchor.tool_name)) {
+    return outlineCorrelationFailure('outline-dispatch-anchor-invalid');
+  }
+  if (!textOf(anchor.session_id) || !textOf(anchor.tool_use_id)) return outlineCorrelationFailure('outline-dispatch-key-missing');
+  const pres = records.filter(item => recordOf(item) && item.event === 'PreToolUse'
+    && ['Task', 'Agent'].includes(item.tool_name) && outlineDispatchKeyMatches(item, anchor));
+  if (pres.length !== 1) return outlineCorrelationFailure('outline-dispatch-anchor-missing-or-ambiguous');
+  const pre = pres[0];
+  let workerRoot = expectedWorkerRoot;
+  if (recordOf(pre.tool_input)) {
     const marker = parseOutlineDispatchPrompt(pre.tool_input.prompt);
-    if (!marker) return false;
-    const starts = records.filter(item => recordOf(item) && item.event === 'SubagentStart'
-      && item.parent_tool_use_id === pre.tool_use_id && item.session_id === pre.session_id
-      && textOf(item.cwd) && textOf(marker.workerRoot) && key(item.cwd) === key(marker.workerRoot)
-      && textOf(item.agent_id));
-    if (starts.length !== 1) return false;
-    const worker = starts[0];
-    const results = records.filter(item => recordOf(item) && item.event === 'PostToolUse'
-      && ['Task', 'Agent'].includes(item.tool_name) && item.tool_use_id === pre.tool_use_id
-      && item.session_id === pre.session_id && item.agent_id === worker.agent_id
-      && item.interrupted === false);
-    return results.length === 1;
-  });
+    if (!marker) return outlineCorrelationFailure('outline-dispatch-marker-invalid');
+    if (workerRoot !== undefined && !samePathKey(marker.workerRoot, workerRoot)) {
+      return outlineCorrelationFailure('outline-dispatch-worker-root-mismatch');
+    }
+    workerRoot = marker.workerRoot;
+    if (!Object.prototype.hasOwnProperty.call(pre.tool_input, 'run_in_background')) {
+      return outlineCorrelationFailure('outline-dispatch-background-unobserved');
+    }
+    if (pre.tool_input.run_in_background !== false) {
+      return outlineCorrelationFailure('outline-dispatch-background-enabled');
+    }
+    if (Object.prototype.hasOwnProperty.call(pre.tool_input, 'isolation')) {
+      return outlineCorrelationFailure('outline-dispatch-isolation-unsupported');
+    }
+  } else {
+    if (!recordOf(pre.outlineDispatch) || pre.outlineDispatch.state !== 'accepted' || !textOf(pre.outlineDispatch.workerRoot)) {
+      return outlineCorrelationFailure('outline-dispatch-marker-unobserved');
+    }
+    if (workerRoot !== undefined && !samePathKey(pre.outlineDispatch.workerRoot, workerRoot)) {
+      return outlineCorrelationFailure('outline-dispatch-worker-root-mismatch');
+    }
+    workerRoot = pre.outlineDispatch.workerRoot;
+    if (!Object.prototype.hasOwnProperty.call(pre, 'run_in_background')) {
+      return outlineCorrelationFailure('outline-dispatch-background-unobserved');
+    }
+    if (pre.run_in_background !== false) return outlineCorrelationFailure('outline-dispatch-background-enabled');
+    if (!Object.prototype.hasOwnProperty.call(pre, 'isolationSet')) {
+      return outlineCorrelationFailure('outline-dispatch-isolation-unobserved');
+    }
+    if (pre.isolationSet !== false) return outlineCorrelationFailure('outline-dispatch-isolation-unsupported');
+  }
+  if (!textOf(workerRoot) || !path.isAbsolute(workerRoot)) return outlineCorrelationFailure('outline-dispatch-worker-root-unobserved');
+
+  const failures = records.filter(item => outlineDispatchKeyMatches(item, pre) && item.event === 'PostToolUseFailure');
+  if (failures.length) return outlineCorrelationFailure('outline-worker-result-failed');
+  const results = records.filter(item => outlineDispatchKeyMatches(item, pre) && item.event === 'PostToolUse'
+    && ['Task', 'Agent'].includes(item.tool_name));
+  if (results.length !== 1) return outlineCorrelationFailure('outline-worker-result-missing-or-ambiguous');
+  const result = results[0];
+  const status = outlineResultStatus(result);
+  if (!status.present || status.value === undefined) return outlineCorrelationFailure('outline-worker-result-status-missing');
+  if (status.value === 'async_launched') return outlineCorrelationFailure('outline-worker-result-async');
+  if (status.value !== 'completed') return outlineCorrelationFailure('outline-worker-result-failed');
+  const observedAgent = outlineResultAgentId(result);
+  if (observedAgent.state !== 'accepted') return outlineCorrelationFailure(observedAgent.reason);
+  const agentId = observedAgent.agentId;
+  const sameAgentResults = records.filter(item => recordOf(item) && item.event === 'PostToolUse'
+    && ['Task', 'Agent'].includes(item.tool_name) && item.session_id === pre.session_id
+    && outlineResultAgentId(item).state === 'accepted' && outlineResultAgentId(item).agentId === agentId);
+  if (sameAgentResults.length !== 1) return outlineCorrelationFailure('outline-worker-agent-id-replayed');
+
+  const starts = records.filter(item => recordOf(item) && item.event === 'SubagentStart'
+    && item.session_id === pre.session_id && item.agent_id === agentId);
+  if (starts.length !== 1) return outlineCorrelationFailure('outline-worker-start-missing-or-ambiguous');
+  const stops = records.filter(item => recordOf(item) && item.event === 'SubagentStop'
+    && item.session_id === pre.session_id && item.agent_id === agentId);
+  if (stops.length !== 1) return outlineCorrelationFailure('outline-worker-stop-missing-or-ambiguous');
+  const start = starts[0];
+  const stop = stops[0];
+  const preIndex = records.indexOf(pre);
+  const startIndex = records.indexOf(start);
+  const stopIndex = records.indexOf(stop);
+  if (preIndex < 0 || startIndex < 0 || stopIndex < 0) return outlineCorrelationFailure('outline-worker-journal-position-unavailable');
+  if (startIndex <= preIndex) return outlineCorrelationFailure('outline-worker-start-before-dispatch');
+  if (stopIndex <= startIndex) return outlineCorrelationFailure('outline-worker-stop-before-start');
+  for (const workerEvent of [start, stop]) {
+    if (!textOf(workerEvent.cwd) || !path.isAbsolute(workerEvent.cwd)) {
+      return outlineCorrelationFailure('outline-worker-root-unobserved');
+    }
+    if (!samePathKey(workerEvent.cwd, workerRoot)) return outlineCorrelationFailure('outline-worker-root-mismatch');
+  }
+  return { state: 'accepted', pre, result, start, stop, workerRoot, agentId };
 }
 
 function verifyOutlineMergeCorrespondence({ root, outlineCommit, draftCommit, mergedCommit, targetPaths, record } = {}) {
@@ -1335,20 +1445,10 @@ function resolveOutlineEvidence({ safeInput, capture, captures, request, originR
       || review.reviewDigest !== seam.reviewDigest || review.reviewerPrincipal !== seam.reviewerPrincipal) {
       return fail(review.reason || 'outline-review-changed-after-dispatch');
     }
-    const startEvents = (Array.isArray(captures) ? captures : []).filter(item => recordOf(item)
-      && item.event === 'SubagentStart' && item.parent_tool_use_id === cap.tool_use_id && item.session_id === cap.session_id);
-    if (startEvents.length !== 1 || !textOf(startEvents[0].agent_id)) return fail('outline-worker-start-missing-or-ambiguous');
-    const worker = startEvents[0];
-    let workerRoot;
-    try { workerRoot = canonicalOutlineRoot(worker.cwd); }
-    catch { return fail('outline-worker-root-unobserved'); }
-    if (!sameCanonicalPath(workerRoot, seam.workerRoot)) return fail('outline-worker-root-mismatch');
-    const results = (Array.isArray(captures) ? captures : []).filter(item => recordOf(item)
-      && item.event === 'PostToolUse' && ['Task', 'Agent'].includes(item.tool_name)
-      && item.tool_use_id === cap.tool_use_id && item.session_id === cap.session_id);
-    if (results.length !== 1 || results[0].agent_id !== worker.agent_id || results[0].interrupted !== false) {
-      return fail('outline-worker-result-missing-or-mismatched');
-    }
+    const correlation = correlateOutlineDispatch(captures, cap, seam.workerRoot);
+    if (correlation.state !== 'accepted') return fail(correlation.reason);
+    const worker = correlation.start;
+    const workerRoot = correlation.workerRoot;
     if (review.reviewerPrincipal === worker.agent_id) return fail('outline-reviewer-is-draft-worker');
     const principals = { author: safeInput.sessionId, executors: journalExecutors(captures, safeInput.sessionId) };
     if (!reviewRecordIndependent(review.review, captures, principals)) return fail('outline-review-not-independent');
@@ -1949,6 +2049,8 @@ function buildCaptureRecord(payload, eventName, workspaceRoot) {
   if (event === 'PreToolUse' && PRE_CAPTURE_TOOLS.indexOf(payload.tool_name) === -1) return null;
   const toolInput = recordOf(payload.tool_input) ? payload.tool_input : {};
   const toolResponse = payload.tool_response;
+  const outlinePre = event === 'PreToolUse' && ['Task', 'Agent'].includes(payload.tool_name);
+  const outlineResult = event === 'PostToolUse' && ['Task', 'Agent'].includes(payload.tool_name);
   // Demonstrated alias mapping (doc: "Host result aliases such as agentId
   // require a demonstrated capture mapping to the same subagent identity"):
   // the PostToolUse Task/Agent result surface reports the subagent id as
@@ -1961,17 +2063,28 @@ function buildCaptureRecord(payload, eventName, workspaceRoot) {
     ref: captureId,
     event,
     command: typeof toolInput.command === 'string' ? toolInput.command : '',
-    cwd: typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : (typeof workspaceRoot === 'string' && workspaceRoot ? workspaceRoot : ''),
     tool_use_id: typeof payload.tool_use_id === 'string' ? payload.tool_use_id : '',
     session_id: payload.session_id === undefined && payload.sessionId === undefined ? '' : String(payload.session_id !== undefined ? payload.session_id : payload.sessionId),
     responseDigest: captureDigest(toolResponse),
     responseRef: `host-payload/${event}/${captureId}`,
   };
+  if (typeof payload.cwd === 'string' && payload.cwd) record.cwd = payload.cwd;
+  else if (!['SubagentStart', 'SubagentStop'].includes(event) && typeof workspaceRoot === 'string' && workspaceRoot) record.cwd = workspaceRoot;
   if (payload.prompt_id !== undefined) record.prompt_id = payload.prompt_id;
   if (payload.parent_tool_use_id !== undefined) record.parent_tool_use_id = payload.parent_tool_use_id;
   // The launch tool name separates the Agent/Task result surface and the subagent launch from executed tools (F4/F5).
   if (typeof payload.tool_name === 'string') record.tool_name = payload.tool_name;
-  const agentId = payload.agent_id !== undefined ? payload.agent_id : responseAliasAgentId;
+  if (outlinePre) {
+    if (Object.prototype.hasOwnProperty.call(toolInput, 'run_in_background')) record.run_in_background = toolInput.run_in_background;
+    record.isolationSet = Object.prototype.hasOwnProperty.call(toolInput, 'isolation');
+  }
+  if (outlineResult && recordOf(toolResponse) && Object.prototype.hasOwnProperty.call(toolResponse, 'status')) {
+    record.tool_response_status = toolResponse.status;
+  }
+  const resultAgentConflict = outlineResult && textOf(payload.agent_id) && textOf(responseAliasAgentId)
+    && payload.agent_id !== responseAliasAgentId;
+  const agentId = outlineResult ? (resultAgentConflict ? undefined : responseAliasAgentId)
+    : payload.agent_id !== undefined ? payload.agent_id : responseAliasAgentId;
   if (agentId !== undefined) {
     record.agent_id = agentId;
     if (payload.agent_type !== undefined) record.agent_type = payload.agent_type;
@@ -2132,4 +2245,4 @@ module.exports = { createClaudeOriginProvider, createOpencodeOriginProvider, bui
   _internals: { captureJson, captureDigest, digestText, canonicalCapture, parseOutlineDispatchPrompt,
     parseInventoryPinRows, validateOutlineInventoryPin, resolveInventoryRow, parseOutlineCitation, resolveOutlineAttempt,
     captureOutlineDispatch, resolveOutlineEvidence, verifyOutlineMergeCorrespondence, validateOutlineCaptureQualification,
-    outlineCaptureMappingValid, OUTLINE_INVENTORY_PIN } };
+    outlineCaptureMappingValid, correlateOutlineDispatch, OUTLINE_CAPTURE_MAPPING, OUTLINE_INVENTORY_PIN } };

package/opencode-plugin/plugin.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.46.0",
+  "version": "0.46.1",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {

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

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

package/plugins/harness-everything/hooks/scripts/lib/doc-reconciliation-provider.js

@@ -52,6 +52,19 @@ const DOC_CHECK_BOOLEAN_FLAGS = new Set(['--conflict-assessment']);
 const DOC_CHECK_SCHEMA = 'harness.doc-check.check.v1';
 const DOC_CHECK_CONFLICT_SCHEMA = 'harness.doc-check.conflict-assessment.v1';
 const OUTLINE_DISPATCH_SCHEMA = 'harness.outline-dispatch.v1';
+const OUTLINE_CAPTURE_MAPPING = Object.freeze({
+  version: 'claude-outline-dispatch-mapping/2',
+  promptField: 'tool_input.prompt',
+  dispatchKey: 'session_id+tool_use_id',
+  runInBackgroundField: 'tool_input.run_in_background',
+  isolationPresenceField: 'tool_input.isolation',
+  resultAgentIdField: 'tool_response.agentId',
+  resultStatusField: 'tool_response.status',
+  workerStartEvent: 'SubagentStart',
+  workerStopEvent: 'SubagentStop',
+  workerIdentity: 'session_id+agent_id',
+  workerRootField: 'cwd',
+});
 const OUTLINE_SEAM_SCHEMA = 'harness.outline-dispatch-seam.v1';
 const OUTLINE_HANDOFF_SCHEMA = 'harness.outline-handoff.v1';
 const OUTLINE_LEASE_SCHEMA = 'harness.outline-writer-lease.v1';
@@ -1163,28 +1176,125 @@ function validateOutlineCaptureQualification(input, expectedHost = HOST_ID) {
 }
 
 function outlineCaptureMappingValid(mapping, records) {
-  if (!recordOf(mapping) || mapping.promptField !== 'tool_input.prompt'
-    || mapping.coordinatorPrincipalField !== 'session_id' || mapping.synchronousPreToolUse !== true
-    || mapping.workerStartDispatchField !== 'parent_tool_use_id' || mapping.workerStartRootField !== 'cwd'
-    || mapping.taskResultDispatchField !== 'tool_use_id' || !Array.isArray(records)) return false;
+  if (!recordOf(mapping) || captureJson(mapping) !== captureJson(OUTLINE_CAPTURE_MAPPING) || !Array.isArray(records)) return false;
   const pres = records.filter(item => recordOf(item) && item.event === 'PreToolUse'
     && ['Task', 'Agent'].includes(item.tool_name) && recordOf(item.tool_input)
     && typeof item.tool_input.prompt === 'string' && textOf(item.session_id) && textOf(item.tool_use_id));
-  return pres.some(pre => {
+  return pres.some(pre => correlateOutlineDispatch(records, pre).state === 'accepted');
+}
+
+function outlineCorrelationFailure(reason) { return { state: 'unresolved', reason }; }
+
+function outlineDispatchKeyMatches(item, pre) {
+  return recordOf(item) && item.session_id === pre.session_id && item.tool_use_id === pre.tool_use_id;
+}
+
+function outlineResultAgentId(result) {
+  if (recordOf(result.tool_response)) {
+    const observed = result.tool_response.agentId;
+    if (textOf(result.agent_id) && textOf(observed) && result.agent_id !== observed) {
+      return { state: 'unresolved', reason: 'outline-worker-result-agent-id-conflict' };
+    }
+    return { state: textOf(observed) ? 'accepted' : 'unresolved', agentId: observed,
+      ...(textOf(observed) ? {} : { reason: 'outline-worker-result-agent-id-missing' }) };
+  }
+  return textOf(result.agent_id)
+    ? { state: 'accepted', agentId: result.agent_id }
+    : { state: 'unresolved', reason: 'outline-worker-result-agent-id-missing' };
+}
+
+function outlineResultStatus(result) {
+  if (recordOf(result.tool_response)) return Object.prototype.hasOwnProperty.call(result.tool_response, 'status')
+    ? { present: true, value: result.tool_response.status } : { present: false };
+  return Object.prototype.hasOwnProperty.call(result, 'tool_response_status')
+    ? { present: true, value: result.tool_response_status } : { present: false };
+}
+
+function correlateOutlineDispatch(records, anchor, expectedWorkerRoot) {
+  if (!Array.isArray(records)) return outlineCorrelationFailure('outline-capture-records-missing');
+  if (!recordOf(anchor) || anchor.event !== 'PreToolUse' || !['Task', 'Agent'].includes(anchor.tool_name)) {
+    return outlineCorrelationFailure('outline-dispatch-anchor-invalid');
+  }
+  if (!textOf(anchor.session_id) || !textOf(anchor.tool_use_id)) return outlineCorrelationFailure('outline-dispatch-key-missing');
+  const pres = records.filter(item => recordOf(item) && item.event === 'PreToolUse'
+    && ['Task', 'Agent'].includes(item.tool_name) && outlineDispatchKeyMatches(item, anchor));
+  if (pres.length !== 1) return outlineCorrelationFailure('outline-dispatch-anchor-missing-or-ambiguous');
+  const pre = pres[0];
+  let workerRoot = expectedWorkerRoot;
+  if (recordOf(pre.tool_input)) {
     const marker = parseOutlineDispatchPrompt(pre.tool_input.prompt);
-    if (!marker) return false;
-    const starts = records.filter(item => recordOf(item) && item.event === 'SubagentStart'
-      && item.parent_tool_use_id === pre.tool_use_id && item.session_id === pre.session_id
-      && textOf(item.cwd) && textOf(marker.workerRoot) && key(item.cwd) === key(marker.workerRoot)
-      && textOf(item.agent_id));
-    if (starts.length !== 1) return false;
-    const worker = starts[0];
-    const results = records.filter(item => recordOf(item) && item.event === 'PostToolUse'
-      && ['Task', 'Agent'].includes(item.tool_name) && item.tool_use_id === pre.tool_use_id
-      && item.session_id === pre.session_id && item.agent_id === worker.agent_id
-      && item.interrupted === false);
-    return results.length === 1;
-  });
+    if (!marker) return outlineCorrelationFailure('outline-dispatch-marker-invalid');
+    if (workerRoot !== undefined && !samePathKey(marker.workerRoot, workerRoot)) {
+      return outlineCorrelationFailure('outline-dispatch-worker-root-mismatch');
+    }
+    workerRoot = marker.workerRoot;
+    if (!Object.prototype.hasOwnProperty.call(pre.tool_input, 'run_in_background')) {
+      return outlineCorrelationFailure('outline-dispatch-background-unobserved');
+    }
+    if (pre.tool_input.run_in_background !== false) {
+      return outlineCorrelationFailure('outline-dispatch-background-enabled');
+    }
+    if (Object.prototype.hasOwnProperty.call(pre.tool_input, 'isolation')) {
+      return outlineCorrelationFailure('outline-dispatch-isolation-unsupported');
+    }
+  } else {
+    if (!recordOf(pre.outlineDispatch) || pre.outlineDispatch.state !== 'accepted' || !textOf(pre.outlineDispatch.workerRoot)) {
+      return outlineCorrelationFailure('outline-dispatch-marker-unobserved');
+    }
+    if (workerRoot !== undefined && !samePathKey(pre.outlineDispatch.workerRoot, workerRoot)) {
+      return outlineCorrelationFailure('outline-dispatch-worker-root-mismatch');
+    }
+    workerRoot = pre.outlineDispatch.workerRoot;
+    if (!Object.prototype.hasOwnProperty.call(pre, 'run_in_background')) {
+      return outlineCorrelationFailure('outline-dispatch-background-unobserved');
+    }
+    if (pre.run_in_background !== false) return outlineCorrelationFailure('outline-dispatch-background-enabled');
+    if (!Object.prototype.hasOwnProperty.call(pre, 'isolationSet')) {
+      return outlineCorrelationFailure('outline-dispatch-isolation-unobserved');
+    }
+    if (pre.isolationSet !== false) return outlineCorrelationFailure('outline-dispatch-isolation-unsupported');
+  }
+  if (!textOf(workerRoot) || !path.isAbsolute(workerRoot)) return outlineCorrelationFailure('outline-dispatch-worker-root-unobserved');
+
+  const failures = records.filter(item => outlineDispatchKeyMatches(item, pre) && item.event === 'PostToolUseFailure');
+  if (failures.length) return outlineCorrelationFailure('outline-worker-result-failed');
+  const results = records.filter(item => outlineDispatchKeyMatches(item, pre) && item.event === 'PostToolUse'
+    && ['Task', 'Agent'].includes(item.tool_name));
+  if (results.length !== 1) return outlineCorrelationFailure('outline-worker-result-missing-or-ambiguous');
+  const result = results[0];
+  const status = outlineResultStatus(result);
+  if (!status.present || status.value === undefined) return outlineCorrelationFailure('outline-worker-result-status-missing');
+  if (status.value === 'async_launched') return outlineCorrelationFailure('outline-worker-result-async');
+  if (status.value !== 'completed') return outlineCorrelationFailure('outline-worker-result-failed');
+  const observedAgent = outlineResultAgentId(result);
+  if (observedAgent.state !== 'accepted') return outlineCorrelationFailure(observedAgent.reason);
+  const agentId = observedAgent.agentId;
+  const sameAgentResults = records.filter(item => recordOf(item) && item.event === 'PostToolUse'
+    && ['Task', 'Agent'].includes(item.tool_name) && item.session_id === pre.session_id
+    && outlineResultAgentId(item).state === 'accepted' && outlineResultAgentId(item).agentId === agentId);
+  if (sameAgentResults.length !== 1) return outlineCorrelationFailure('outline-worker-agent-id-replayed');
+
+  const starts = records.filter(item => recordOf(item) && item.event === 'SubagentStart'
+    && item.session_id === pre.session_id && item.agent_id === agentId);
+  if (starts.length !== 1) return outlineCorrelationFailure('outline-worker-start-missing-or-ambiguous');
+  const stops = records.filter(item => recordOf(item) && item.event === 'SubagentStop'
+    && item.session_id === pre.session_id && item.agent_id === agentId);
+  if (stops.length !== 1) return outlineCorrelationFailure('outline-worker-stop-missing-or-ambiguous');
+  const start = starts[0];
+  const stop = stops[0];
+  const preIndex = records.indexOf(pre);
+  const startIndex = records.indexOf(start);
+  const stopIndex = records.indexOf(stop);
+  if (preIndex < 0 || startIndex < 0 || stopIndex < 0) return outlineCorrelationFailure('outline-worker-journal-position-unavailable');
+  if (startIndex <= preIndex) return outlineCorrelationFailure('outline-worker-start-before-dispatch');
+  if (stopIndex <= startIndex) return outlineCorrelationFailure('outline-worker-stop-before-start');
+  for (const workerEvent of [start, stop]) {
+    if (!textOf(workerEvent.cwd) || !path.isAbsolute(workerEvent.cwd)) {
+      return outlineCorrelationFailure('outline-worker-root-unobserved');
+    }
+    if (!samePathKey(workerEvent.cwd, workerRoot)) return outlineCorrelationFailure('outline-worker-root-mismatch');
+  }
+  return { state: 'accepted', pre, result, start, stop, workerRoot, agentId };
 }
 
 function verifyOutlineMergeCorrespondence({ root, outlineCommit, draftCommit, mergedCommit, targetPaths, record } = {}) {
@@ -1335,20 +1445,10 @@ function resolveOutlineEvidence({ safeInput, capture, captures, request, originR
       || review.reviewDigest !== seam.reviewDigest || review.reviewerPrincipal !== seam.reviewerPrincipal) {
       return fail(review.reason || 'outline-review-changed-after-dispatch');
     }
-    const startEvents = (Array.isArray(captures) ? captures : []).filter(item => recordOf(item)
-      && item.event === 'SubagentStart' && item.parent_tool_use_id === cap.tool_use_id && item.session_id === cap.session_id);
-    if (startEvents.length !== 1 || !textOf(startEvents[0].agent_id)) return fail('outline-worker-start-missing-or-ambiguous');
-    const worker = startEvents[0];
-    let workerRoot;
-    try { workerRoot = canonicalOutlineRoot(worker.cwd); }
-    catch { return fail('outline-worker-root-unobserved'); }
-    if (!sameCanonicalPath(workerRoot, seam.workerRoot)) return fail('outline-worker-root-mismatch');
-    const results = (Array.isArray(captures) ? captures : []).filter(item => recordOf(item)
-      && item.event === 'PostToolUse' && ['Task', 'Agent'].includes(item.tool_name)
-      && item.tool_use_id === cap.tool_use_id && item.session_id === cap.session_id);
-    if (results.length !== 1 || results[0].agent_id !== worker.agent_id || results[0].interrupted !== false) {
-      return fail('outline-worker-result-missing-or-mismatched');
-    }
+    const correlation = correlateOutlineDispatch(captures, cap, seam.workerRoot);
+    if (correlation.state !== 'accepted') return fail(correlation.reason);
+    const worker = correlation.start;
+    const workerRoot = correlation.workerRoot;
     if (review.reviewerPrincipal === worker.agent_id) return fail('outline-reviewer-is-draft-worker');
     const principals = { author: safeInput.sessionId, executors: journalExecutors(captures, safeInput.sessionId) };
     if (!reviewRecordIndependent(review.review, captures, principals)) return fail('outline-review-not-independent');
@@ -1949,6 +2049,8 @@ function buildCaptureRecord(payload, eventName, workspaceRoot) {
   if (event === 'PreToolUse' && PRE_CAPTURE_TOOLS.indexOf(payload.tool_name) === -1) return null;
   const toolInput = recordOf(payload.tool_input) ? payload.tool_input : {};
   const toolResponse = payload.tool_response;
+  const outlinePre = event === 'PreToolUse' && ['Task', 'Agent'].includes(payload.tool_name);
+  const outlineResult = event === 'PostToolUse' && ['Task', 'Agent'].includes(payload.tool_name);
   // Demonstrated alias mapping (doc: "Host result aliases such as agentId
   // require a demonstrated capture mapping to the same subagent identity"):
   // the PostToolUse Task/Agent result surface reports the subagent id as
@@ -1961,17 +2063,28 @@ function buildCaptureRecord(payload, eventName, workspaceRoot) {
     ref: captureId,
     event,
     command: typeof toolInput.command === 'string' ? toolInput.command : '',
-    cwd: typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : (typeof workspaceRoot === 'string' && workspaceRoot ? workspaceRoot : ''),
     tool_use_id: typeof payload.tool_use_id === 'string' ? payload.tool_use_id : '',
     session_id: payload.session_id === undefined && payload.sessionId === undefined ? '' : String(payload.session_id !== undefined ? payload.session_id : payload.sessionId),
     responseDigest: captureDigest(toolResponse),
     responseRef: `host-payload/${event}/${captureId}`,
   };
+  if (typeof payload.cwd === 'string' && payload.cwd) record.cwd = payload.cwd;
+  else if (!['SubagentStart', 'SubagentStop'].includes(event) && typeof workspaceRoot === 'string' && workspaceRoot) record.cwd = workspaceRoot;
   if (payload.prompt_id !== undefined) record.prompt_id = payload.prompt_id;
   if (payload.parent_tool_use_id !== undefined) record.parent_tool_use_id = payload.parent_tool_use_id;
   // The launch tool name separates the Agent/Task result surface and the subagent launch from executed tools (F4/F5).
   if (typeof payload.tool_name === 'string') record.tool_name = payload.tool_name;
-  const agentId = payload.agent_id !== undefined ? payload.agent_id : responseAliasAgentId;
+  if (outlinePre) {
+    if (Object.prototype.hasOwnProperty.call(toolInput, 'run_in_background')) record.run_in_background = toolInput.run_in_background;
+    record.isolationSet = Object.prototype.hasOwnProperty.call(toolInput, 'isolation');
+  }
+  if (outlineResult && recordOf(toolResponse) && Object.prototype.hasOwnProperty.call(toolResponse, 'status')) {
+    record.tool_response_status = toolResponse.status;
+  }
+  const resultAgentConflict = outlineResult && textOf(payload.agent_id) && textOf(responseAliasAgentId)
+    && payload.agent_id !== responseAliasAgentId;
+  const agentId = outlineResult ? (resultAgentConflict ? undefined : responseAliasAgentId)
+    : payload.agent_id !== undefined ? payload.agent_id : responseAliasAgentId;
   if (agentId !== undefined) {
     record.agent_id = agentId;
     if (payload.agent_type !== undefined) record.agent_type = payload.agent_type;
@@ -2132,4 +2245,4 @@ module.exports = { createClaudeOriginProvider, createOpencodeOriginProvider, bui
   _internals: { captureJson, captureDigest, digestText, canonicalCapture, parseOutlineDispatchPrompt,
     parseInventoryPinRows, validateOutlineInventoryPin, resolveInventoryRow, parseOutlineCitation, resolveOutlineAttempt,
     captureOutlineDispatch, resolveOutlineEvidence, verifyOutlineMergeCorrespondence, validateOutlineCaptureQualification,
-    outlineCaptureMappingValid, OUTLINE_INVENTORY_PIN } };
+    outlineCaptureMappingValid, correlateOutlineDispatch, OUTLINE_CAPTURE_MAPPING, OUTLINE_INVENTORY_PIN } };

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.46.0",
+  "version": "0.46.1",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:4e82c3bc-ded1-5f78-8aa6-6dd26488f41f",
+  "serialNumber": "urn:uuid:e14b39ac-6cf4-5711-b0c8-03de1649a568",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-10-28T00:05:02.172Z",
+    "timestamp": "2026-10-28T02:23:43.789Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.46.0"
+        "version": "0.46.1"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.46.0",
+      "bom-ref": "pkg:npm/harness-everything@0.46.1",
       "name": "harness-everything",
-      "version": "0.46.0",
-      "purl": "pkg:npm/harness-everything@0.46.0"
+      "version": "0.46.1",
+      "purl": "pkg:npm/harness-everything@0.46.1"
     }
   },
   "components": [
@@ -2033,7 +2033,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.46.0",
+      "ref": "pkg:npm/harness-everything@0.46.1",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",