@clear-capabilities/agentic-security-scanner 0.161.0 → 0.163.0

package/src/posture/accuracy-scorecard.js

@@ -111,6 +111,55 @@ export function aggregateCorpus(detail) {
   };
 }
 
+/**
+ * Real-code evaluation gates (programme QA-001/QA-003). Takes the committed gate
+ * report written by `scripts/evaluation.mjs gates` (or nothing) and returns the
+ * section the scorecard publishes. It can only RELAY a status: a synthetic
+ * protocol is forced to `unmeasured`, and an absent report is `unmeasured` with
+ * the reason, never an empty pass. Pure.
+ */
+export function summarizeMeasurement(provenance, independent) {
+  const p = provenance || {};
+  const clean = p.worktreeClean === true;
+  const hist = independent && independent.engineVersion && independent.engineVersion !== p.engineVersion;
+  return {
+    engineVersion: p.engineVersion || null, commit: p.commit || null, bundleSha256: p.bundleSha256 || null,
+    cleanMeasurement: clean,
+    identity: clean
+      ? 'the commit and bundle below identify exactly the tree that was measured'
+      : p.worktreeClean === false ? 'the worktree was dirty: the commit below does NOT identify what was measured, so this is not a clean measurement' : 'cleanliness of the measured tree was not recorded',
+    currentEngineIndependentAccuracy: 'unmeasured',
+    currentEngineIndependentReason: 'no adjudicated real-code population has been run against this engine; the independent record in this document, if any, describes an older engine',
+    historicalIndependentRecord: hist
+      ? { engineVersion: independent.engineVersion, measuredAt: independent.measuredAt || null, usage: 'historical record only; not a measurement of the engine above and not combined with the corpus figures' }
+      : null,
+  };
+}
+
+export function summarizeEvaluationGates(report) {
+  if (!report || typeof report !== 'object') {
+    return {
+      measuredThisRun: false, status: 'unmeasured', synthetic: null, gates: [],
+      reason: 'no frozen real-code evaluation protocol and no sealed adjudicated population exist yet; no real-code gate has been evaluated',
+    };
+  }
+  const gates = Array.isArray(report.gates) ? report.gates.map((g) => ({ id: g.id, status: g.status, threshold: g.threshold ?? null, measured: g.measured ?? null, reason: g.reason || null })) : [];
+  const synthetic = report.synthetic !== false;
+  const counts = {};
+  for (const g of gates) counts[g.status] = (counts[g.status] || 0) + 1;
+  return {
+    measuredThisRun: false,
+    source: 'bench/independent/evaluation-gates.json',
+    protocolHash: report.protocolHash || null,
+    synthetic,
+    // A synthetic protocol can exercise the machinery; it can never publish a gate result.
+    status: synthetic ? 'unmeasured' : (report.overall || 'unmeasured'),
+    reason: synthetic ? 'the recorded protocol is synthetic; its results are not real-code evidence' : (report.population?.reason || null),
+    gates: synthetic ? [] : gates,
+    gateCounts: synthetic ? {} : counts,
+  };
+}
+
 /**
  * Build the machine-readable scorecard model. `inputs`:
  *   provenance   { engineVersion, bundleSha256, commit, nodeVersion, generatedAt,
@@ -227,6 +276,10 @@ export function buildScorecard(inputs) {
           source: 'bench/independent/RESULT.json',
           measuredAt: committed.independent.measuredAt || null,
           engineVersion: committed.independent.engineVersion || null,
+          // QA-008.AC01: this record belongs to the engine it names. When that is not the engine this scorecard measured, it is a
+          // HISTORICAL record: kept, dated, labelled, and never combined with the curated-corpus figures into one accuracy claim.
+          historical: !!committed.independent.engineVersion && committed.independent.engineVersion !== (inputs.provenance || {}).engineVersion,
+          comparableToCurrentEngine: !!committed.independent.engineVersion && committed.independent.engineVersion === (inputs.provenance || {}).engineVersion,
           population: committed.independent.population || null,
           overall: committed.independent.overall || null,
           wide: committed.independent.wide || null,
@@ -293,6 +346,10 @@ export function buildScorecard(inputs) {
     // frameworks" from "this scorecard predates the metric" the same way
     // every other section here distinguishes absence from zero.
     complianceMappingCoverage: inputs.complianceMappingCoverage || [],
+    // QA-001/QA-003: the real-code gates registered in the evaluation protocol. Relayed, never computed here.
+    evaluationGates: summarizeEvaluationGates(inputs.evaluation),
+    // QA-008.AC01: what this scorecard measured, stated once. `clean` is what lets the commit and bundle identify the measured tree.
+    measurement: summarizeMeasurement(inputs.provenance, committed.independent),
   };
 }
 
@@ -344,6 +401,10 @@ export function renderScorecardMarkdown(m) {
   if (p.worktreeClean !== undefined) {
     L.push(`| Worktree at measurement time | ${p.worktreeClean ? 'clean' : 'DIRTY — the commit above does not fully describe what was measured'} |`);
   }
+  if (m.measurement) {
+    L.push(`| Measurement identity | ${m.measurement.cleanMeasurement ? 'clean measurement: the commit and bundle above identify the measured tree' : 'NOT a clean measurement: the commit and bundle above do not identify the measured tree'} |`);
+    L.push('| Independent accuracy of THIS engine | unmeasured (no adjudicated real-code population has been run; see the historical record below, if present) |');
+  }
   L.push(`| Node | ${p.nodeVersion || 'unknown'} |`);
   L.push(`| Corpus entries | ${c.totalEntries} (${c.scoredEntries} scored) |`);
   // FR-901: "Published results identify engine version, corpus version,
@@ -674,8 +735,17 @@ export function renderScorecardMarkdown(m) {
 
   const ind = m.committedInputs.independent;
   if (ind && ind.overall) {
-    L.push('## Independent evaluation population — the number that matters');
+    const hist = ind.historical === true;
+    L.push(hist
+      ? `## Independent evaluation population: historical record (engine ${ind.engineVersion}, ${ind.measuredAt || 'undated'})`
+      : '## Independent evaluation population — the number that matters');
     L.push('');
+    if (hist) {
+      L.push(`**This is a historical record of engine ${ind.engineVersion}, measured ${ind.measuredAt || 'on an unrecorded date'}.** It is not a measurement of the`);
+      L.push(`engine this scorecard describes (${p.engineVersion || 'unknown'}), it is a different population from the curated corpus above, and the two are`);
+      L.push('never combined into one accuracy figure. The current engine has no independent figure: it is **unmeasured**.');
+      L.push('');
+    }
     L.push('Everything above is a **regression net**: its fixtures and its labels are both');
     L.push('written here, which is why its detection rate sits at the ceiling by');
     L.push('construction. `bench/independent/` is the other instrument — real upstream code');
@@ -715,9 +785,14 @@ export function renderScorecardMarkdown(m) {
     L.push('class at all, a question with a much easier yes. It is kept because it is the');
     L.push('only way to tell whether a change moved the engine or moved the benchmark.');
     L.push('');
-    L.push('Against ~100% on the curated corpus above. **That gap is the most useful number');
-    L.push('in this document**, and publishing it is the point of the exercise. The figure');
-    L.push('went DOWN when the benchmark was corrected, and is published that way.');
+    if (hist) {
+      L.push(`This record is kept, dated and labelled because it is the last independent measurement the project made. It describes engine ${ind.engineVersion} only.`);
+      L.push('It does not describe the engine above, and the curated-corpus rates earlier in this document are a different population that must not be read beside it as one claim.');
+    } else {
+      L.push('Against ~100% on the curated corpus above. **That gap is the most useful number');
+      L.push('in this document**, and publishing it is the point of the exercise. The figure');
+      L.push('went DOWN when the benchmark was corrected, and is published that way.');
+    }
     L.push('');
     // FR-904 (assurance-hardening PRD): "rule authors cannot optimize
     // against the full scored population." T0.7's held-out slice is a
@@ -771,6 +846,22 @@ export function renderScorecardMarkdown(m) {
       }
     }
   }
+  const eg = m.evaluationGates || summarizeEvaluationGates(null);
+  L.push('## Real-code evaluation gates');
+  L.push('');
+  L.push(`Status: **${eg.status}**${eg.reason ? ` (${eg.reason})` : ''}.`);
+  L.push('');
+  L.push('The gates (per-language F1, micro and macro F1, pooled precision and recall, completion) are registered');
+  L.push('in a frozen protocol before any result is observed, and can read `pass` only on an independently');
+  L.push('adjudicated sealed population that meets the registered minimums. `insufficient-population` and');
+  L.push('`unmeasured` are honest blockers, not failures and not passes.');
+  if (eg.gates.length) {
+    L.push('');
+    L.push('| Gate | Status | Threshold | Measured |');
+    L.push('| --- | --- | --- | --- |');
+    for (const g of eg.gates) L.push(`| ${g.id} | ${g.status} | ${g.threshold ?? 'n/a'} | ${g.measured ?? 'n/a'} |`);
+  }
+  L.push('');
   L.push('## Committed artifacts referenced (not re-run by this command)');
   L.push('');
   const cb = m.committedInputs.corpusBaseline;

package/src/posture/assurance/baseline-inventory.js

@@ -0,0 +1,218 @@
+// The recommendation mappings and the capability inventory that baseline capture
+// (CORE-001) records. Pure data. Every path is relative to the repository root and
+// is VERIFIED against the checkout at capture time: a path that does not exist is
+// reported as a problem, never carried as if it did.
+//
+// Status vocabulary (one per capability, never combined):
+//   implemented  the capability exists, has a source path and a test or artifact,
+//                and no gap against the differentiation PRD is known.
+//   partial      it exists and is tested, and `gap` names exactly what the PRD
+//                still needs on top of it.
+//   unsupported  the PRD calls for it and the checkout does not provide it; `source`
+//                is the existing extension point it would attach to, `evidence` the
+//                test that covers that neighbour, and `gap` says what is absent.
+//   unmeasured   it exists but no current-revision measurement of it is recorded;
+//                `evidence` is the artifact that exists and `gap` says why it is not a
+//                current measurement.
+//
+// This is a statement about what was inspected, not a quality score. Moving an
+// entry to a stronger status needs the new source and evidence paths to land first.
+
+export const RECOMMENDATION_MAPPINGS = Object.freeze([
+  {
+    n: 1, title: 'Refresh real-code evaluation and repair measured misses', priority: 'P0', slice: 'QA-001..QA-008',
+    extensionPoints: ['bench/independent', 'scanner/src/posture/accuracy-scorecard.js', 'scripts/scorecard.mjs', 'docs/scorecard.json'],
+  },
+  {
+    n: 2, title: 'Unify verification and expand trusted runtime oracles', priority: 'P0', slice: 'X-201..X-208',
+    extensionPoints: ['scanner/src/posture/fix-verify.js', 'scanner/src/posture/execution-proof.js', 'scanner/src/posture/verifier.js', 'scanner/src/sandbox/index.js', 'scanner/src/posture/autopilot.js', 'scanner/src/mcp/tools.js'],
+  },
+  {
+    n: 3, title: 'Add a deployment-aware Code Boundaries graph', priority: 'P1', slice: 'X-301..X-308',
+    extensionPoints: ['scanner/src/lineage/runtime-observation.js', 'scanner/src/lineage/observation-adapters.js', 'scanner/src/lineage/observation-correlation.js', 'scanner/src/lineage/cross-repo-link.js', 'scanner/src/lineage/federation-loader.js', 'scanner/src/lineage/drift-policy.js'],
+  },
+  {
+    n: 4, title: 'Execute tenant and business invariants', priority: 'P1', slice: 'X-401..X-408',
+    extensionPoints: ['scanner/src/posture/business-logic.js', 'scanner/src/posture/logic-claims.js', 'scanner/src/posture/specification-mining.js', 'scanner/src/discovery'],
+  },
+  {
+    n: 5, title: 'Enforce coding-agent capabilities', priority: 'P1', slice: 'X-501..X-508',
+    extensionPoints: ['hooks/pre-bash-guard.js', 'hooks/pre-edit-bodyguard.js', 'hooks/dispatch-pre-tool.js', 'scanner/src/egress/policy.js', 'scanner/src/egress/redact.js', 'scanner/src/egress/audit.js', 'scanner/src/sandbox/index.js', 'scanner/src/mcp/server.js'],
+  },
+  {
+    n: 6, title: 'Calibrate model routing against outcomes', priority: 'P2', slice: 'X-601..X-608',
+    extensionPoints: ['scanner/src/posture/model-routing.js', 'scanner/src/posture/model-trust.js', 'scanner/src/posture/cache-economics.js', 'scanner/src/posture/provider-catalog.js'],
+  },
+  {
+    n: 7, title: 'Deliver portable release assurance and resumable portfolios', priority: 'P2', slice: 'X-701..X-708',
+    extensionPoints: ['scanner/src/posture/fleet.js', 'scanner/src/posture/scan-checkpoint.js', 'scanner/src/posture/attestation.js', 'scanner/src/posture/evidence-bundle.js', 'scanner/src/posture/integrity.js', 'scanner/src/posture/retention-policy.js'],
+  },
+]);
+
+const t = (p) => ({ kind: 'test', path: p });
+const a = (p) => ({ kind: 'artifact', path: p });
+
+export const CAPABILITY_INVENTORY = Object.freeze([
+  {
+    id: 'poc-replay', workstream: 2, title: 'Proof-of-concept generation and confined replay',
+    status: 'partial',
+    source: ['scanner/src/posture/poc-generator.js', 'scanner/src/posture/poc-inprocess.js', 'scanner/src/posture/execution-proof.js', 'scanner/src/posture/proof-tier.js'],
+    entryPoints: [{ path: 'scanner/src/posture/execution-proof.js', symbol: 'proveFinding' }, { path: 'scanner/src/posture/proof-tier.js', symbol: 'attachProofTier' }],
+    evidence: [t('scanner/test/poc-generator.test.js'), t('scanner/test/execution-proof.test.js'), t('scanner/test/proof-artifact.test.js')],
+    gap: 'replay is JavaScript/taint oriented and records a proof tier on the finding; there is no class-specific oracle adapter, no patched-negative replay, and no single verification record',
+    prd: ['X-201', 'X-202', 'X-203', 'X-204', 'X-205'],
+  },
+  {
+    id: 'fix-verification', workstream: 2, title: 'Fix verification (rescan, lint, tests, honesty gate, PoC re-check)',
+    status: 'partial',
+    source: ['scanner/src/posture/fix-verify.js', 'scanner/src/posture/fix-verify-loop.js', 'scanner/src/fix/apply-fix-service.js', 'scanner/src/posture/fix-honesty-gate.js'],
+    entryPoints: [{ path: 'scanner/src/posture/fix-verify.js', symbol: 'verifyFix' }, { path: 'scanner/src/fix/apply-fix-service.js', symbol: 'applyVerifiedFix' }],
+    evidence: [t('scanner/test/fix-verify-loop.test.js'), t('scanner/test/fix-verify-tests.test.js'), t('scanner/test/apply-fix-service.test.js'), t('scanner/test/fix-honesty-gate.test.js')],
+    gap: 'results are per-surface shapes, not one versioned record; original-positive, patched-negative and functional-regression evidence are not bound together by digest',
+    prd: ['X-201', 'X-204', 'X-206'],
+  },
+  {
+    id: 'verifier-separation', workstream: 2, title: 'Independent verifier and verification separation',
+    status: 'partial',
+    source: ['scanner/src/posture/verifier.js', 'scanner/src/posture/verification-separation.js', 'scanner/src/posture/verifier-target.js', 'scanner/src/posture/verifier-ephemeral.js'],
+    entryPoints: [],
+    evidence: [t('scanner/test/verifier.test.js'), t('scanner/test/verifier-independence.test.js'), t('scanner/test/verification-separation.test.js')],
+    gap: 'separation is enforced for the existing verifier path; key and label isolation for the new oracle workers is the CORE-003 trust-boundary work',
+    prd: ['CORE-003', 'X-202'],
+  },
+  {
+    id: 'sandbox-confinement', workstream: 2, title: 'Confinement sandbox (namespace, userspace and disabled backends)',
+    status: 'partial',
+    source: ['scanner/src/sandbox/index.js', 'scanner/src/sandbox/capabilities.js', 'scanner/src/sandbox/limits.js', 'scanner/src/sandbox/backend-namespace.js', 'scanner/src/sandbox/backend-userspace.js', 'scanner/src/sandbox/backend-disabled.js'],
+    entryPoints: [{ path: 'scanner/src/sandbox/index.js', symbol: 'runConfined' }],
+    evidence: [t('scanner/test/sandbox.test.js'), t('scanner/test/sandbox-escape.test.js')],
+    gap: 'isolation is probed per backend; descendant-process cleanup, read confinement and per-backend active probes are the CORE-003 work, and enforcement is only advertised on Linux',
+    prd: ['CORE-003', 'X-502', 'X-503'],
+  },
+  {
+    id: 'runtime-observation-imports', workstream: 3, title: 'Runtime observation imports and correlation',
+    status: 'partial',
+    source: ['scanner/src/lineage/runtime-observation.js', 'scanner/src/lineage/observation-adapters.js', 'scanner/src/lineage/observation-store.js', 'scanner/src/lineage/observation-correlation.js', 'scanner/src/posture/telemetry-ingest.js'],
+    entryPoints: [{ path: 'scanner/src/lineage/runtime-observation.js', symbol: 'validateRuntimeObservation' }, { path: 'scanner/src/lineage/observation-store.js', symbol: 'persistObservationImport' }],
+    evidence: [t('scanner/test/lineage/runtime-observation.test.js'), t('scanner/test/lineage/observation-adapters.test.js'), t('scanner/test/lineage/observation-store.test.js'), t('scanner/test/lineage/observation-correlation.test.js')],
+    gap: 'one adapter (native-jsonl) is implemented; observations corroborate lineage edges but do not yet bind to vulnerability hypotheses, and freshness and sampling are not modelled as path states',
+    prd: ['X-302', 'X-303', 'X-305'],
+  },
+  {
+    id: 'cross-repo-federation-drift', workstream: 3, title: 'Cross-repository links, federation and drift policy',
+    status: 'implemented',
+    source: ['scanner/src/lineage/cross-repo-link.js', 'scanner/src/lineage/federation-loader.js', 'scanner/src/lineage/drift-policy.js', 'scanner/src/lineage/graph-diff.js'],
+    entryPoints: [{ path: 'scanner/src/lineage/cross-repo-link.js', symbol: 'validateCrossRepoLink' }],
+    evidence: [t('scanner/test/lineage/cross-repo-link.test.js'), t('scanner/test/lineage/federation-loader.test.js'), t('scanner/test/lineage/drift-policy.test.js')],
+    gap: null,
+    prd: ['X-304', 'X-306'],
+  },
+  {
+    id: 'business-logic-claims', workstream: 4, title: 'Business-logic detection, logic claims and specification mining',
+    status: 'partial',
+    source: ['scanner/src/posture/business-logic.js', 'scanner/src/posture/logic-claims.js', 'scanner/src/posture/specification-mining.js'],
+    entryPoints: [],
+    evidence: [t('scanner/test/business-logic.test.js'), t('scanner/test/logic-claims.test.js'), t('scanner/test/phase3-v3.test.js')],
+    gap: 'claims are advisory findings; there are no declarative approved invariants and no bounded stateful scenario execution',
+    prd: ['X-401', 'X-402', 'X-403', 'X-404'],
+  },
+  {
+    id: 'stateful-invariant-execution', workstream: 4, title: 'Approved invariants, stateful scenarios, state oracles and sequence shrinking',
+    status: 'unsupported',
+    source: ['scanner/src/posture/logic-claims.js', 'scanner/src/discovery'],
+    entryPoints: [],
+    evidence: [t('scanner/test/logic-claims.test.js')],
+    gap: 'no executable invariant contract, approval state, scenario generator, durable-effect oracle or minimizer exists in the checkout',
+    prd: ['X-401', 'X-403', 'X-404', 'X-405'],
+  },
+  {
+    id: 'egress-policy-redaction-audit', workstream: 5, title: 'Central egress policy, outbound redaction and tamper-evident audit',
+    status: 'implemented',
+    source: ['scanner/src/egress/policy.js', 'scanner/src/egress/redact.js', 'scanner/src/egress/audit.js'],
+    entryPoints: [{ path: 'scanner/src/egress/policy.js', symbol: 'evaluateEgress' }, { path: 'scanner/src/egress/redact.js', symbol: 'redactPayload' }, { path: 'scanner/src/egress/audit.js', symbol: 'recordEgressCall' }],
+    evidence: [t('scanner/test/egress-policy.test.js'), t('scanner/test/egress-redact.test.js'), t('scanner/test/egress-audit.test.js'), t('scanner/test/egress-policy-completeness.test.js')],
+    gap: null,
+    prd: ['CORE-004', 'X-504'],
+  },
+  {
+    id: 'agent-hooks', workstream: 5, title: 'Pre-edit, pre-bash and dispatch hooks',
+    status: 'partial',
+    source: ['hooks/pre-bash-guard.js', 'hooks/pre-edit-bodyguard.js', 'hooks/dispatch-pre-tool.js', 'hooks/hooks.json'],
+    entryPoints: [],
+    evidence: [t('scanner/test/pre-bash-guard.test.js'), t('scanner/test/bodyguard.test.js'), t('scanner/test/dispatch-pre-tool.test.js')],
+    gap: 'hooks explain and advise at the prompt layer; no runner mediates filesystem, command or network access, so a hook response is not an enforcement receipt',
+    prd: ['X-501', 'X-502', 'X-505', 'X-507'],
+  },
+  {
+    id: 'mcp-server', workstream: 2, title: 'MCP server tools (including the write-gated fix tools)',
+    status: 'partial',
+    source: ['scanner/src/mcp/server.js', 'scanner/src/mcp/tools.js', 'scanner/src/mcp/validate.js', 'scanner/src/mcp/audit.js'],
+    entryPoints: [],
+    evidence: [t('scanner/test/mcp.test.js'), t('scanner/test/mcp-audit.test.js'), t('scanner/test/mcp-protocol-smoke.test.js')],
+    gap: 'tool results are not yet emitted as the unified verification record',
+    prd: ['X-206'],
+  },
+  {
+    id: 'model-routing-and-trust', workstream: 6, title: 'Model routing, measured trust, cache economics and provider catalog',
+    status: 'partial',
+    source: ['scanner/src/posture/model-routing.js', 'scanner/src/posture/model-trust.js', 'scanner/src/posture/cache-economics.js', 'scanner/src/posture/provider-catalog.js'],
+    entryPoints: [{ path: 'scanner/src/posture/model-trust.js', symbol: 'createTrustLedger' }, { path: 'scanner/src/posture/model-routing.js', symbol: 'routeModelWithTrust' }],
+    evidence: [t('scanner/test/model-routing.test.js'), t('scanner/test/model-trust.test.js'), t('scanner/test/cache-economics.test.js'), t('scanner/test/providers.test.js'), a('bench/router-replay/baseline.json')],
+    gap: 'trust is a per-key miss-rate ledger; there are no adjudicated task strata, calibrated quality intervals, shadow validation or drift circuit breakers',
+    prd: ['X-601', 'X-603', 'X-604', 'X-605'],
+  },
+  {
+    id: 'fleet-checkpoints', workstream: 7, title: 'Fleet runs and scan checkpoints',
+    status: 'partial',
+    source: ['scanner/src/posture/fleet.js', 'scanner/src/posture/scan-checkpoint.js', 'scripts/fleet.mjs'],
+    entryPoints: [{ path: 'scanner/src/posture/scan-checkpoint.js', symbol: 'openCheckpoint' }],
+    evidence: [t('scanner/test/fleet.test.js'), t('scanner/test/scan-checkpoint.test.js')],
+    gap: 'checkpoints resume a single scan; there are no durable leased work units, dependency-hash invalidation or portfolio budgets',
+    prd: ['X-704', 'X-705', 'X-706'],
+  },
+  {
+    id: 'attestation-and-evidence-bundles', workstream: 7, title: 'Run attestation, signed per-finding evidence bundles, integrity and retention',
+    status: 'partial',
+    source: ['scanner/src/posture/attestation.js', 'scanner/src/posture/evidence-bundle.js', 'scanner/src/posture/integrity.js', 'scanner/src/posture/retention-policy.js'],
+    entryPoints: [{ path: 'scanner/src/posture/evidence-bundle.js', symbol: 'signEvidenceBundle' }, { path: 'scanner/src/posture/attestation.js', symbol: 'computeRunAttestation' }],
+    evidence: [t('scanner/test/attestation.test.js'), t('scanner/test/evidence-bundle.test.js'), t('scanner/test/retention-policy.test.js'), t('scanner/test/verify-attestation-cli.test.js')],
+    gap: 'bundles are per finding with a local signer; there is no release assurance manifest, portable package or explicit trust-root policy',
+    prd: ['X-701', 'X-702', 'X-703', 'CORE-003'],
+  },
+  {
+    id: 'accuracy-scorecard', workstream: 1, title: 'Published accuracy scorecard and corpus replay',
+    status: 'implemented',
+    source: ['scanner/src/posture/accuracy-scorecard.js', 'scripts/scorecard.mjs'],
+    entryPoints: [],
+    evidence: [t('scanner/test/accuracy-scorecard.test.js'), t('scanner/test/scorecard.test.js'), a('docs/scorecard.json')],
+    gap: null,
+    prd: ['QA-004'],
+  },
+  {
+    id: 'independent-accuracy-current-engine', workstream: 1, title: 'Current-engine accuracy on independent real code',
+    status: 'unmeasured',
+    source: ['bench/independent/runner.mjs', 'bench/independent/manifest.json'],
+    entryPoints: [],
+    evidence: [a('docs/scorecard.json'), a('docs/INDEPENDENT_POPULATION_ROOT_CAUSE.md')],
+    gap: 'the recorded independent result belongs to an older engine revision; no current-engine adjudicated measurement exists in the checkout',
+    prd: ['QA-001', 'QA-002', 'QA-003'],
+  },
+  {
+    id: 'loop-controller', workstream: 'foundation', title: 'Supervised background implementation controller (Haskell/Nix profile)',
+    status: 'partial',
+    source: ['scripts/loop-engineering/run.mjs', 'scripts/loop-engineering/profiles/haskell-nix.json'],
+    entryPoints: [],
+    evidence: [t('scripts/loop-engineering/test/loop-manifest.test.js'), t('scripts/loop-engineering/test/loop-watchdog.test.js'), t('scripts/loop-engineering/test/loop-recovery.test.js')],
+    gap: 'only the Haskell/Nix profile exists; the assurance-differentiation profile and its protected acceptance suites are not present',
+    prd: ['LOOP-001', 'LOOP-002', 'LOOP-003'],
+  },
+  {
+    id: 'lineage-graph', workstream: 3, title: 'Data Flow Explorer lineage graph (DataFlowGraph v1)',
+    status: 'implemented',
+    source: ['scanner/src/lineage/graph-builder.js', 'scanner/src/lineage/ids.js', 'scanner/src/lineage/schema.js', 'scanner/src/lineage/dataflow-graph.schema.json'],
+    entryPoints: [{ path: 'scanner/src/lineage/ids.js', symbol: 'graphId' }],
+    evidence: [t('scanner/test/lineage/schema.test.js'), t('scanner/test/lineage/ids.test.js')],
+    gap: null,
+    prd: ['X-301'],
+  },
+]);