harness-everything 0.44.0 → 0.46.0

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

@@ -265,7 +265,16 @@ function directoryCanContainMatch(relativeDirectory, globs, exactPaths = []) {
     || exactPathCanMatchDescendant(relativeDirectory, exactPaths);
 }
 
-function collectDocs(root, config) {
+function documentCorpusPaths(records, config) {
+  const selectors = [
+    ...(Array.isArray(config && config.governed) ? config.governed.map(entry => entry && entry.path) : []),
+    ...(Array.isArray(config && config.legacy) ? config.legacy : [])
+  ].filter(value => typeof value === 'string');
+  return [...new Set((records || []).filter(item => item && item.presence === 'present' && item.type === 'file'
+    && typeof item.path === 'string' && matchesAny(item.path, selectors)).map(item => item.path))].sort(compareText);
+}
+
+function collectDocs(root, config, coverage = null) {
   const workspace = path.resolve(root);
   const governed = Array.isArray(config && config.governed) ? config.governed : [];
   const legacyGlobs = Array.isArray(config && config.legacy) ? config.legacy : [];
@@ -274,9 +283,14 @@ function collectDocs(root, config) {
     ...legacyGlobs
   ].filter(value => typeof value === 'string');
   const files = [];
+  const skipped = [];
+  const skip = (relative, reason) => skipped.push({ path: relative || '.', reason });
   function walk(directory, relativeDirectory) {
     let entries;
-    try { entries = fs.readdirSync(directory, { withFileTypes: true }); } catch { return; }
+    try { entries = fs.readdirSync(directory, { withFileTypes: true }); } catch {
+      skip(relativeDirectory, 'unreadable-directory');
+      return;
+    }
     entries.sort((a, b) => compareText(a.name, b.name));
     for (const entry of entries) {
       if (entry.name === '.git' || entry.name === 'node_modules') continue;
@@ -285,6 +299,11 @@ function collectDocs(root, config) {
       if (entry.isDirectory()) {
         if (directoryCanContainMatch(relativePath, globs)) walk(absolute, relativePath);
       } else if (entry.isFile() && matchesAny(relativePath, globs)) files.push(absolute);
+      else if (entry.isSymbolicLink() && (matchesAny(relativePath, globs) || directoryCanContainMatch(relativePath, globs))) {
+        skip(relativePath, 'unsupported-symlink');
+      } else if (!entry.isDirectory() && !entry.isFile() && matchesAny(relativePath, globs)) {
+        skip(relativePath, 'unsupported-entry');
+      }
     }
   }
   walk(workspace, '');
@@ -296,9 +315,23 @@ function collectDocs(root, config) {
     const legacy = matchesAny(relativePath, legacyGlobs);
     if (!roleEntry && !legacy) continue;
     let bytes;
-    try { bytes = fs.readFileSync(absolute); } catch { continue; }
+    try { bytes = fs.readFileSync(absolute); } catch {
+      skip(relativePath, 'unreadable-file');
+      continue;
+    }
     selected.push({ relativePath, role: roleEntry ? roleEntry.role : null, legacy, bytes });
   }
+  for (const selector of globs.filter(value => !/[*?\[\]{}]/.test(value))) {
+    if (!files.includes(path.resolve(workspace, selector))) skip(selector, 'missing-configured-path');
+  }
+  if (coverage) {
+    coverage.complete = globs.length > 0 && skipped.length === 0;
+    coverage.skipped = skipped;
+    coverage.paths = selected.map(item => item.relativePath).sort(compareText);
+    coverage.digests = Object.fromEntries(selected
+      .sort((a, b) => compareText(a.relativePath, b.relativePath))
+      .map(item => [item.relativePath, crypto.createHash('sha256').update(item.bytes).digest('hex')]));
+  }
   const rules = readWorkingTreeRules(workspace, selected.filter(item => item.bytes.includes(0x0d)).map(item => item.relativePath));
   const docs = [];
   for (const item of selected) {
@@ -2664,7 +2697,11 @@ function main(argv = process.argv.slice(2)) {
     ? path.resolve(options.configFile)
     : path.resolve(workspacePath, options.configFile);
   let config;
-  try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (error) {
+  let configBytes;
+  try {
+    configBytes = fs.readFileSync(configPath);
+    config = JSON.parse(configBytes.toString('utf8'));
+  } catch (error) {
     process.stderr.write(`cannot read config: ${error.message}\n`);
     return 2;
   }
@@ -2672,7 +2709,14 @@ function main(argv = process.argv.slice(2)) {
     process.stderr.write(`${error.message}\n`);
     return 2;
   }
-  const docs = collectDocs(workspacePath, config);
+  const corpus = options.all ? { complete: false, skipped: [], paths: [], digests: {} } : null;
+  const docs = collectDocs(workspacePath, config, corpus);
+  if (corpus) {
+    const relativeConfig = path.relative(workspacePath, configPath);
+    corpus.config = relativeConfig && relativeConfig !== '..' && !relativeConfig.startsWith(`..${path.sep}`)
+      ? { path: relativeConfig.split(path.sep).join('/'), digest: crypto.createHash('sha256').update(configBytes).digest('hex') }
+      : null;
+  }
   const mode = {
     ...(options.all ? { all: true } : { changedPaths: options.changedPaths }),
     workspace: workspacePath, base: options.base, configPath,
@@ -2688,10 +2732,11 @@ function main(argv = process.argv.slice(2)) {
     }));
     return 0;
   }
+  if (corpus) analysis.corpus = corpus;
   process.stdout.write(`${JSON.stringify(analysis, null, 2)}\n`);
   return analysis.diagnostics.some(item => item.severity === 'error') ? 1 : 0;
 }
 
-module.exports = { readGitBaseInventory, scanWorkspaceFiles, parseFrontmatter, parseRequirementBlocks, collectDocs, analyzeDocs, resolveRef, lintDocs, buildIndex, diffRevisions, buildGitDocumentInventory };
+module.exports = { readGitBaseInventory, scanWorkspaceFiles, parseFrontmatter, parseRequirementBlocks, collectDocs, documentCorpusPaths, analyzeDocs, resolveRef, lintDocs, buildIndex, diffRevisions, buildGitDocumentInventory };
 
 if (require.main === module) process.exitCode = main();

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');
@@ -101,6 +209,23 @@ function acceptDocEvents(input = {}, dependencies = {}) {
         // Supplied extra digests must also describe this capture, never another tree.
         for (const p of Object.keys(digests)) if (!artifacts[p] || digests[p] !== artifacts[p].digest) reject('artifact-mismatch');
       }
+      if (event?.capability === 'conflict-check') {
+        const binding = event.corpusBinding;
+        const identity = snapshot.identity;
+        const expectedPaths = U.runtimeModule('doc-lifecycle.js').documentCorpusPaths(
+          snapshot.candidate.records, snapshot.config.resolution.config
+        );
+        if (!U.record(binding) || binding.complete !== true || !Array.isArray(binding.paths)
+          || U.stable(binding.paths) !== U.stable(expectedPaths) || !U.record(binding.digests)
+          || U.stable(Object.keys(binding.digests).sort()) !== U.stable(expectedPaths)
+          || !expectedPaths.every(p => artifacts[p] && binding.digests[p] === artifacts[p].digest)) reject('corpus-mismatch');
+        if (binding?.baselineDigest !== identity.baselineDigest || binding?.candidateDigest !== identity.candidateDigest
+          || binding?.configIdentityDigest !== identity.configDigest
+          || binding?.baseCommit !== snapshot.originContext.baseline.commit) reject('snapshot-changed');
+        const configSource = snapshot.config.capture.sources.find(source => source.path === binding?.config?.path);
+        if (!configSource || configSource.presence !== 'present'
+          || U.sha(U.bytes(configSource.bytes)) !== binding?.config?.digest) reject('config-capture-mismatch');
+      }
       if (event?.kind === 'review') {
         if (event.verdict !== 'approve' || !U.text(event.summary)) reject('event-invalid');
         const principals = context?.principals;
@@ -118,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() };
@@ -129,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;

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

@@ -2,10 +2,13 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 const { atomicWriteJson } = require('./fable-contracts');
+const { canonical, key } = require('./workflow-isolation');
 
 const enabled = () => process.env.HARNESS_DOC_RECONCILIATION_PILOT === '1';
+const text = value => typeof value === 'string' && value.trim().length > 0;
 
 function git(root, args) {
   const env = { ...process.env };
@@ -29,11 +32,40 @@ function runtimeModule(name) {
 
 // Only capture at plan/start. A later credit assessment must never advance the baseline to HEAD.
 function captureBaseline(context) {
-  if (!enabled() || context.workflow.docReconciliationBaseline) return;
+  if (!enabled()) return;
   try {
-    const root = git(context.root, ['rev-parse', '--show-toplevel']).trim();
-    const commit = git(root, ['rev-parse', '--verify', 'HEAD^{commit}']).trim();
-    context.workflow.docReconciliationBaseline = { root, commit };
+    if (!context.workflow.docReconciliationBaseline) {
+      const root = canonical(git(context.root, ['rev-parse', '--show-toplevel']).trim());
+      const commit = git(root, ['rev-parse', '--verify', 'HEAD^{commit}']).trim();
+      const tree = git(root, ['rev-parse', '--verify', `${commit}^{tree}`]).trim();
+      context.workflow.docReconciliationBaseline = { root, commit, tree };
+    } else if (!context.workflow.docReconciliationBaseline.tree) {
+      const pin = context.workflow.docReconciliationBaseline;
+      pin.tree = git(pin.root, ['rev-parse', '--verify', `${pin.commit}^{tree}`]).trim();
+    }
+    if (!context.workflow.docReconciliationTask) {
+      const plan = context.workflow.pendingPlan || context.workflow.workflowPlan;
+      const loaded = plan && runtimeModule('workflow-obligations').loadObligationSet(context, plan);
+      const requirementIds = loaded?.set?.requirements?.map(item => item.id);
+      if (Array.isArray(requirementIds) && requirementIds.length && requirementIds.every(id => typeof id === 'string' && id)) {
+        const baseline = context.workflow.docReconciliationBaseline;
+        const resolver = runtimeModule('project-docs-resolver');
+        const configSources = configSourcePaths(resolver).map(relative => {
+          const bytes = bytesAtBaseline(baseline.root, baseline.commit, relative);
+          return [relative, bytes === null ? null : crypto.createHash('sha256').update(bytes).digest('hex')];
+        });
+        const hash = value => crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+        const workspaceId = 'ws-' + hash({ workspaceRoot: canonical(baseline.root) });
+        context.workflow.docReconciliationTask = {
+          schema: 'harness.doc-reconciliation-task-pin.v1',
+          taskId: `task-${requirementIds.join('+')}`, requirementIds,
+          requirementDigest: hash(requirementIds), sessionId: context.sessionId,
+          workflowId: context.workflow.workflowId, workspaceId,
+          baselineCommit: baseline.commit, baselineRoot: baseline.root,
+          configDigest: hash(configSources),
+        };
+      }
+    }
   } catch {
     // Absence is intentionally retained; credit assessment will fail closed.
   }
@@ -80,8 +112,9 @@ function assertConfigScopeUnchanged(root, baseline, resolver) {
 function collect(context) {
   const baseline = context.workflow.docReconciliationBaseline;
   if (!baseline) throw new Error('baseline-unavailable');
-  const root = git(context.root, ['rev-parse', '--show-toplevel']).trim();
-  if (root !== baseline.root || !/^[0-9a-f]{40,64}$/.test(baseline.commit)) throw new Error('baseline-unavailable');
+  const root = canonical(git(context.root, ['rev-parse', '--show-toplevel']).trim());
+  if (!text(baseline.root) || key(root) !== key(baseline.root)
+    || !/^[0-9a-f]{40,64}$/.test(baseline.commit)) throw new Error('baseline-unavailable');
   const resolver = runtimeModule('project-docs-resolver');
   const resolved = resolver.resolveDocsConfig(root);
   if (!['project', 'host'].includes(resolved.status)) throw new Error('config-unavailable');
@@ -120,17 +153,30 @@ function creditChain(context, set, dependencies = {}) {
     : hostId === 'claude-code' ? providerModule.readCaptureView(context.sessionDir)
       : { records: [], tampered: false };
   if (captureView.tampered) {
-    return { eligible: false, diagnostics: [{ code: 'journal-tampered', message: 'the capture journal no longer matches its immutable event records' }] };
+    return { eligible: false, outlineEvidence: { outcome: 'none', observation: 'unresolved', reason: 'journal-tampered' },
+      diagnostics: [{ code: 'journal-tampered', message: 'the capture journal no longer matches its immutable event records' }] };
   }
   if (!['claude-code', 'opencode'].includes(hostId)) {
-    return { eligible: false, diagnostics: [{ code: 'unsupported-host', message: `no document origin provider is registered for ${String(hostId)}` }] };
+    return { eligible: false, outlineEvidence: { outcome: 'none', observation: 'unresolved', reason: 'unsupported-host' },
+      diagnostics: [{ code: 'unsupported-host', message: `no document origin provider is registered for ${String(hostId)}` }] };
   }
   const { produceDocSnapshot } = require('./doc-reconciliation-producer');
   const { acceptDocEvents } = require('./doc-reconciliation-events');
   const { checkAcceptedDocEvidence } = require('./doc-reconciliation-core');
   const baseline = context.workflow.docReconciliationBaseline;
   const requirements = Array.isArray(set?.requirements) ? set.requirements : [];
-  const taskId = `task-${requirements.map(item => item.id).join('+') || 'none'}`;
+  const requirementIds = requirements.map(item => item.id);
+  const derivedTaskId = `task-${requirementIds.join('+') || 'none'}`;
+  const taskBinding = context.workflow.docReconciliationTask || null;
+  const taskId = taskBinding?.taskId || derivedTaskId;
+  if (taskBinding && (taskBinding.taskId !== derivedTaskId || taskBinding.workflowId !== context.workflow.workflowId
+    || taskBinding.sessionId !== context.sessionId || taskBinding.baselineCommit !== baseline?.commit
+    || !text(taskBinding.baselineRoot) || !text(baseline?.root)
+    || key(taskBinding.baselineRoot) !== key(baseline.root)
+    || taskBinding.requirementDigest !== crypto.createHash('sha256').update(JSON.stringify(requirementIds)).digest('hex')) ) {
+    return { eligible: false, outlineEvidence: { outcome: 'none', observation: 'unresolved', reason: 'task-binding-mismatch' },
+      diagnostics: [{ code: 'task-binding-mismatch', message: 'the requirement set or original B differs from the task pin' }] };
+  }
   const sessionId = context.sessionId;
   const { createClaudeOriginProvider, createOpencodeOriginProvider, journalExecutors } = providerModule;
   const captures = captureView.records;
@@ -145,6 +191,8 @@ function creditChain(context, set, dependencies = {}) {
     workflowId: context.workflow.workflowId,
     workflowRevision: context.workflow.revision,
     taskId,
+    sessionDir: context.sessionDir,
+    taskBinding,
     principals,
     baseline,
     captures,
@@ -161,6 +209,7 @@ function creditChain(context, set, dependencies = {}) {
   }, { originProvider });
   if (produced.state !== 'ready' || !produced.snapshot) return {
     eligible: false,
+    outlineEvidence: { outcome: 'none', observation: 'unresolved', reason: produced.diagnostics?.[0]?.code || 'snapshot-unavailable' },
     diagnostics: produced.diagnostics || [],
     unsatisfied: [],
   };
@@ -171,12 +220,25 @@ function creditChain(context, set, dependencies = {}) {
   const passing = new Set((checked.results || []).filter(r => r.observation === 'observed' && r.outcome === 'pass').map(r => r.obligationId));
   const expected = new Set(checked.checkedMustIds || []);
   const satisfied = produced.snapshot.obligations.filter(o => o.strength === 'MUST' && o.applicability !== 'N/A' && expected.has(o.id) && passing.has(o.id));
+  const outlineObligation = produced.snapshot.obligations.find(item => item.capability === 'outline-confirmation');
+  const outlineResult = outlineObligation && (checked.results || []).find(item => item.obligationId === outlineObligation.id);
+  const outlineRefs = Object.entries(accepted.acceptedIndex || {}).filter(([, item]) => item.capability === 'outline-confirmation').map(([ref]) => ref);
+  const outlineEvidence = {
+    status: outlineResult?.observation === 'observed' && outlineResult?.outcome === 'pass' ? 'pass' : 'unresolved',
+    outcome: outlineResult?.outcome || 'none',
+    observation: outlineResult?.observation || 'unresolved',
+    recordRefs: outlineResult?.recordRefs || [],
+    acceptedRefs: outlineRefs,
+    diagnostics: [...(accepted.diagnostics || []), ...(accepted.rejected || []), ...(checked.diagnostics || [])]
+      .filter(item => !item?.obligationId || item.obligationId === outlineObligation?.id),
+  };
   return {
     eligible: checked.eligible === true,
     capabilities: checked.eligible === true ? [...new Set(satisfied.map(o => o.capability))] : [],
     satisfiedObligationIds: satisfied.map(o => o.id),
     unsatisfied: checked.unsatisfied || [],
     acceptedRefs: Object.keys(accepted.acceptedIndex || {}),
+    outlineEvidence,
     diagnostics: [...(accepted.diagnostics || []), ...(checked.diagnostics || [])],
     rejected: accepted.rejected || [],
   };
@@ -232,6 +294,45 @@ function readCaptures(context) {
 const docCheckCandidate = item => item.event === 'PostToolUse'
   && require('./doc-reconciliation-provider').resolveDocCheckInvocation(item.command, item.cwd).kind !== 'not-candidate';
 
+function outlineReviewCaptureRefs(sessionDir, taskId) {
+  const refs = new Set();
+  if (!text(taskId)) return refs;
+  const attempts = path.join(sessionDir, 'doc-reconciliation', 'outline-confirmation', taskId, 'attempts');
+  try {
+    for (const entry of fs.readdirSync(attempts, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const handoff = JSON.parse(fs.readFileSync(path.join(attempts, entry.name, 'handoff.json'), 'utf8'));
+        if (handoff.taskId === taskId && typeof handoff.reviewCaptureRef === 'string') refs.add(handoff.reviewCaptureRef);
+      } catch { /* malformed handoff cannot add review credit */ }
+    }
+  } catch { /* no attempts yet */ }
+  return refs;
+}
+
+function outlineDispatchReferences(captures, taskId, sessionDir) {
+  if (!text(taskId)) return [];
+  const candidates = (Array.isArray(captures) ? captures : []).filter(item => recordOf(item)
+    && item.event === 'PreToolUse' && ['Task', 'Agent'].includes(item.tool_name)
+    && text(item.ref) && item.outlineDispatch?.taskId === taskId && text(item.outlineDispatch.attemptId));
+  if (!candidates.length) return [];
+  if (text(sessionDir)) {
+    const provider = require('./doc-reconciliation-provider');
+    const attemptIds = [...new Set(candidates.map(item => item.outlineDispatch.attemptId))];
+    const resolved = attemptIds.map(attemptId => ({ attemptId,
+      attempt: provider._internals.resolveOutlineAttempt({ sessionDir, taskId, attemptId }) }));
+    const current = resolved.filter(item => item.attempt.state === 'accepted');
+    if (current.length === 1) {
+      const dispatches = candidates.filter(item => item.outlineDispatch.attemptId === current[0].attemptId);
+      return dispatches.length ? [`${dispatches[0].ref}#outline-confirmation`] : [];
+    }
+    if (current.length > 1 || attemptIds.length > 1) return [];
+  }
+  const tuples = [...new Set(candidates.map(item => `${item.outlineDispatch.attemptId}\0${item.tool_use_id || ''}\0${item.outlineDispatch.dispatchInputDigest || ''}`))];
+  if (tuples.length > 1 && !candidates.some(item => item.outlineDispatch.state === 'unresolved')) return [];
+  return [`${candidates[0].ref}#outline-confirmation`];
+}
+
 function captureReferences(context) {
   const captures = readCaptures(context);
   if (activeHostFor(context) === 'opencode') {
@@ -241,12 +342,19 @@ function captureReferences(context) {
   const candidates = captures
     .filter(item => item && typeof item.ref === 'string' && (item.event === 'SubagentStop' || docCheckCandidate(item)))
     .filter(item => item.event !== 'SubagentStop');
-  const reviews = captures.filter(item => item && typeof item.ref === 'string' && item.event === 'SubagentStop');
+  const taskId = context.workflow.docReconciliationTask?.taskId;
+  const outlineReviews = outlineReviewCaptureRefs(context.sessionDir, taskId);
+  const reviews = captures.filter(item => item && typeof item.ref === 'string' && item.event === 'SubagentStop'
+    && !outlineReviews.has(item.ref));
   const references = [];
   for (const [index, capability] of ['doc-lint', 'link-check'].entries()) {
     const ordered = index ? candidates.slice(1).concat(candidates.slice(0, 1)) : candidates;
     references.push(...ordered.map(item => `${item.ref}#${capability}`));
   }
+  const provider = require('./doc-reconciliation-provider');
+  references.push(...candidates.filter(item => provider.resolveDocCheckInvocation(item.command, item.cwd).conflictAssessment === true)
+    .map(item => `${item.ref}#conflict-check`));
+  references.push(...outlineDispatchReferences(captures, taskId, context.sessionDir));
   // The adapter accepts one event per capability; rotating candidate order lets separate valid runs fill each capability.
   return [...references, ...reviews.map(item => `${item.ref}#quality-review`)];
 }
@@ -295,6 +403,7 @@ function assess(context, set, dependencies = {}) {
   const report = {
     schemaVersion: 1, reportOrigin: 'runtime', pilotStatus: 'unavailable', pilotCredit: false,
     identity: null, expectedMustIds: [], results: [], unsatisfied: [], diagnostics: [],
+    outlineEvidence: { status: 'unresolved', outcome: 'none', observation: 'unresolved', acceptedRefs: [], recordRefs: [], diagnostics: [] },
   };
   const supported = set?.stepBindingsEnabled === true && !String(context.workflow.strategy || '').startsWith('fable-');
   let withhold = false;
@@ -310,10 +419,17 @@ function assess(context, set, dependencies = {}) {
         reasonCode: item.applicability === 'unknown' ? 'unknown-applicability' : 'producer-unavailable',
       }));
       if (!withhold) report.diagnostics.push('trusted-non-document-scope');
-      if (withhold) {
+      const hasOutlineCapture = captureReferences(context).some(reference => reference.endsWith('#outline-confirmation'));
+      if (withhold || hasOutlineCapture) {
         let chain;
         try { chain = creditChain(context, set, dependencies); }
-        catch (error) { chain = { eligible: false, diagnostics: [{ code: 'collector-unavailable', message: String(error.message) }] }; }
+        catch (error) { chain = { eligible: false, outlineEvidence: { status: 'unresolved', outcome: 'none',
+          observation: 'unresolved', reason: 'collector-unavailable', acceptedRefs: [], recordRefs: [], diagnostics: [] },
+          diagnostics: [{ code: 'collector-unavailable', message: String(error.message) }] }; }
+        report.outlineEvidence = chain.outlineEvidence || report.outlineEvidence;
+        report.acceptedRefs = chain.acceptedRefs || [];
+        report.diagnostics.push(...(chain.diagnostics || []));
+        if (withhold) {
         // The unsatisfied list is rewritten from the chain: a MUST that the chain did not satisfy stays listed (F3).
         const satisfied = new Set(chain.satisfiedObligationIds || []);
         report.unsatisfied = [
@@ -324,12 +440,11 @@ function assess(context, set, dependencies = {}) {
           ...(chain.unsatisfied || []),
         ];
         report.creditedCapabilities = chain.eligible === true ? chain.capabilities : [];
-        report.acceptedRefs = chain.acceptedRefs || [];
-        report.diagnostics.push(...(chain.diagnostics || []));
         // Credit needs an empty unsatisfied list across both sources and at least one satisfied capability.
         withhold = !(chain.eligible === true && report.unsatisfied.length === 0 && report.creditedCapabilities.length > 0);
         report.pilotCredit = !withhold;
         report.pilotStatus = report.pilotCredit ? 'credited' : 'unresolved';
+        }
       }
     } catch (error) {
       withhold = true;
@@ -348,4 +463,5 @@ function assess(context, set, dependencies = {}) {
   return { withhold, report };
 }
 
-module.exports = { enabled, captureBaseline, assess, reviewRequired, independentReviewAccepted };
+module.exports = { enabled, captureBaseline, assess, reviewRequired, independentReviewAccepted,
+  _internals: { captureReferences, outlineDispatchReferences, outlineReviewCaptureRefs } };