harness-everything 0.46.3 → 0.47.0

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

@@ -8,6 +8,7 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 const { spawnSync } = require('child_process');
 const { canonical } = require(path.resolve(__dirname, '../hooks/scripts/lib/workflow-isolation.js'));
+const { stage: stageQualificationTree } = require('./lib/doc-reconciliation-staged-tree.js');
 
 const ROOT = path.resolve(__dirname, '..');
 const provider = require(path.join(ROOT, 'hooks/scripts/lib/doc-reconciliation-provider.js'));
@@ -76,7 +77,10 @@ function outlineText({ complete = false, decisionPlaceholder = false, duplicateD
 
 function createOutlineFixture(options = {}) {
   const root = canonical(fs.mkdtempSync(path.join(os.tmpdir(), 'prb-outline-fixture-')));
-  const target = options.target || 'docs/adr/DOCS-001.md';
+  const retainedInventory = options.retainedInventory === true;
+  const target = options.target || (retainedInventory ? 'docs/adr/EVID-001.md' : 'docs/adr/DOCS-001.md');
+  const rowId = options.rowId || (retainedInventory ? '17' : '20');
+  const domain = options.domain || (retainedInventory ? 'EVID' : 'DOCS');
   const taskId = options.taskId || 'task-prb';
   const attemptId = options.attemptId || 'attempt-1';
   const sessionId = options.sessionId || 'author-session';
@@ -85,7 +89,7 @@ function createOutlineFixture(options = {}) {
     ? `${root}${path.sep}..${path.sep}${path.basename(root)}` : root;
   const workflowId = 'workflow-prb';
   const workflowRevision = 2;
-  const config = JSON.stringify({ governed: [{ path: 'docs/adr/*.md', role: 'adr' }], domains: ['DOCS'], derived: [] }, null, 2) + '\n';
+  const config = JSON.stringify({ governed: [{ path: 'docs/adr/*.md', role: 'adr' }], domains: [domain], derived: [] }, null, 2) + '\n';
   const configDigest = sha(config);
   fs.mkdirSync(path.join(root, '.agents/harness-everything'), { recursive: true });
   fs.mkdirSync(path.dirname(path.join(root, target)), { recursive: true });
@@ -110,7 +114,7 @@ function createOutlineFixture(options = {}) {
     decisionPlaceholder: options.decisionPlaceholder === true,
     duplicateDecision: options.duplicateDecision === true,
     indentedDecision: options.indentedDecision === true,
-    rowId: options.rowId || '20', target, domain: options.domain || 'DOCS',
+    rowId, target, domain,
   }));
   fixtureGit(root, ['add', '-A']);
   fixtureGit(root, ['commit', '-q', '-m', 'O outline']);
@@ -119,16 +123,20 @@ function createOutlineFixture(options = {}) {
   const outlineBytes = fs.readFileSync(path.join(root, target));
   const outlineBlob = fixtureGit(root, ['rev-parse', `HEAD:${target}`]);
 
-  const pinDigest = sha(syntheticInventory);
-  const expectedPin = {
+  const inventoryBytes = retainedInventory
+    ? fs.readFileSync(path.join(ROOT, 'benchmarks/results/live-host/claude-341-outline-dispatch-2026-10-28/inventory/2741bd4514d2cd68f57d93a2b3ce94cbe597ca62d30e26f0ca58e882df5b03c6.md'))
+    : Buffer.from(syntheticInventory);
+  const pinDigest = sha(inventoryBytes);
+  const expectedPin = retainedInventory ? internals.OUTLINE_INVENTORY_PIN : {
     source: 'synthetic://approved-inventory', sha256: pinDigest, runId: 'synthetic-run', inputSha: 'abcdef012345',
     approvalRef: { issue: 325, commentId: 'synthetic-comment', decision: 1 },
     retainedArtifactPath: `inventory/${pinDigest}.md`,
   };
+  if (retainedInventory) assert.strictEqual(pinDigest, expectedPin.sha256, 'retained inventory bytes must match the pinned digest');
   const outlineRoot = path.join(sessionDir, 'doc-reconciliation/outline-confirmation');
   const inventoryDir = path.join(outlineRoot, 'inventory');
   fs.mkdirSync(inventoryDir, { recursive: true });
-  fs.writeFileSync(path.join(inventoryDir, `${pinDigest}.md`), syntheticInventory);
+  fs.writeFileSync(path.join(inventoryDir, `${pinDigest}.md`), inventoryBytes);
   writeJson(path.join(inventoryDir, 'inventory-pin.json'), expectedPin);
   const requirementIds = ['prb'];
   const workspaceId = 'ws-' + internals.digestText(internals.captureJson({ workspaceRoot: root }));
@@ -183,7 +191,7 @@ function createOutlineFixture(options = {}) {
     'Review verdict: approve',
     `Reviewed artifact: ${target} sha256:${sha(outlineBytes)}`,
     `Reviewed artifact: ${inventoryPath} sha256:${pinDigest}`,
-    `Summary: Approved inventory row 20 for ${target} in domain DOCS.`,
+    `Summary: Approved inventory row ${rowId} for ${target} in domain ${domain}.`,
   ].join('\n');
   const reviewResultPayload = {
     session_id: sessionId, cwd: root, hook_event_name: 'PostToolUse', tool_name: 'Task',
@@ -229,7 +237,7 @@ function createOutlineFixture(options = {}) {
     baseline: { root, commit: baselineCommit, tree: baselineTree, configDigest },
     configDigest, targetPaths: [target], draftWorktreeRoot: workerRoot,
     outline: { commit: outlineCommit, tree: outlineTree, targetBlobs: { [target]: { blobOid: outlineBlob, storedBytesSha256: sha(outlineBytes) } } },
-    inventory: { ...expectedPin, rowId: options.rowId || '20', domain: options.domain || 'DOCS', targetPaths: [target] },
+    inventory: { ...expectedPin, rowId, domain, targetPaths: [target] },
     reviewCaptureRef: reviewStop.ref, reviewCaptureDigest: reviewRecordDigest, reviewDigest: reviewStop.reviewDigest,
     coordinatorPrincipal: sessionId, writerLeaseId: lease.id, writerLeaseDigest: leaseDigest,
     draftDispatchToken: options.token || 'token-1',
@@ -311,9 +319,10 @@ function createOutlineFixture(options = {}) {
   function finishDraft({ draft = true, nonDescendant = false, finalReview = false, baselineRoot = root,
     omitWorkerStart = false, omitWorkerResult = false, omitWorkerStop = false, tamperHandoff = false,
     providerSessionId = sessionId, providerTaskId = taskId, providerBaseline = { root, commit: baselineCommit },
-    runPilot = false, handAuthoredCapture = false, removeSeam = false, mutateAfterFinalReview = false } = {}) {
+    runPilot = false, handAuthoredCapture = false, removeSeam = false, mutateAfterFinalReview = false,
+    postWorkerCaptures = [] } = {}) {
     if (draft) {
-      fs.writeFileSync(path.join(root, target), `---\nid: DOCS-001\nstatus: proposed\n---\n\n## Decision\nFinal D for row 20.\n`);
+      fs.writeFileSync(path.join(root, target), `---\nid: ${domain}-001\nstatus: proposed\n---\n\n## Decision\nFinal D for row ${rowId}.\n`);
       fixtureGit(root, ['add', '-A']);
       fixtureGit(root, ['commit', '-q', '-m', 'D final draft']);
     }
@@ -321,7 +330,7 @@ function createOutlineFixture(options = {}) {
       fixtureGit(root, ['checkout', '--orphan', 'unrelated']);
       fixtureGit(root, ['rm', '-rf', '.']);
       fs.mkdirSync(path.dirname(path.join(root, target)), { recursive: true });
-      fs.writeFileSync(path.join(root, target), `---\nid: DOCS-001\nstatus: proposed\n---\n\n## Decision\nUnrelated D.\n`);
+      fs.writeFileSync(path.join(root, target), `---\nid: ${domain}-001\nstatus: proposed\n---\n\n## Decision\nUnrelated D for row ${rowId}.\n`);
       fixtureGit(root, ['add', '-A']);
       fixtureGit(root, ['-c', 'user.name=outline-fixture', '-c', 'user.email=outline-fixture@invalid', 'commit', '-q', '-m', 'unrelated D']);
     }
@@ -381,8 +390,8 @@ function createOutlineFixture(options = {}) {
         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,
+      }, 'SubagentStop', root)] : []), ...postWorkerCaptures];
+    const qualification = options.noFakeQualification ? undefined : { source: 'fake-test-fixture', faked: true, toolUseIdPopulated: true,
       agentIdPopulated: true, outlineDispatchCaptureVerified: true };
     if (removeSeam && capture.outlineDispatch?.seamRef) {
       fs.rmSync(path.join(sessionDir, capture.outlineDispatch.seamRef), { force: true });
@@ -396,7 +405,8 @@ function createOutlineFixture(options = {}) {
     const origin = provider.createClaudeOriginProvider({
       hostId: 'claude-code', sessionId: providerSessionId, workspaceRoot: root, workflowId, workflowRevision, taskId: providerTaskId,
       principals: { author: providerSessionId, executors: [] }, baseline: providerBaseline,
-      captures, sessionDir, taskBinding, qualification, outlineFixture: { expectedPin },
+      captures, sessionDir, taskBinding,
+      ...(qualification ? { qualification, outlineFixture: { expectedPin } } : {}),
     });
     const identity = {
       workspaceId: origin.resolveContext({}).context.workspaceId, sessionId: providerSessionId, workflowId, workflowRevision, taskId: providerTaskId,
@@ -408,8 +418,8 @@ function createOutlineFixture(options = {}) {
     if (runPilot) {
       const previousSwitch = process.env.HARNESS_DOC_RECONCILIATION_PILOT;
       const previousFactory = provider.createClaudeOriginProvider;
-      provider.createClaudeOriginProvider = input => previousFactory({ ...input, qualification,
-        outlineFixture: { expectedPin }, taskBinding });
+      provider.createClaudeOriginProvider = input => previousFactory({ ...input,
+        ...(qualification ? { qualification, outlineFixture: { expectedPin } } : {}), taskBinding });
       process.env.HARNESS_DOC_RECONCILIATION_PILOT = '1';
       const context = { root, sessionId, sessionDir, activeHost: 'claude-code', workflow: {
         workflowId, revision: workflowRevision, strategy: 'iterative-single', state: 'running',
@@ -518,6 +528,55 @@ test('coordinator-seeded inventory pin requires exact bytes, all fixed fields, a
   assert.strictEqual(internals.resolveInventoryRow(multiDomainResult, '20').state, 'unresolved', 'ambiguous domain mapping is unresolved');
 });
 
+test('the trusted inventory pin maps only owner-approved VERI rows 15–18 to EVID', () => {
+  const pin = internals.OUTLINE_INVENTORY_PIN;
+  const bytes = fs.readFileSync(path.join(ROOT,
+    'benchmarks/results/live-host/claude-341-outline-dispatch-2026-10-28/inventory/2741bd4514d2cd68f57d93a2b3ce94cbe597ca62d30e26f0ca58e882df5b03c6.md'));
+  const mapping = [{ rowIds: ['15', '16', '17', '18'], sourceDomain: 'VERI', domain: 'EVID',
+    approvalRef: '../e1-feasibility-2026-10-28/owner-decision-veri-evid.md' }];
+  assert.deepStrictEqual(pin.rowDomainMappings, mapping, 'the owner approval is part of the trusted pin');
+  const valid = internals.validateOutlineInventoryPin({ bytes, pin, expectedPin: pin });
+  assert.strictEqual(valid.state, 'accepted');
+  for (const rowId of ['15', '16', '17', '18']) {
+    assert.deepStrictEqual(internals.resolveInventoryRow(valid, rowId).row, { rowId, domain: 'EVID' });
+  }
+  const substituted = { ...pin, rowDomainMappings: [{ ...mapping[0], domain: 'VERI' }] };
+  const stale = internals.validateOutlineInventoryPin({ bytes, pin: substituted, expectedPin: pin });
+  assert.strictEqual(stale.state, 'unresolved', 'a substituted domain cannot change the trusted mapping');
+  assert.strictEqual(stale.reason, 'inventory-pin-mismatch');
+});
+
+test('pilot offers structured SubagentStop reviews only and preserves drafter independence rejection', () => {
+  const sessionDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prb-review-candidates-'));
+  const author = 'author-session';
+  const draft = provider.buildCaptureRecord({ session_id: author, hook_event_name: 'PostToolUse', tool_name: 'Task',
+    tool_use_id: 'draft-dispatch', tool_response: { agentId: 'draft-worker', status: 'completed' } }, 'PostToolUse', '/tmp');
+  const ordinary = provider.buildCaptureRecord({ session_id: author, hook_event_name: 'SubagentStop', agent_id: 'draft-worker',
+    last_assistant_message: 'Draft complete. The document is ready.' }, 'SubagentStop', '/tmp');
+  const reviewResult = provider.buildCaptureRecord({ session_id: author, hook_event_name: 'PostToolUse', tool_name: 'Task',
+    tool_use_id: 'review-dispatch', tool_response: { agentId: 'independent-reviewer', status: 'completed' } }, 'PostToolUse', '/tmp');
+  const approval = provider.buildCaptureRecord({ session_id: author, hook_event_name: 'SubagentStop', agent_id: 'independent-reviewer',
+    last_assistant_message: `Review verdict: approve\nReviewed artifact: docs/adr/EVID-001.md sha256:${'a'.repeat(64)}\nSummary: exact ADR reviewed.` }, 'SubagentStop', '/tmp');
+  for (const record of [draft, ordinary, reviewResult, approval]) provider.writeImmutableEvent(sessionDir, record);
+  provider.rebuildJournalView(sessionDir);
+  const context = { sessionDir, activeHost: 'claude-code', workflow: { docReconciliationTask: { taskId: 'task-review-selection' } } };
+  const captures = provider.readCaptureView(sessionDir).records;
+  const reviewRefs = pilot._internals.captureReferences(context).filter(ref => ref.endsWith('#quality-review'));
+  assert.deepStrictEqual(reviewRefs, [`${approval.ref}#quality-review`], 'ordinary draft completion is not a review candidate');
+  assert.strictEqual(provider.reviewRecordIndependent(approval, captures, { author, executors: ['draft-worker'] }), true);
+
+  const drafterApproval = provider.buildCaptureRecord({ session_id: author, hook_event_name: 'SubagentStop', agent_id: 'draft-worker',
+    last_assistant_message: `Review verdict: approve\nReviewed artifact: docs/adr/EVID-001.md sha256:${'a'.repeat(64)}\nSummary: self approval.` }, 'SubagentStop', '/tmp');
+  provider.writeImmutableEvent(sessionDir, drafterApproval);
+  provider.rebuildJournalView(sessionDir);
+  const withDrafterApproval = provider.readCaptureView(sessionDir).records;
+  assert.ok(pilot._internals.captureReferences(context).includes(`${drafterApproval.ref}#quality-review`),
+    'an explicit approval remains visible to the provider independence check');
+  assert.strictEqual(provider.reviewRecordIndependent(drafterApproval, withDrafterApproval,
+    { author, executors: ['draft-worker'] }), false, 'a drafter cannot approve its own work');
+  fs.rmSync(sessionDir, { recursive: true, force: true });
+});
+
 test('generic successful execution or waiver cannot pass outline-confirmation', () => {
   const target = 'docs/adr/DOCS-001.md';
   const digest = sha('final D bytes');
@@ -921,6 +980,74 @@ test('outline evidence binds exact task, B, O blobs, independent review, worker
     assert.strictEqual(completed.result.status, 'accepted',
       `a reviewer that started and stopped in O before the dispatch is not a competing writer: ${JSON.stringify(completed.result)}`);
   } finally { stoppedReviewer.cleanup(); }
+
+  const postDraftReviewer = createOutlineFixture();
+  try {
+    const reviewer = 'post-draft-reviewer';
+    const captures = [
+      provider.buildCaptureRecord({ session_id: postDraftReviewer.sessionId, cwd: postDraftReviewer.root,
+        hook_event_name: 'SubagentStart', agent_id: reviewer, agent_type: 'reviewer' }, 'SubagentStart', postDraftReviewer.root),
+      provider.buildCaptureRecord({ session_id: postDraftReviewer.sessionId, cwd: postDraftReviewer.root,
+        hook_event_name: 'PostToolUse', tool_name: 'Read', tool_use_id: 'post-draft-read', agent_id: reviewer,
+        tool_input: { file_path: postDraftReviewer.target }, tool_response: { interrupted: false } }, 'PostToolUse', postDraftReviewer.root),
+      provider.buildCaptureRecord({ session_id: postDraftReviewer.sessionId, cwd: postDraftReviewer.root,
+        hook_event_name: 'PostToolUse', tool_name: 'Task', tool_use_id: 'post-draft-review',
+        tool_response: { agentId: reviewer, status: 'completed' } }, 'PostToolUse', postDraftReviewer.root),
+      provider.buildCaptureRecord({ session_id: postDraftReviewer.sessionId, cwd: postDraftReviewer.root,
+        hook_event_name: 'SubagentStop', agent_id: reviewer, agent_type: 'reviewer' }, 'SubagentStop', postDraftReviewer.root),
+    ];
+    const completed = postDraftReviewer.finishDraft({ postWorkerCaptures: captures });
+    assert.strictEqual(completed.result.status, 'accepted',
+      `a same-root reviewer starting after the draft worker's Stop does not overlap the draft interval: ${JSON.stringify(completed.result)}`);
+  } finally { postDraftReviewer.cleanup(); }
+
+  for (const [name, arrange] of [
+    ['post-stop reviewer missing Stop', fixture => [
+      provider.buildCaptureRecord({ session_id: fixture.sessionId, cwd: fixture.root,
+        hook_event_name: 'SubagentStart', agent_id: 'post-draft-reviewer', agent_type: 'reviewer' }, 'SubagentStart', fixture.root),
+    ]],
+    ['post-stop reviewer with duplicate Starts', fixture => {
+      const start = provider.buildCaptureRecord({ session_id: fixture.sessionId, cwd: fixture.root,
+        hook_event_name: 'SubagentStart', agent_id: 'post-draft-reviewer', agent_type: 'reviewer' }, 'SubagentStart', fixture.root);
+      return [start, { ...start, ref: `${start.ref}:dup`, captureId: `${start.captureId}:dup` }, provider.buildCaptureRecord({
+        session_id: fixture.sessionId, cwd: fixture.root, hook_event_name: 'SubagentStop',
+        agent_id: 'post-draft-reviewer', agent_type: 'reviewer' }, 'SubagentStop', fixture.root)];
+    }],
+    ['post-stop reviewer Stop before Start', fixture => [
+      provider.buildCaptureRecord({ session_id: fixture.sessionId, cwd: fixture.root,
+        hook_event_name: 'SubagentStop', agent_id: 'post-draft-reviewer', agent_type: 'reviewer' }, 'SubagentStop', fixture.root),
+      provider.buildCaptureRecord({ session_id: fixture.sessionId, cwd: fixture.root,
+        hook_event_name: 'SubagentStart', agent_id: 'post-draft-reviewer', agent_type: 'reviewer' }, 'SubagentStart', fixture.root),
+    ]],
+  ]) {
+    const fixture = createOutlineFixture();
+    try {
+      const completed = fixture.finishDraft({ postWorkerCaptures: arrange(fixture) });
+      assert.ok(completed.result.diagnostics?.some(item => item.code === 'outline-competing-writer-start'),
+        `${name} cannot use the post-stop exception: ${JSON.stringify(completed.result)}`);
+    } finally { fixture.cleanup(); }
+  }
+
+  const postDraftWriter = createOutlineFixture();
+  try {
+    const reviewer = 'post-draft-reviewer';
+    const captures = [
+      provider.buildCaptureRecord({ session_id: postDraftWriter.sessionId, cwd: postDraftWriter.root,
+        hook_event_name: 'SubagentStart', agent_id: reviewer, agent_type: 'reviewer' }, 'SubagentStart', postDraftWriter.root),
+      provider.buildCaptureRecord({ session_id: postDraftWriter.sessionId, cwd: postDraftWriter.root,
+        hook_event_name: 'PostToolUse', tool_name: 'Edit', tool_use_id: 'post-draft-edit', agent_id: reviewer,
+        tool_input: { file_path: postDraftWriter.target }, tool_response: { interrupted: false } }, 'PostToolUse', postDraftWriter.root),
+      provider.buildCaptureRecord({ session_id: postDraftWriter.sessionId, cwd: postDraftWriter.root,
+        hook_event_name: 'PostToolUse', tool_name: 'Task', tool_use_id: 'post-draft-review',
+        tool_response: { agentId: reviewer, status: 'completed' } }, 'PostToolUse', postDraftWriter.root),
+      provider.buildCaptureRecord({ session_id: postDraftWriter.sessionId, cwd: postDraftWriter.root,
+        hook_event_name: 'SubagentStop', agent_id: reviewer, agent_type: 'reviewer' }, 'SubagentStop', postDraftWriter.root),
+    ];
+    const completed = postDraftWriter.finishDraft({ postWorkerCaptures: captures });
+    assert.ok(completed.result.diagnostics?.some(item => item.code === 'outline-writer-activity-ambiguous'),
+      `a write after the post-stop reviewer start remains ambiguous: ${JSON.stringify(completed.result)}`);
+  } finally { postDraftWriter.cleanup(); }
+
   for (const [name, arrange] of [
     ['reviewer stop after the dispatch', fixture => {
       const stop = fixture.reviewCaptures.findIndex(item => item.event === 'SubagentStop');
@@ -1049,6 +1176,23 @@ const outlineMappingV2 = {
   workerRootField: 'cwd',
 };
 
+test('valid separate outline export opens outline qualification', () => {
+  const staged = stageQualificationTree('source');
+  try {
+    const records = [qualificationDispatch(), qualificationStart(), qualificationResult(), qualificationStop()];
+    const bytes = Buffer.from(records.map(record => JSON.stringify(record)).join('\n') + '\n');
+    const file = 'doc-reconciliation-outline-capture.sanitized.jsonl';
+    fs.writeFileSync(path.join(staged.libDir, file), bytes);
+    staged.writeExport(staged.validExport({
+      outlineDispatchCapture: { mapping: outlineMappingV2, file, sha256: sha(bytes), hostVersion: '2.1.312',
+        run: 'run8', baseline: '1bd0f805031c5577a6e7f72a9bc5b41618b71fc1' },
+    }));
+    const outcome = require(path.join(staged.libDir, 'doc-reconciliation-provider.js'))
+      ._internals.validateOutlineCaptureQualification({ hostId: 'claude-code' });
+    assert.strictEqual(outcome.open, true, JSON.stringify(outcome));
+  } finally { staged.cleanup(); }
+});
+
 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 } : {}) };
@@ -1071,6 +1215,118 @@ function qualificationResult(id = 'dispatch-1', agentId = 'worker', status = 'co
     ...(legacyAgentId !== undefined ? { agent_id: legacyAgentId } : {}), tool_response: toolResponse };
 }
 
+function stagedOutlineOutcome(staged) {
+  return require(path.join(staged.libDir, 'doc-reconciliation-provider.js'))
+    ._internals.validateOutlineCaptureQualification({ hostId: 'claude-code' });
+}
+
+function writeStagedOutlineEvidence(staged, records) {
+  const file = 'doc-reconciliation-outline-capture.sanitized.jsonl';
+  const bytes = Buffer.from(records.map(record => JSON.stringify(record)).join('\n') + '\n');
+  fs.writeFileSync(path.join(staged.libDir, file), bytes);
+  const wrapper = { mapping: outlineMappingV2, file, sha256: sha(bytes), hostVersion: '2.1.312', run: 'run8',
+    baseline: '1bd0f805031c5577a6e7f72a9bc5b41618b71fc1' };
+  staged.writeExport(staged.validExport({ outlineDispatchCapture: wrapper }));
+  return { wrapper, filePath: path.join(staged.libDir, file), bytes };
+}
+
+test('shipped run8 capture opens production qualification without DI', () => {
+  const qualification = internals.validateOutlineCaptureQualification({ hostId: 'claude-code' });
+  assert.strictEqual(qualification.open, true, JSON.stringify(qualification));
+  assert.strictEqual(qualification.source, 'validated-export');
+  assert.strictEqual(qualification.captureFile, 'doc-reconciliation-outline-capture.sanitized.jsonl');
+});
+
+test('shipped run8 export resolves the real-hook integrated fixture without fake qualification', () => {
+  const originalFactory = provider.createClaudeOriginProvider;
+  let originInput;
+  provider.createClaudeOriginProvider = input => {
+    originInput = input;
+    return originalFactory(input);
+  };
+  const fixture = createOutlineFixture({ realHook: true, retainedInventory: true, noFakeQualification: true });
+  try {
+    const completed = fixture.finishDraft();
+    assert.strictEqual(completed.result.status, 'accepted', JSON.stringify(completed.result));
+    assert.strictEqual(Object.hasOwn(originInput, 'qualification'), false, 'production resolution must use the shipped export');
+  } finally {
+    provider.createClaudeOriginProvider = originalFactory;
+    fixture.cleanup();
+  }
+});
+
+test('mapped row 17 dispatch accepts EVID-001 while the old VERI request and a substituted domain reject', () => {
+  const valid = createOutlineFixture({ retainedInventory: true, noFakeQualification: true });
+  try {
+    const completed = valid.finishDraft();
+    assert.strictEqual(completed.result.status, 'accepted', JSON.stringify(completed.result));
+    assert.strictEqual(completed.result.event.outlineEvidence.inventoryRowId, '17');
+    assert.strictEqual(completed.result.event.outlineEvidence.domain, 'EVID');
+  } finally { valid.cleanup(); }
+
+  const unapprovedVeri = createOutlineFixture({ retainedInventory: true, rowId: '16',
+    target: 'docs/adr/VERI-001.md', domain: 'VERI' });
+  try {
+    assert.strictEqual(unapprovedVeri.capture.outlineDispatch.state, 'unresolved');
+    assert.ok(unapprovedVeri.capture.outlineDispatch.reasons.includes('outline-inventory-binding-mismatch'));
+  } finally { unapprovedVeri.cleanup(); }
+
+  const unchangedRun8 = createOutlineFixture({ retainedInventory: true, rowId: '17',
+    target: 'docs/adr/EVID-001-verify-all-evidence.md', domain: 'EVID' });
+  try {
+    assert.strictEqual(unchangedRun8.capture.outlineDispatch.state, 'unresolved');
+    assert.ok(unchangedRun8.capture.outlineDispatch.reasons.includes('outline-domain-target-mismatch'),
+      'the original descriptive filename still fails the citation-id/basename check');
+  } finally { unchangedRun8.cleanup(); }
+
+  const substituted = createOutlineFixture({ retainedInventory: true,
+    handoffOverrides: { inventory: { ...internals.OUTLINE_INVENTORY_PIN, rowId: '17', domain: 'VERI',
+      targetPaths: ['docs/adr/EVID-001.md'] } } });
+  try {
+    assert.strictEqual(substituted.capture.outlineDispatch.state, 'unresolved');
+    assert.ok(substituted.capture.outlineDispatch.reasons.includes('outline-inventory-binding-mismatch'));
+  } finally { substituted.cleanup(); }
+});
+
+test('separate outline export failures stay closed for digest, path, file, wrapper, mapping, and chain corruption', () => {
+  const staged = stageQualificationTree('source');
+  const validRecords = [qualificationDispatch(), qualificationStart(), qualificationResult(), qualificationStop()];
+  try {
+    const closed = (name, mutate, records = validRecords) => {
+      const { wrapper, filePath } = writeStagedOutlineEvidence(staged, records);
+      mutate(wrapper, filePath);
+      const outcome = stagedOutlineOutcome(staged);
+      assert.strictEqual(outcome.open, false, `${name}: ${JSON.stringify(outcome)}`);
+    };
+    closed('wrong digest', wrapper => {
+      wrapper.sha256 = '0'.repeat(64);
+      staged.writeExport(staged.validExport({ outlineDispatchCapture: wrapper }));
+    });
+    closed('unsafe filename', wrapper => {
+      wrapper.file = '../doc-reconciliation-outline-capture.sanitized.jsonl';
+      staged.writeExport(staged.validExport({ outlineDispatchCapture: wrapper }));
+    });
+    closed('missing file', (_wrapper, filePath) => fs.rmSync(filePath));
+    closed('malformed file', (wrapper, filePath) => {
+      const bytes = Buffer.from('{malformed json}\n');
+      fs.writeFileSync(filePath, bytes);
+      wrapper.sha256 = sha(bytes);
+      staged.writeExport(staged.validExport({ outlineDispatchCapture: wrapper }));
+    });
+    closed('malformed wrapper', () => staged.writeExport(staged.validExport({ outlineDispatchCapture: null })));
+    closed('mapping mismatch', wrapper => {
+      wrapper.mapping = { ...outlineMappingV2, workerRootField: 'cwd.unobserved' };
+      staged.writeExport(staged.validExport({ outlineDispatchCapture: wrapper }));
+    });
+    const crossSession = validRecords.map(record => ({ ...record }));
+    crossSession[2].session_id = 'other-coordinator';
+    closed('only dispatch chain crosses coordinator sessions', () => {}, crossSession);
+    const wrongRoot = validRecords.map(record => ({ ...record }));
+    wrongRoot[1].cwd = '/tmp/other-worker';
+    closed('only dispatch chain has a worker-root mismatch', () => {}, wrongRoot);
+  } finally { staged.cleanup(); }
+});
+
 function outlineCorrelation(records, anchor = records.find(item => item.event === 'PreToolUse')) {
   return internals.correlateOutlineDispatch(records, anchor, '/tmp/prb-worker');
 }
@@ -1215,22 +1471,13 @@ test('runtime resolution accepts Stop after the completed result through the syn
   } finally { fixture.cleanup(); }
 });
 
-test('production export without an outline mapping keeps outline-live-gate-unmet', () => {
-  const fixture = createOutlineFixture();
+test('missing outline wrapper keeps outline-live-gate-unmet', () => {
+  const staged = stageQualificationTree('source');
   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(); }
+    staged.writeExport(staged.validExport());
+    const qualification = stagedOutlineOutcome(staged);
+    assert.strictEqual(qualification.open, false, JSON.stringify(qualification));
+  } finally { staged.cleanup(); }
 });
 
 test('original B and immutable attempt chain survive reconfirmation; stale attempts/tokens never cover new scope', () => {

package/docs/doc-workflow-reconciliation.md

@@ -1181,12 +1181,14 @@ Only direct, single, registered Node invocations are credited. Compound shell co
 
 Candidate classification follows command roles, not arbitrary text matches. A direct `doc-check`/`doc-check.js` target, a checker script operand to a recognized launcher, or a checker command in a recognized shell command-string remains a candidate when its launcher, subcommand, flags, quoting or composition is unsupported; it is refused as `unregistered-command` and cannot fall through to generic verification. An unrelated command whose data argument mentions `doc-check`—including workflow-plan JSON, `echo` text or a supplied filename—is not a candidate. Candidate detection never authorizes a wrapper, and opaque aliases or dynamically constructed targets remain unsupported.
 
+Default `check` remains non-generating, and `compare-derived` remains a pure comparison of caller-captured bytes. One explicitly requested, registered `check --derived-view <path>` invocation may generate the configured lifecycle index in memory and compare it with the declared view; it never writes the view. Automatic collection and reconciliation still do not execute generators.
+
 | Capability | Credit needs |
 |---|---|
 | `doc-lint` | One projection from an observed successful `check`: lint exit 0, valid schema, the exact expected governed and baseline paths, and complete relevant coverage |
 | `link-check` | A separate projection of the same invocation, scoped to the expected paths: no broken, skipped, unreadable or unsupported link syntax |
-| `derived-regenerate` | An observed successful generation **and** an observed successful pure comparison, bound to the same source and config identity and to the same generated bytes. `--generation-status ok` is caller-reported and cannot establish generation alone |
-| `quality-review` | A completed review from a correlated host `agent_id` distinct from the author session and every executor. Executors are the author session and the principals of registered doc-check runs in the task, which are the execution evidence a doc obligation uses (see the rationale below). An Agent/Task result must name the same `agent_id`. The verdict needs an explicit approve line, a non-empty summary and one `Reviewed artifact: <path> sha256:<hex>` line per reviewed path, which must match the candidate. SubagentStop alone is never approval |
+| `derived-regenerate` | An observed successful generation and an observed successful pure byte comparison, bound to the same source inventory, config identity and generated bytes. Both operations MAY occur inside one explicitly requested, registered checker invocation: the checker executes the supported configured generator, retains its success and generated-output digest, and compares that output with the declared view without writing the view. Credit requires unchanged input identities and an observed matching target digest. Caller-reported `--generation-status ok` cannot establish generation alone |
+| `quality-review` | A completed review from a correlated host `agent_id` distinct from the author session and every executor. Executors are the author session and the principals of registered doc-check runs in the task, which are the execution evidence a doc obligation uses (see the rationale below). An Agent/Task result must name the same `agent_id`. The pilot offers only SubagentStop records with an explicit structured `Review verdict: approve|reject`; ordinary completion summaries are not review candidates, while missing or malformed required review remains unresolved. An approve needs a non-empty summary and `Reviewed artifact: <path> sha256:<hex>` lines whose exact path set matches the obligation scope and candidate. SubagentStop alone is never approval |
 | `conflict-check` | A registered `check --conflict-assessment` runs lifecycle lint with `--all` and requires an exact `--base` commit SHA; the corpus collection must be complete and lint must have no error diagnostics. The event keeps the exact obligation `normativePaths` as its scope and binds the full corpus paths/digests, config bytes and base commit separately to the workflow snapshot. This checks recorded and structural conflicts only; prose contradictions stay with independent `quality-review`. Plain `check` earns no conflict credit |
 | `requirement-sync` | Stay unresolved. F4 gives it no credit |
 | SHOULD reminders | Never earn credit, and their absence never withholds it |
@@ -1213,7 +1215,7 @@ claude -p "<fixed capture prompt, containing the exact check command>" \
 
 **Retained artifacts** go to `benchmarks/results/live-host/claude-325-3b-s2b/`: `capture.sanitized.jsonl`, `README.md`, the relevant stream-json transcript, settings, manifest and wrapper digests, the host version, the runtime and tree fingerprint, and the command and exit summary. Raw payloads stay private, outside the repository. Transcript text alone is not hook evidence.
 
-**Qualification export** is a sanitized file at the canonical path `hooks/scripts/lib/doc-reconciliation-qualification.json`, copied by plugin sync, with a byte-identical copy of its sanitized capture beside it (`doc-reconciliation-capture.sanitized.jsonl`). The runtime validates schema, host version, payload kinds, correlation and the capture digest against that sibling file. It does not search ancestor directories and does not accept a file by size.
+**Qualification export** is the sanitized file at `hooks/scripts/lib/doc-reconciliation-qualification.json`, copied by plugin sync. Its base `sanitizedCapture` and validation stay unchanged. Outline qualification uses a separate `outlineDispatchCapture` wrapper and sibling file (`doc-reconciliation-outline-capture.sanitized.jsonl`); the runtime checks the wrapper's sibling filename, SHA-256, object records and exact outline mapping. Neither path searches ancestor directories or accepts a file by size.
 
 ### Scope and limits
 
@@ -1232,7 +1234,7 @@ claude -p "<fixed capture prompt, containing the exact check command>" \
 
 ## 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.
+Status: **implemented behind the existing pilot switch; mechanism and package checks pass; the retained Claude Code 2.1.312 run8 profile is qualified for outline evidence.** Run8 was captured at main baseline `1bd0f805031c5577a6e7f72a9bc5b41618b71fc1`. This does not establish runtime version enforcement or an E1 qualifying cycle. OpenCode, Codex and other Claude Code versions remain unqualified. The 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
@@ -1250,12 +1252,14 @@ flowchart LR
 | 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. |
+| 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 trusted pin also records the owner-approved `VERI`→`EVID` mapping for rows 15–18 by reference to `../e1-feasibility-2026-10-28/owner-decision-veri-evid.md`; inventory bytes and digest stay unchanged. 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, with `id` equal to the target basename, 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. Any other subagent start in the worker root rejects the outline as a competing writer, unless that start and its unique stop are both journaled before the dispatch PreToolUse (for example, a non-isolated outline reviewer). 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.
+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. A same-root subagent start is unresolved as a competing writer when it may overlap the exclusive draft interval, from accepted dispatch PreToolUse through the uniquely correlated draft worker’s Stop. A uniquely identified agent whose Start and unique Stop both precede dispatch, or whose Start occurs strictly after that worker Stop, does not establish overlap by its Start alone. Missing, duplicated or inconsistent lifecycle evidence stays unresolved. This exception does not authorize writes outside the correlated draft worker/root or relax independent review, artifact identity or final-byte validation.
+
+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.
+The separate run8 capture establishes the versioned `claude-outline-dispatch-mapping/2` field contract for the observed Claude Code 2.1.312 profile: prompt and coordinator identity, completed result status and agent ID, explicit non-background dispatch, isolation absence, and matching worker root. The production export reads this capture from its own sibling file and keeps the base qualification capture unchanged. The retained run8 assessment reports `resolveIfQualified.status: accepted`; it is not an independent rerun. Deterministic fixtures continue to exercise the real hook/provider/adapter/checker/pilot path with a synthetic inventory pin as mechanism evidence. Neither evidence source is an E1 qualifying cycle or a claim for OpenCode, Codex or other Claude Code versions.

package/docs/platform-capabilities.md

@@ -210,7 +210,7 @@ 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.
+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. A separate sanitized capture now qualifies the **observed Claude Code 2.1.312 run8 profile**, recorded at main baseline `1bd0f805031c5577a6e7f72a9bc5b41618b71fc1`. This is retained field-mapping evidence, not runtime version enforcement or an E1 qualifying cycle. OpenCode, Codex and other Claude Code versions receive no outline qualification. 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)
 

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.46.0
+  version: 0.47.0
 ---
 
 # Harness Everything