harness-everything 0.45.0 → 0.46.1

package/docs/adr/DOCS-001-project-docs-config.md

@@ -0,0 +1,32 @@
+---
+id: DOCS-001
+status: accepted
+---
+
+# DOCS-001 — Project docs config resolution (D5)
+
+## Decision
+
+- The committed, host-neutral `.agents/harness-everything/project-docs.json` wholly overrides differing host `projectDocs` values.
+- `AGENTS.md` is never a configuration source.
+- When the project file overrides a differing host value, the resolver reports `project-overrides-host`.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #325 | Documentation family, PRD/ADR governance and doc-change workflow | OPEN |
+
+- Contract: [document-lifecycle.md § Configuration (D5)](../document-lifecycle.md#configuration-d5).
+
+## Evidence
+
+- Implementation: [project-docs-resolver.js](../../harness-everything/scripts/project-docs-resolver.js) (`project-overrides-host`, around line 390), [doc-check.js](../../harness-everything/scripts/doc-check.js).
+- Test: [mechanism-2aw-project-docs-config.test.js](../../ci/mechanism-2aw-project-docs-config.test.js).
+- Repo-wide gate, not row-specific: [reference-check.js](../../ci/reference-check.js).
+- `AGENTS.md` exclusion is stated in [document-lifecycle.md](../document-lifecycle.md) (configuration table). The resolver has no `AGENTS.md` read path.
+- Config in this repo: [project-docs.json](../../.agents/harness-everything/project-docs.json).
+
+## Open gates
+
+- #325 is OPEN as the documentation-family umbrella. Shipped slices do not close it.

package/docs/adr/DOCS-002-adr-identity-supersession-index.md

@@ -0,0 +1,34 @@
+---
+id: DOCS-002
+status: accepted
+---
+
+# DOCS-002 — ADR/REQ identity, supersession and generated index (D6.1–D6.4)
+
+## Decision
+
+- ADR IDs are `<DOMAIN>-NNN` (domain 2–10 uppercase alphanumerics, at least 3 digits). The domain must be declared in `domains`.
+- `status` is required and uses `proposed` / `accepted` / `rejected` / `superseded`.
+- Aliases and `legacy:` references resolve to one document. Self-aliases and collisions are diagnosed.
+- A `supersedes` edge takes effect only from an `accepted` ADR to a target already `superseded`. Cycles are diagnosed.
+- `conflicts_with` stays a recorded conflict until an effective `supersedes` edge exists.
+- The index in `docs/governed-index.md` is generated, not hand-written.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #325 | Documentation family, PRD/ADR governance and doc-change workflow | OPEN |
+
+- Contract: [document-lifecycle.md § IDs](../document-lifecycle.md#ids-aliases-and-references-d62-d68), [§ Supersession](../document-lifecycle.md#supersession-d63-d64).
+
+## Evidence
+
+- Implementation: [doc-lifecycle.js](../../harness-everything/scripts/doc-lifecycle.js) (`ADR_ID` at line 20; `unknown-domain` at line 1078; `supersede-cycle` at line 1220).
+- Test: [mechanism-2ax-doc-lifecycle.test.js](../../ci/mechanism-2ax-doc-lifecycle.test.js).
+- Repo-wide gate, not row-specific: [reference-check.js](../../ci/reference-check.js).
+- Generator: [governed-index.md](../governed-index.md), produced by `doc-lifecycle.js index` (see `derived` in [project-docs.json](../../.agents/harness-everything/project-docs.json)).
+
+## Open gates
+
+- #325 is OPEN as the documentation-family umbrella. Shipped slices do not close it.

package/docs/adr/DOCS-003-prd-revision-contract.md

@@ -0,0 +1,29 @@
+---
+id: DOCS-003
+status: accepted
+---
+
+# DOCS-003 — Contract-style PRD revision chain (D6.9)
+
+## Decision
+
+- An effective PRD is a frozen revision chain with an approval record.
+- A change creates a new complete revision copied from the current effective revision. The effective snapshot is never edited in place.
+- This replaces the D6.1 living-PRD model for PRDs only. ADRs, tickets and other roles are unchanged.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #325 | Documentation family, PRD/ADR governance and doc-change workflow | OPEN |
+
+- Contract: [document-lifecycle.md § Contract-style PRD revisions (D6.9)](../document-lifecycle.md#contract-style-prd-revisions-d69).
+
+## Evidence
+
+- Implementation: [doc-lifecycle.js](../../harness-everything/scripts/doc-lifecycle.js) (revision identity, approval, immutability and `immutable-revision-modified` diagnostics).
+- Test: [mechanism-2ay-prd-revisions.test.js](../../ci/mechanism-2ay-prd-revisions.test.js). Its header cites the D6.9 contract section.
+
+## Open gates
+
+- #325 is OPEN as the documentation-family umbrella. Shipped slices do not close it.

package/docs/adr/DOCS-004-doc-change-step-type.md

@@ -0,0 +1,28 @@
+---
+id: DOCS-004
+status: accepted
+---
+
+# DOCS-004 — `doc-change` step type
+
+## Decision
+
+- `doc-change` is an explicit documentation-edit step type.
+- It has no implicit TDD binding. Step types are declared in a registry, not inferred.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #326 | Extract step-type registry and add doc-change step (split from #320 for #325) | CLOSED |
+| #328 | Declarative step-type registry with declared-only doc-change (#326) | MERGED |
+
+## Evidence
+
+- Implementation: [step-types.json](../../hooks/scripts/lib/step-types.json) (`"id": "doc-change"`), [workflow-obligations.js](../../hooks/scripts/lib/workflow-obligations.js).
+- Test: [mechanism-2az-step-type-registry.test.js](../../ci/mechanism-2az-step-type-registry.test.js).
+
+## Open gates
+
+- None for #326 and #328.
+- #325 is OPEN as the documentation-family umbrella (see DOCS-001).

package/docs/adr/DOCS-005-doc-obligations-evidence-producer.md

@@ -0,0 +1,29 @@
+---
+id: DOCS-005
+status: accepted
+---
+
+# DOCS-005 — Doc obligations and trusted evidence producer (phase 3a)
+
+## Decision
+
+- Documentation MUST obligations fail closed: missing or untrusted evidence yields a failing result, never a pass.
+- Evidence is produced by a trusted producer. Baseline-bound evidence is refused when the baseline has no whole-baseline digest.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #334 | Phase 3a doc-change obligation derivation and evidence producer (#325) | MERGED |
+| #335 | Bind deleted and renamed paths to baseline evidence | CLOSED |
+| #342 | Read baseline and destination identities exactly once (fix for #335) | MERGED |
+
+## Evidence
+
+- Implementation: [doc-obligations.js](../../harness-everything/scripts/doc-obligations.js), [doc-evidence.js](../../harness-everything/scripts/doc-evidence.js) (digest refusal near line 165), [doc-evidence-capture.js](../../harness-everything/scripts/doc-evidence-capture.js).
+- Tests: [mechanism-325-3a-doc-obligations.test.js](../../ci/mechanism-325-3a-doc-obligations.test.js), [mechanism-325-3a-doc-evidence.test.js](../../ci/mechanism-325-3a-doc-evidence.test.js), [mechanism-335-baseline-evidence.test.js](../../ci/mechanism-335-baseline-evidence.test.js).
+
+## Open gates
+
+- None specific to #334, #335 or #342.
+- #325 is OPEN as the documentation-family umbrella (see DOCS-001).

package/docs/adr/DOCS-006-reconciliation-pilot.md

@@ -0,0 +1,50 @@
+---
+id: DOCS-006
+status: accepted
+---
+
+# DOCS-006 — Doc reconciliation pilot (S1 default-OFF, F4 limited credit)
+
+## Decision
+
+- The S1 runtime is default OFF. It runs only when `HARNESS_DOC_RECONCILIATION_PILOT=1`.
+- Fail-closed: evidence that is not trusted is withheld, not credited.
+- F4 gives positive credit for `doc-lint` and `link-check`, from a host-captured run of the installed doc-check. The contract limits positive credit to Claude Code ([F4 contract](../doc-workflow-reconciliation.md#f4-credited-reconciliation-claude-only-pilot-on), line 1158).
+- F4 also gives credit for `quality-review` from an independent host reviewer (`SubagentStop`).
+- `conflict-check` (PR #385): `doc-check.js check --conflict-assessment` requires an exact `--base` SHA and runs lifecycle lint with `--all`. It credits only a complete corpus with no lint error diagnostics, and checks recorded and structural conflicts only. Prose contradictions stay with `quality-review`. Plain `check` earns no conflict credit.
+- The observed live runs (Claude Code 2.1.309, runs 4–5) credited only `doc-lint` and `link-check`. `quality-review` and `conflict-check` have mechanism tests only.
+- Other capabilities stay withheld. Expansion beyond the limited pilot is gated on #341 E1.
+
+```mermaid
+flowchart LR
+  E["HARNESS_DOC_RECONCILIATION_PILOT=1"] --> P["doc-reconciliation-pilot.js"]
+  P -->|"host-captured doc-check"| L["doc-lint + link-check: credited"]
+  P -->|"independent SubagentStop reviewer"| Q["quality-review: credited (mechanism tests)"]
+  P -->|"check --conflict-assessment, complete corpus"| C["conflict-check: credited (mechanism tests)"]
+  P -. "all other capabilities" .-> W["withheld"]
+```
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #341 | Phased snapshot boundary, conformance suite, obligation contract | OPEN |
+| #350 | Docuvia pilot limitations (code-to-doc dependency edge, derivation hygiene) | OPEN |
+| #358 | Credit host-captured doc evidence on Claude Code (#325) | MERGED |
+| #375 | Retain adjudicated E1 blockers and Phase 3c handoff | MERGED |
+| #385 | Conflict-check producer from a full-corpus assessment | MERGED |
+
+- #375 records zero qualifying E1 cycles, so expansion stays gated.
+- Contract: [doc-workflow-reconciliation.md § S1 switch](../doc-workflow-reconciliation.md#s1--switch-trusted-scope-and-fail-closed-no-credit-gate).
+
+## Evidence
+
+- Implementation: [doc-reconciliation-pilot.js](../../hooks/scripts/lib/doc-reconciliation-pilot.js) (env gate at line 8; `doc-lint` / `link-check` credit at line 246; `quality-review` collection from `SubagentStop` at lines 244 and 254; `conflict-check` collection at lines 251–252), [doc-check.js](../../harness-everything/scripts/doc-check.js) (flag parse at lines 86–88; `--base` required at line 102; `--all` lint at line 108; assessment at lines 468–498; credit at line 501), [doc-reconciliation-provider.js](../../hooks/scripts/lib/doc-reconciliation-provider.js) (corpus binding check at lines 763–785), [doc-reconciliation-core.js](../../hooks/scripts/lib/doc-reconciliation-core.js), [doc-reconciliation-producer.js](../../hooks/scripts/lib/doc-reconciliation-producer.js), [doc-reconciliation-events.js](../../hooks/scripts/lib/doc-reconciliation-events.js).
+- F4 contract: [doc-workflow-reconciliation.md § F4](../doc-workflow-reconciliation.md#f4-credited-reconciliation-claude-only-pilot-on). `conflict-check` row: [doc-workflow-reconciliation.md](../doc-workflow-reconciliation.md) line 1174.
+- Tests: [mechanism-pr-a-conflict-check.test.js](../../ci/mechanism-pr-a-conflict-check.test.js) (17/17 PASS at this SHA; mechanism only, no live-host run), [mechanism-325-3b-preparation.test.js](../../ci/mechanism-325-3b-preparation.test.js), [mechanism-325-3b-s1-review.test.js](../../ci/mechanism-325-3b-s1-review.test.js), [mechanism-325-3b-s2a-core.test.js](../../ci/mechanism-325-3b-s2a-core.test.js), [mechanism-325-3b-s2b-wiring.test.js](../../ci/mechanism-325-3b-s2b-wiring.test.js), [mechanism-341-opencode-lane.test.js](../../ci/mechanism-341-opencode-lane.test.js).
+
+## Open gates
+
+- #341 OPEN: E1 GO / REVISE / NO-GO gates any expansion beyond the limited pilot.
+- #350 OPEN: Docuvia pilot limitations.
+- #325 OPEN as the documentation-family umbrella (see DOCS-001).

package/docs/adr/DOCS-007-shared-doc-craft-derived-views.md

@@ -0,0 +1,31 @@
+---
+id: DOCS-007
+status: accepted
+---
+
+# DOCS-007 — Shared doc craft and derived-view regeneration (F2/F3)
+
+## Decision
+
+- Each declared derived view in `derived` MUST be regenerated and must match its source when its inputs change (`derived-regenerate`).
+- Doc-skill craft guidance is shared from one place under `references/documentation/_shared/`, not copied into each skill.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #356 | Share documentation craft across doc skills (#325) | MERGED |
+| #357 | Check derived views with regenerate-equals (#325) | MERGED |
+
+- #325 is OPEN as the documentation-family umbrella (see DOCS-001). It is the commit-title parent of both merged PRs.
+
+## Evidence
+
+- Implementation: [doc-obligations.js](../../harness-everything/scripts/doc-obligations.js) (`derived-regenerate` capability at line 10), [writing-craft.md](../../harness-everything/references/documentation/_shared/writing-craft.md), [maintenance.md](../../harness-everything/references/documentation/_shared/maintenance.md).
+- Tests: [mechanism-325-f3-derived-views.test.js](../../ci/mechanism-325-f3-derived-views.test.js), [mechanism-325-f2-doc-craft.test.js](../../ci/mechanism-325-f2-doc-craft.test.js).
+- Repo-wide gate, not row-specific: [reference-check.js](../../ci/reference-check.js).
+
+## Open gates
+
+- None specific to #356 or #357.
+- #325 is OPEN as the documentation-family umbrella (see DOCS-001).

package/docs/adr/DOCS-008-obligation-abstraction-bounded-consumer.md

@@ -0,0 +1,30 @@
+---
+id: DOCS-008
+status: accepted
+---
+
+# DOCS-008 — #320 obligation abstraction as a bounded doc consumer
+
+## Decision
+
+- The doc workflow reconciliation consumes the workflow obligation abstraction in a bounded way: the documentation path only, under the DOCS-006 gate.
+- Broad promotion of the abstraction to generic workflow use is not approved. It is gated on the Phase 3c H1–H4 paired-task evidence and owner sign-off.
+
+## Context
+
+| Issue | Subject | State |
+| --- | --- | --- |
+| #320 | Compile workflow/skill metadata into a dynamic decision graph | OPEN |
+
+- Phase 3c is planned, not shipped: [document-lifecycle.md § Phase 3c](../document-lifecycle.md#phase-3c--architecture-promotion-gate-for-320-planned-not-shipped).
+
+## Evidence
+
+- Implementation: [doc-reconciliation-core.js](../../hooks/scripts/lib/doc-reconciliation-core.js), [doc-obligations.js](../../harness-everything/scripts/doc-obligations.js) (the obligation table consumed by the doc path).
+- Consumer tests (exercise `doc-reconciliation-core.js` consuming `deriveDocObligations`): [mechanism-325-3b-s2a-core.test.js](../../ci/mechanism-325-3b-s2a-core.test.js), [mechanism-325-3b-s2b-wiring.test.js](../../ci/mechanism-325-3b-s2b-wiring.test.js).
+- Fail-closed controls (not evidence of the consumer): [mechanism-325-3b-preparation.test.js](../../ci/mechanism-325-3b-preparation.test.js), [mechanism-325-3b-s1-review.test.js](../../ci/mechanism-325-3b-s1-review.test.js), [mechanism-341-opencode-lane.test.js](../../ci/mechanism-341-opencode-lane.test.js).
+
+## Open gates
+
+- #320 OPEN. Its own promotion gate is unmet: H1–H4 paired-task evidence has not been collected.
+- Pilot gate (#341 E1) applies, see DOCS-006.

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
@@ -1213,3 +1229,33 @@ claude -p "<fixed capture prompt, containing the exact check command>" \
 - **The live gate is a repository-pinned field-availability check, not a running-host compatibility check (F10).** The qualification export records Claude Code `2.1.308`, but the retained Claude hook payloads expose no host-version field for the runtime to compare. The export and sibling sanitized capture validate the recorded payload kinds and correlations for that host version; they do not establish compatibility with the current session. Editing both repository artifacts and updating the capture digest can reopen the gate without a new live capture.
 - **The unsupported-host check is vacuous in production (F11).** The only production caller asserts the Claude host id. OpenCode and Codex stay unavailable because their plugins do not mount `state-persist.js`, not because the host is detected.
 - **Event files are not tamper-proof (F13).** Event files are created exclusively, and the journal is checked against them. The local agent can still rewrite event files and rebuild the journal. This is the owner's bounded claim, not a guarantee of tamper resistance.
+
+## PR-B: dedicated pre-draft outline confirmation
+
+Status: **implemented behind the existing pilot switch; mechanism and package checks pass; no positive live-host credit is enabled.** This capability follows owner decisions 9 and 11: an independent reviewer approves exact O before drafting; the outline cites one row from the pinned inventory; final D is a strict descendant of O; a coordinator handoff records review-complete → fresh-draft-dispatch. Owner approval is provenance only and never a runtime reviewer principal.
+
+```mermaid
+flowchart LR
+  B["Original baseline B<br/>task and config pinned"] --> O["Proposed outline O<br/>new target absent at B"]
+  I["Coordinator-pinned inventory"] --> R["Independent review<br/>exact O + cited row"]
+  O --> R
+  R --> H["Immutable handoff +<br/>exclusive writer lease"]
+  H --> P["Task/Agent PreToolUse<br/>exact prompt marker"]
+  P --> S["Synchronous seam<br/>clean worker root at O<br/>one-use token consumed"]
+  S --> W["Correlated worker start/result"]
+  W --> D["Final candidate D<br/>strict descendant of O"]
+  D --> A["Outline result and<br/>aggregate B→D MUSTs"]
+```
+
+| Evidence | Required binding |
+|---|---|
+| 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. 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. 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 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/docs/governed-index.md

@@ -4,6 +4,14 @@
 
 - `(no id)` — `docs/architecture.md` (role: reference; status: active)
 - `(no id)` — `docs/doc-workflow-reconciliation.md` (role: reference; status: active)
+- `DOCS-001` — `docs/adr/DOCS-001-project-docs-config.md` (role: adr; status: accepted)
+- `DOCS-002` — `docs/adr/DOCS-002-adr-identity-supersession-index.md` (role: adr; status: accepted)
+- `DOCS-003` — `docs/adr/DOCS-003-prd-revision-contract.md` (role: adr; status: accepted)
+- `DOCS-004` — `docs/adr/DOCS-004-doc-change-step-type.md` (role: adr; status: accepted)
+- `DOCS-005` — `docs/adr/DOCS-005-doc-obligations-evidence-producer.md` (role: adr; status: accepted)
+- `DOCS-006` — `docs/adr/DOCS-006-reconciliation-pilot.md` (role: adr; status: accepted)
+- `DOCS-007` — `docs/adr/DOCS-007-shared-doc-craft-derived-views.md` (role: adr; status: accepted)
+- `DOCS-008` — `docs/adr/DOCS-008-obligation-abstraction-bounded-consumer.md` (role: adr; status: accepted)
 
 ## PRD revision chains
 

package/docs/platform-capabilities.md

@@ -210,6 +210,8 @@ The editorial doc check (`harness-everything/scripts/doc-check.js`, F1) is reach
 
 Credited reconciliation for F4 (Claude Code only, pilot ON) is **implemented, with mechanism and package evidence and one live field-availability capture**. Credit works for `doc-lint` and `link-check` through a registered `doc-check` run, and for an independent `quality-review` with bound path digests. The capture under `benchmarks/results/live-host/claude-325-3b-s2b/` proves field availability on Claude Code 2.1.308 for one session. It is not live-host credit, and no live-host credit run exists yet. Deterministic mechanism tests (replay through the real hook entry points, with a CI-only qualification preloader) prove the chain.
 
+PR-B adds a dedicated `outline-confirmation` evidence lane for Claude captures with separate B/O/D checks, a coordinator-sealed pre-dispatch handoff, pinned-inventory row binding, and an independent exact-O review. It is **mechanism and package evidence only**. The retained qualification does not yet establish `tool_input.prompt`, the coordinator identity, synchronous PreToolUse boundary or worker-root mapping, so positive live-host outline credit remains disabled. OpenCode and Codex receive no outline credit; missing or ambiguous capture stays unresolved and host tools remain fail-open. The outline result does not replace the aggregate B→D MUST result or the existing exact-D `quality-review` contract.
+
 ### Own-repository governance guard (PR #376)
 
 On `pull_request`, a standalone `doc-governance` job extracts `scripts/doc-governance-guard.js` from the event base commit and runs those bytes against the exact event base/head SHAs. Its nonzero result fails that job; `self-regression` and the other CI jobs run independently. The ordinary test suite may still run on GitHub's PR checkout SHA, which can be a synthetic merge commit; it is reported separately. The guard never falls back to the candidate copy. PR #376's reviewed base lacked the verifier; that historical bootstrap reported BOOTSTRAP_UNCHECKED without executing candidate bytes. Bases containing the guard (including main at 0ef0541c) execute the base-owned verifier. If a selected PR base lacks the guard, the wrapper retains the warning/step-summary-only bootstrap path with exit 0; this is unverified governance, not PASS. Every nonzero exit from an extracted verifier, including FAIL and BOOTSTRAP_UNCHECKED, fails the governance job. Other CI jobs run independently.

package/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through Harness: classify tier/topolog
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.45.0
+  version: 0.46.0
 ---
 
 # Harness Everything

package/harness-everything/scripts/doc-evidence.js

@@ -433,6 +433,61 @@ function evaluateObligation(obligation, context) {
     return entry ? baselineBound(item, entry) : candidateBound(item, path);
   };
 
+  if (capability === 'outline-confirmation') {
+    const candidates = matching.filter(item => reviewList.includes(item) && item.kind === 'outline-confirmation');
+    if (candidates.length !== 1) {
+      return result('unresolved', 'none',
+        'outline-confirmation requires one validated pre-draft O/review/handoff/dispatch record and a final D; generic execution and waivers do not qualify',
+        candidates.map(item => item.id));
+    }
+    const item = candidates[0];
+    const evidence = isPlainObject(item.outlineEvidence) ? item.outlineEvidence : null;
+    const sha = value => isSha256(value);
+    const digestsMatch = map => isPlainObject(map)
+      && Object.keys(map).sort(compareText).join('\0') === scopePaths.slice().sort(compareText).join('\0')
+      && scopePaths.every(path => sha(map[path]));
+    const identityValid = Boolean(evidence)
+      && evidence.schema === 'harness.outline-confirmation.v1' && evidence.state === 'validated'
+      && nonEmptyString(evidence.taskId) && nonEmptyString(evidence.attemptId)
+      && /^\d{1,2}$/.test(String(evidence.inventoryRowId || ''))
+      && /^[A-Z][A-Z0-9]{1,9}$/.test(String(evidence.domain || ''))
+      && sha(evidence.inventoryPinDigest) && sha(evidence.inventoryArtifactDigest)
+      && /^[0-9a-f]{40,64}$/.test(String(evidence.baselineCommit || ''))
+      && /^[0-9a-f]{40,64}$/.test(String(evidence.outlineCommit || ''))
+      && /^[0-9a-f]{40,64}$/.test(String(evidence.draftCommit || ''))
+      && /^[0-9a-f]{40,64}$/.test(String(evidence.mergedCommit || ''))
+      && evidence.outlineCommit !== evidence.draftCommit
+      && evidence.ancestry === 'strict-descendant'
+      && sha(evidence.handoffDigest) && sha(evidence.reviewCaptureDigest) && sha(evidence.reviewDigest)
+      && sha(evidence.seamDigest) && sha(evidence.dispatchInputDigest) && sha(evidence.writerLeaseDigest)
+      && nonEmptyString(evidence.dispatchToolUseId) && nonEmptyString(evidence.coordinatorPrincipal)
+      && nonEmptyString(evidence.reviewerPrincipal) && nonEmptyString(evidence.workerPrincipal)
+      && evidence.reviewerPrincipal !== evidence.coordinatorPrincipal
+      && evidence.reviewerPrincipal !== evidence.workerPrincipal
+      && Array.isArray(evidence.targetPaths)
+      && evidence.targetPaths.slice().sort(compareText).join('\0') === scopePaths.slice().sort(compareText).join('\0')
+      && digestsMatch(evidence.outlineArtifactDigests) && digestsMatch(evidence.draftArtifactDigests)
+      && digestsMatch(item.artifactDigests)
+      && scopePaths.every(path => evidence.draftArtifactDigests[path] === item.artifactDigests[path]
+        && candidateBound(item, path));
+    const mergeValid = evidence && (evidence.mergeCorrespondence === null
+      || (isPlainObject(evidence.mergeCorrespondence)
+        && ['accepted', 'changed'].includes(evidence.mergeCorrespondence.state)
+        && Array.isArray(evidence.mergeCorrespondence.targetPaths)
+        && evidence.mergeCorrespondence.targetPaths.slice().sort(compareText).join('\0')
+          === scopePaths.slice().sort(compareText).join('\0')));
+    const outlineProblems = [];
+    if (!identityValid) outlineProblems.push('envelope-or-current-D-binding');
+    if (!mergeValid) outlineProblems.push('merge-correspondence');
+    if (item.baseDigest !== baselineDigest) outlineProblems.push('original-B-digest');
+    if (outlineProblems.length) {
+      diagnostics.push({ code: 'outline-evidence-unresolved', obligationId,
+        message: `the outline evidence is incomplete or inconsistent: ${outlineProblems.join(', ')}` });
+      return result('unresolved', 'none', 'outline evidence is incomplete or unbound to the original B and final D', [item.id]);
+    }
+    return result('observed', 'pass', 'validated independent review of exact O, coordinator handoff, clean one-use dispatch, pinned inventory, and strict O-to-D evidence', [item.id]);
+  }
+
   for (const item of matching) {
     if (executionList.includes(item) && !completeExecution(item)) {
       diagnostics.push({

package/hooks/hooks.json

@@ -37,7 +37,7 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Bash|PowerShell|Task|Agent",
+        "matcher": "Bash|PowerShell|Task|Agent|Write|Edit|apply_patch",
         "hooks": [
           {
             "type": "command",

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

@@ -1,15 +1,16 @@
 'use strict';
 
 const fs = require('fs');
-const path = require('path');
+const { execFileSync } = require('child_process');
 const { _internals: U } = require('./doc-reconciliation-core');
+const { key } = require('./workflow-isolation');
 
 // Directory identity as in the producer: native realpath (Windows 8.3 names), case-insensitive on Windows.
 function samePath(a, b) {
   try {
-    const left = fs.realpathSync.native(path.resolve(a));
-    const right = fs.realpathSync.native(path.resolve(b));
-    return process.platform === 'win32' ? left.toLowerCase() === right.toLowerCase() : left === right;
+    fs.statSync(a);
+    fs.statSync(b);
+    return key(a) === key(b);
   } catch { return false; }
 }
 
@@ -19,6 +20,109 @@ function artifactsFor(records) {
 function prdDigest(artifacts) {
   return U.sha(JSON.stringify(Object.keys(artifacts).filter(p => p.startsWith('docs/prd/')).sort().map(p => [p, artifacts[p].digest])));
 }
+
+function git(root, args, binary = false) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) if (key.startsWith('GIT_')) delete env[key];
+  return execFileSync('git', ['-C', root, ...args], { env, encoding: binary ? null : 'utf8',
+    timeout: 10000, maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+}
+
+function shaBytes(value) { return U.sha(Buffer.from(value)); }
+
+function outlineEventValid({ event, snapshot, paths, artifacts, baselineArtifacts } = {}) {
+  let stage = 'envelope';
+  try {
+    const evidence = event?.outlineEvidence;
+    const root = snapshot.originContext.workspaceRoot;
+    const baseline = snapshot.originContext.baseline;
+    if (snapshot.originContext.activeHost !== 'claude-code' || !U.record(evidence)
+      || evidence.schema !== 'harness.outline-confirmation.v1' || evidence.state !== 'validated'
+      || evidence.baselineCommit !== baseline?.commit || evidence.taskId !== snapshot.identity.taskId
+      || !/^[0-9a-f]{40,64}$/.test(String(evidence.outlineCommit || ''))
+      || !/^[0-9a-f]{40,64}$/.test(String(evidence.draftCommit || ''))
+      || !/^[0-9a-f]{40,64}$/.test(String(evidence.mergedCommit || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.handoffDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.reviewCaptureDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.reviewDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.seamDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.dispatchInputDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.writerLeaseDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.inventoryPinDigest || ''))
+      || !/^[0-9a-f]{64}$/.test(String(evidence.inventoryArtifactDigest || ''))
+      || !Array.isArray(evidence.targetPaths) || U.stable(evidence.targetPaths) !== U.stable(paths)
+      || !U.record(evidence.outlineArtifactDigests) || !U.record(evidence.draftArtifactDigests)
+      || !U.record(evidence.outlineBlobOids) || !U.record(evidence.draftBlobOids)
+      || U.stable(Object.keys(evidence.outlineArtifactDigests).sort()) !== U.stable(paths)
+      || U.stable(Object.keys(evidence.draftArtifactDigests).sort()) !== U.stable(paths)
+      || U.stable(Object.keys(evidence.outlineBlobOids).sort()) !== U.stable(paths)
+      || U.stable(Object.keys(evidence.draftBlobOids).sort()) !== U.stable(paths)
+      || !U.record(event.draftArtifactDigests) || U.stable(Object.keys(event.draftArtifactDigests).sort()) !== U.stable(paths)
+      || U.stable(event.draftArtifactDigests) !== U.stable(evidence.draftArtifactDigests)
+      || !U.record(event.reviewedArtifactDigests)
+      || !paths.every(p => /^[0-9a-f]{64}$/.test(String(evidence.outlineArtifactDigests[p] || ''))
+        && /^[0-9a-f]{64}$/.test(String(evidence.draftArtifactDigests[p] || ''))
+        && /^[0-9a-f]{40,64}$/.test(String(evidence.outlineBlobOids[p] || ''))
+        && /^[0-9a-f]{40,64}$/.test(String(evidence.draftBlobOids[p] || ''))
+        && artifacts[p]?.digest === evidence.draftArtifactDigests[p])
+      || !/^[0-9a-f]{40,64}$/.test(String(evidence.baselineCommit || ''))
+      || !/^[0-9a-f]{40,64}$/.test(String(evidence.outlineTree || ''))
+      || !/^[0-9a-f]{40,64}$/.test(String(evidence.draftTree || ''))
+      || !U.text(evidence.coordinatorPrincipal) || !U.text(evidence.reviewerPrincipal) || !U.text(evidence.workerPrincipal)
+      || evidence.reviewerPrincipal === evidence.coordinatorPrincipal || evidence.reviewerPrincipal === evidence.workerPrincipal
+      || evidence.ancestry !== 'strict-descendant' || evidence.outlineCommit === evidence.draftCommit) return stage;
+
+    stage = 'reviewed-object-binding';
+    const pinPath = Object.keys(event.reviewedArtifactDigests).filter(p => p.startsWith('doc-reconciliation/outline-confirmation/inventory/'));
+    if (pinPath.length !== 1 || event.reviewedArtifactDigests[pinPath[0]] !== evidence.inventoryArtifactDigest
+      || Object.keys(event.reviewedArtifactDigests).length !== paths.length + 1
+      || !paths.every(p => event.reviewedArtifactDigests[p] === evidence.outlineArtifactDigests[p])) return stage;
+
+    stage = 'current-commit-binding';
+    const head = git(root, ['rev-parse', '--verify', 'HEAD^{commit}']).trim();
+    const tree = git(root, ['rev-parse', '--verify', 'HEAD^{tree}']).trim();
+    if (head !== evidence.mergedCommit || tree !== evidence.draftTree) return stage;
+    const verified = commit => git(root, ['rev-parse', '--verify', `${commit}^{commit}`]).trim() === commit;
+    if (![evidence.baselineCommit, evidence.outlineCommit, evidence.draftCommit, evidence.mergedCommit].every(verified)) return 'git-object-missing';
+    if (evidence.baselineCommit === evidence.outlineCommit) return 'B-to-O-ancestry';
+    stage = 'B-to-O-ancestry';
+    try { git(root, ['merge-base', '--is-ancestor', evidence.baselineCommit, evidence.outlineCommit]); }
+    catch { return stage; }
+    stage = 'O-to-D-ancestry';
+    try { git(root, ['merge-base', '--is-ancestor', evidence.outlineCommit, evidence.draftCommit]); }
+    catch { return stage; }
+    stage = 'merge-correspondence';
+    if (evidence.mergeCorrespondence === null) {
+      if (evidence.draftCommit !== evidence.mergedCommit) return stage;
+    } else {
+      const merge = evidence.mergeCorrespondence;
+      if (!U.record(merge) || !['accepted', 'changed'].includes(merge.state)
+        || merge.draftCommit !== evidence.draftCommit || merge.mergedCommit !== evidence.mergedCommit
+        || U.stable(merge.targetPaths) !== U.stable(paths) || !U.record(merge.targetBlobs)) return stage;
+      for (const p of paths) {
+        const draftOid = git(root, ['rev-parse', `${evidence.draftCommit}:${p}`]).trim();
+        const mergedOid = git(root, ['rev-parse', `${evidence.mergedCommit}:${p}`]).trim();
+        if (merge.targetBlobs[p]?.draft !== draftOid || merge.targetBlobs[p]?.merged !== mergedOid
+          || (merge.state === 'accepted' && draftOid !== mergedOid)
+          || (merge.state === 'changed' && draftOid === mergedOid)) return stage;
+      }
+    }
+    stage = 'target-object-binding';
+    for (const p of paths) {
+      const atBase = git(root, ['ls-tree', '-r', '--name-only', evidence.baselineCommit, '--', p]).trim().split('\n').filter(Boolean);
+      if (atBase.includes(p)) return 'target-existed-at-B';
+      if (git(root, ['rev-parse', `${evidence.outlineCommit}:${p}`]).trim() !== evidence.outlineBlobOids[p]
+        || git(root, ['rev-parse', `${evidence.mergedCommit}:${p}`]).trim() !== evidence.draftBlobOids[p]) return stage;
+      const outlineBytes = git(root, ['show', `${evidence.outlineCommit}:${p}`], true);
+      const draftBytes = git(root, ['show', `${evidence.mergedCommit}:${p}`], true);
+      if (shaBytes(outlineBytes) !== evidence.outlineArtifactDigests[p]
+        || shaBytes(draftBytes) !== evidence.draftArtifactDigests[p]
+        || shaBytes(draftBytes) !== artifacts[p]?.digest) return 'candidate-artifact-binding';
+    }
+    return true;
+  } catch { return 'git-verification-failed'; }
+}
+
 function acceptDocEvents(input = {}, dependencies = {}) {
   const { snapshot, eventRefs } = U.record(input) ? input : {};
   const originProvider = dependencies?.originProvider;
@@ -91,8 +195,12 @@ function acceptDocEvents(input = {}, dependencies = {}) {
       seenCapabilities.add(event?.capability);
       const paths = obligation?.scope?.paths || [];
       if (!Array.isArray(event?.paths) || U.stable([...event.paths].sort()) !== U.stable([...paths].sort())) reject('scope-mismatch');
+      const outlineCapability = event?.capability === 'outline-confirmation';
       const digests = event?.kind === 'review' ? event.reviewedArtifactDigests : event?.artifactDigests;
-      if (!U.record(digests)) reject('artifact-mismatch');
+      if (outlineCapability) {
+        const outlineValidation = outlineEventValid({ event, snapshot, paths, artifacts, baselineArtifacts });
+        if (outlineValidation !== true) reject(`outline-${outlineValidation || 'evidence-invalid'}`);
+      } else if (!U.record(digests)) reject('artifact-mismatch');
       else {
         for (const p of paths) {
           if (artifacts[p] && digests[p] !== artifacts[p].digest) reject('artifact-mismatch');
@@ -135,10 +243,13 @@ function acceptDocEvents(input = {}, dependencies = {}) {
         if (!context?.principals?.executors?.includes(event?.principalId)) reject('origin-untrusted');
       }
       if (problems.length) { rejected.push(...problems); continue; }
-      const adapted = { id: reference, obligationId, kind: event.kind === 'review' ? 'review' : 'execution',
+      const adapted = { id: reference, obligationId,
+        kind: outlineCapability ? 'outline-confirmation' : event.kind === 'review' ? 'review' : 'execution',
         paths: [...paths], provenance: event.provenance, baseDigest: snapshot.identity.baselineDigest,
-        artifactDigests: U.clone(digests), ...(event.baselineArtifacts ? { baselineArtifacts: U.clone(event.baselineArtifacts) } : {}) };
-      if (event.kind === 'review') Object.assign(adapted, { verdict: event.verdict, summary: event.summary });
+        artifactDigests: U.clone(outlineCapability ? event.draftArtifactDigests : digests),
+        ...(event.baselineArtifacts ? { baselineArtifacts: U.clone(event.baselineArtifacts) } : {}) };
+      if (outlineCapability) Object.assign(adapted, { outlineEvidence: U.clone(event.outlineEvidence) });
+      else if (event.kind === 'review') Object.assign(adapted, { verdict: event.verdict, summary: event.summary });
       else Object.assign(adapted, { command: event.command, exitCode: event.exitCode });
       if (event.capability === 'conflict-check') {
         adapted.candidatePrdSet = { digest: prdDigest(artifacts), complete: true, paths: Object.keys(artifacts).filter(p => p.startsWith('docs/prd/')).sort() };
@@ -146,7 +257,8 @@ function acceptDocEvents(input = {}, dependencies = {}) {
       (event.kind === 'review' ? checkerInputs.reviewRecords : checkerInputs.executionRecords).push(adapted);
       acceptedIndex[reference] = { reference, eventId: event.eventId, obligationId, capability: event.capability,
         paths: [...paths], identity: U.clone(event.identity), originRef: response.originRef, artifactBinding: snapshot.identity.candidateDigest,
-        artifactDigests: U.clone(digests), event };
+        artifactDigests: U.clone(outlineCapability ? event.draftArtifactDigests : digests),
+        ...(outlineCapability ? { reviewedArtifactDigests: U.clone(event.reviewedArtifactDigests) } : {}), event };
     }
     if (diagnostics.length || rejected.length) out.state = 'unresolved';
     return out;