create-agdf 0.20.2 → 0.31.0

package/runtime/core/lib/companion/run-view.js

@@ -0,0 +1,184 @@
+// Companion run view (SD SDD-001, SDD-002): a read-only projection of the unchanged gate-check
+// report of each run, beside the run inventory of one project root. It never re-derives a gate
+// rule: status fields are copied from the status card verbatim, so every consumer of the run
+// view sees exactly what the status card shows. Nothing here writes or authorizes.
+import { existsSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { readFileSync } from '../control-read/fs.js';
+import { captureControlScope } from '../control-read/snapshot.js';
+import { evaluateGateCheck } from '../control-evaluation/gate-check.js';
+import { readRunInventory } from '../control-state/run-inventory-reader.js';
+import { runFolderEntries } from '../control-state/run-state-reader.js';
+import { readArtefactBindings } from '../control-state/artefact-bindings.js';
+import { readEvidenceBindings } from '../control-state/evidence-bindings.js';
+import { runRelativePath } from '../control-state/run-identity.js';
+import { artefactFileDigest } from '../control-state/run-seal-compute.js';
+import { boundedCode } from '../control-inspect/run-classification.js';
+import { localizeBlockingCondition, localizeOperationalValue } from '../interaction-presentation.js';
+import { interactionLocales } from '../resources/context.js';
+import { deriveFigureState } from './figure-state.js';
+
+export const RUN_VIEW_SCHEMA = 'run-view/1';
+export const DIAGNOSIS_REASONS = Object.freeze(['run_version_unsupported', 'run_state_invalid', 'too_large', 'missing']);
+// The reader's findings for a run folder without a readable run state: the path finding of
+// run-state-reader.js (invalidRun) and the inventory's finding for a run without text (run-inventory.js).
+const MISSING_CODES = new Set(['AGDF_RUN_PATH_INVALID', 'AGDF_RUN_STATE_UNAVAILABLE']);
+// The classifications run-state-resolver.js treats as unsupported (AGDF_RUN_VERSION_UNSUPPORTED).
+const UNSUPPORTED_CLASSIFICATIONS = new Set(['unsupported_version', 'unsupported_layout']);
+
+// Per-run reason of an unreadable run (SD SDD-003) from the reader findings: unsupported by their
+// classification, as run-state-resolver.js and the cockpit decide it (CR finding CIR-03), missing
+// when only the missing-state findings are present, otherwise invalid. Core reports no size bound
+// of its own, so an oversized run state is reported with the reason Core gives it; too_large stays
+// reserved for such a bound (contradiction C1).
+export function diagnosisReason(findings) {
+  if (findings.some(finding => UNSUPPORTED_CLASSIFICATIONS.has(finding.classification))) return 'run_version_unsupported';
+  if (findings.length && findings.every(finding => MISSING_CODES.has(finding.code))) return 'missing';
+  return 'run_state_invalid';
+}
+
+export function projectDiagnosis(entries) {
+  const unreadable = entries.filter(entry => !entry.valid).map(entry => ({ run_id: entry.run_id, reason: entry.unreadable_reason ?? 'run_state_invalid', codes: entry.findings }));
+  const by_reason = Object.fromEntries(DIAGNOSIS_REASONS.map(reason => [reason, unreadable.filter(row => row.reason === reason).length]));
+  return { unreadable, counts: { unreadable: unreadable.length, readable: entries.length - unreadable.length, by_reason } };
+}
+
+// One run entry: inventory facts plus, when evaluated, the status card fields of its report.
+export function projectRunEntry(inventoryEntry, report, { registry = interactionLocales, language = 'en' } = {}) {
+  const base = {
+    run_id: inventoryEntry.run_id,
+    title: inventoryEntry.title ?? null,
+    // The authored objective only; a template objective or a run-id title is no goal (CR finding C2).
+    objective: inventoryEntry.title_source === 'objective' ? inventoryEntry.title ?? null : null,
+    lifecycle: inventoryEntry.lifecycle ?? null,
+    valid: inventoryEntry.valid !== false,
+    revision: inventoryEntry.revision ?? null,
+    revision_id: inventoryEntry.revision_id ?? null,
+    last_activity: inventoryEntry.last_activity?.at ?? null,
+    findings: (inventoryEntry.findings ?? []).map(finding => finding.code),
+  };
+  if (!base.valid) base.unreadable_reason = diagnosisReason(inventoryEntry.findings ?? []);
+  // A run whose evaluation threw is reported with the bounded reason, never as an idle run (CR A7).
+  if (report?.evaluation_error) return withFigure({ ...base, evaluated: false, evaluation_error: report.evaluation_error });
+  if (!report?.status_card) return withFigure({ ...base, evaluated: false });
+  const card = report.status_card;
+  return withFigure({
+    ...base,
+    title: card.humanPresentation?.runTitle ?? base.title,
+    evaluated: true,
+    status: card.status,
+    current_gate: card.current_gate,
+    path: card.breadcrumb.map(({ gate, status }) => ({ gate, status })),
+    missing_approval: card.missing_approval,
+    blocking_reason: card.blocking_condition,
+    blocking_text: localizeBlockingCondition(card.blocking_condition, { registry, requestedLocale: language }) ?? card.blocking_condition,
+    next_step: card.next_step,
+    next_step_text: localizeOperationalValue(card.next_step, { registry, requestedLocale: language }) ?? card.next_step,
+    user_action_required: card.user_action_required,
+    doctor_status: report.doctor_status,
+    mode: card.mode_slice_decision ?? card.mode ?? null,
+  });
+}
+const withFigure = entry => ({ ...entry, figure: deriveFigureState(entry) });
+
+// Pure assembly of the versioned view from already evaluated parts.
+export function projectRunView({ root, language, store, entries }) {
+  return {
+    schema_version: RUN_VIEW_SCHEMA,
+    root,
+    language,
+    store,
+    diagnosis: projectDiagnosis(entries.filter(entry => entry.listed !== false)),
+    runs: entries,
+    authorizes: false,
+  };
+}
+
+// Drift warnings (SD SDD-008, PRD AC-008): documents the run state binds with a recorded digest
+// (effective artefact binding destination, latest evidence report per path) whose file now has another
+// canonical digest from the node digest owner. Declared input files of a recording are not kept in
+// the run state, so only bound documents are compared (contradiction C5 of this run). An unreadable
+// run state yields no warning; the status card reports it.
+export function readRunDrift(root, runId) {
+  let content;
+  try { content = readFileSync(join(root, runRelativePath(runId, '', 'RUN_STATE.md')), 'utf8'); } catch { return []; }
+  const declared = new Map();
+  const artefacts = readArtefactBindings(content);
+  // A binding a recorded source revision invalidated is superseded for Core, so its document being
+  // re-drafted is no drift (CR finding A5).
+  for (const receipt of artefacts.valid ? artefacts.active ?? [] : []) {
+    declared.set(receipt.destination.path, { document: receipt.destination.type, digest: receipt.destination.digest });
+  }
+  const evidence = readEvidenceBindings(content);
+  for (const row of evidence.valid ? evidence.bindings : []) {
+    declared.set(row.report.path, { document: row.report.path.split('/').at(-1).replace(/\.md$/u, ''), digest: row.report.digest });
+  }
+  const drift = [];
+  for (const [path, { document, digest }] of declared) {
+    const current = artefactFileDigest(root, path);
+    if (current === digest) continue;
+    drift.push({ document, path, recorded_digest: digest, current_digest: /^sha256:/u.test(current) ? current : null });
+  }
+  return drift;
+}
+
+// Active and unreadable runs are evaluated; terminal runs are summarized unless requested by id,
+// so a large history does not cost one evaluation per run.
+const needsEvaluation = (entry, requested) => requested.has(entry.run_id) || !entry.valid || entry.lifecycle === 'active';
+
+// A write that lands during a capture invalidates it (source_changed); the read is repeated a bounded
+// number of times before the change is reported (CR delta review RV-1).
+export const CAPTURE_ATTEMPTS = 3;
+export function captured(readRoot, project, capture = captureControlScope) {
+  for (let attempt = 1; ; attempt += 1) {
+    try { return capture(readRoot, view => project(view.root)).data; }
+    catch (error) { if (error?.code !== 'source_changed' || attempt >= CAPTURE_ATTEMPTS) throw error; }
+  }
+}
+
+// Reads inside bounded, revalidated control snapshots (TP T-002, SD section 4: captureControlScope,
+// CR finding CIR-01): the inventory in one snapshot and each evaluated run with its drift in its own,
+// so a read-boundary failure of one run (a linked file, a document outside the control folder, a read
+// limit) marks only that run and the readable runs stay listed (SDD-003, RV-2). The root is resolved
+// first, as MCP canonicalizes its target, so a junction or symlinked project root reads like its
+// target; the view keeps the caller's spelling (RV-3). A missing root has no control folder (RV-5).
+export function readRunView(root, { language = 'en', runIds = [] } = {}) {
+  const empty = store => projectRunView({ root, language, store, entries: [] });
+  if (!existsSync(root)) return empty({ status: 'no_control', reason: null });
+  let readRoot;
+  try { readRoot = realpathSync(root); } catch (error) { return empty({ status: 'unavailable', reason: boundedCode(error) }); }
+  const requested = new Set(runIds);
+  const evaluate = runId => {
+    try {
+      return captured(readRoot, base => {
+        const report = evaluateGateCheck(base, { runId, ignoreRunIdEnv: true, presentationLanguage: language });
+        return { report, drift: report?.status_card ? readRunDrift(base, runId) : null };
+      });
+    } catch (error) { return { report: { evaluation_error: boundedCode(error) }, drift: null }; }
+  };
+  const entryOf = (inventoryEntry, evaluated) => {
+    const entry = projectRunEntry(inventoryEntry, evaluated?.report ?? null, { language });
+    return entry.evaluated && entry.valid !== false && evaluated.drift ? { ...entry, drift: evaluated.drift } : entry;
+  };
+  let inventory = null, store;
+  try {
+    inventory = captured(readRoot, base => readRunInventory(base, { language, observe: false }));
+    store = { status: inventory.state === 'absent' ? 'no_control' : 'ok', reason: null };
+  } catch (error) {
+    store = { status: 'unavailable', reason: boundedCode(error) };
+    // An unsupported layout lists no run, but its run folders can be counted, so a consumer names count
+    // and reason instead of "no open runs" (PRD AC-002, TP T-004). A failing count leaves the field out.
+    if (store.reason === 'control_layout_unsupported') {
+      try { store.run_folders = captured(readRoot, base => runFolderEntries(base).length); } catch { /* count unknown */ }
+    }
+  }
+  const listed = inventory?.runs ?? [];
+  const entries = listed.map(entry => entryOf(entry, needsEvaluation(entry, requested) ? evaluate(entry.run_id) : null));
+  for (const runId of requested) {
+    if (listed.some(entry => entry.run_id === runId)) continue;
+    // Requested but not listed by the inventory (for example behind an unsupported layout):
+    // evaluated for its card, never counted in the diagnosis of listed runs.
+    entries.push({ ...entryOf({ run_id: runId, findings: [] }, evaluate(runId)), valid: null, listed: false });
+  }
+  return projectRunView({ root, language, store, entries });
+}

package/runtime/core/lib/control-evaluation/acceptance-criteria.js

@@ -4,6 +4,8 @@ const CRITERION_ID = /^[A-Z][A-Z0-9]*(?:-[A-Z0-9]+)*$/u;
 export const ACCEPTANCE_CRITERIA_FORMAT = Object.freeze({
   section: "Acceptance Criteria", declaration: "criterion_id: <stable id>",
   fields: "semicolon-separated inline fields or following bullet key: value lines",
+  description_fields: Object.freeze(["observable_success", "visible_feedback", "expected_effective_state"]),
+  description_rule: "For same-language approval rendering, provide at least one nonempty description field separately. Never concatenate field names or infer their meaning from combined keys.",
   id_pattern: CRITERION_ID.source,
   examples: Object.freeze([
     "## Acceptance Criteria\n- criterion_id: AC-001; observable_success: Saved choice remains selected",

package/runtime/core/lib/control-evaluation/closeout-readiness.js

@@ -8,6 +8,14 @@ import { inspectQaReports } from './qa-follow-up.js';
 export { STRUCTURED_REQUIRED_REVIEWS, reviewArtefactType };
 
 export const closeoutConfirmation = (runId, revisionId, operationId, orDigest) => `Close Run: ${runId} ${revisionId} ${operationId} ${orDigest}`;
+// Discovery and validation share the existing compact document requirements.
+export const QUICK_CLOSEOUT_AUTHORING_FORMAT = {
+  template: 'OR', report_mode: 'OR-lite',
+  required_metadata: [{ field: 'run_id', label: 'Run' }, { field: 'report_mode', label: 'Report mode' }],
+  run_binding: 'Exactly one Run: <current run_id> or - run_id: <current run_id>; never both.',
+  required_sections: ['Result', 'Evidence', 'Risk', 'Next Step'],
+  template_scope: 'Use the bound OR template for identity; OR-lite needs only the declared metadata and four concrete sections, not OR-full sections.',
+};
 const value = (text, field, label) => cleanStatusCell(extractField(text, field) || (label ? text.match(new RegExp(`^${label}:[ \\t]*(.*)$`, 'mu'))?.[1] : ''));
 const concrete = text => filled(text) && !isPlaceholderValue(text) && !/^(?:tbd|todo|<)/iu.test(text);
 export function closeoutContext(text) {
@@ -16,13 +24,31 @@ export function closeoutContext(text) {
 }
 export const closeoutContextDigest = text => digest(`agdf-closeout-context/1\0${canonicalJson(closeoutContext(text))}`);
 
+// Bindings a structured OR states; the same tables drive the check and the
+// expectations returned with a refusal.
+const OR_SOURCE_FIELDS = Object.freeze({ related_ur: 'UR', related_prd: 'PRD', related_sd: 'SD', related_tp: 'TP', related_qa_report: 'QA' });
+const OR_GATE_ROWS = Object.freeze(['UR', 'PRD', 'SD', 'TP', 'Brownfield Review', 'Brownfield Analysis', 'CD+Tests', 'CR', 'QA', 'UAT']);
+const OR_MEMORY_TARGETS = Object.freeze(['context_graph', 'sot_registry', 'scope_artifact', 'open_questions', 'none']);
+const gateRowExpectation = (state, type) => ({
+  status: state.approvals.has(type) ? state.approvals.get(type).status : state.artefacts.get(type)?.status,
+  reference: state.artefacts.get(type)?.path || state.approvals.get(type)?.evidence,
+});
+function structuredOrExpectations(state, route) {
+  return {
+    fields: { ...Object.fromEntries(Object.entries(OR_SOURCE_FIELDS).map(([field, type]) => [field, state.artefacts.get(type)?.path ?? null])),
+      mode_slice_decision: route, current_gate: 'OR', decision: 'pass', required_approval: 'none' },
+    gate_state_rows: Object.fromEntries(OR_GATE_ROWS.map(type => [type, gateRowExpectation(state, type)])),
+    memory_target: OR_MEMORY_TARGETS, memory_fields: 'memory_reason and memory_refs need concrete text',
+  };
+}
+
 // Shared observation of registered OR and prepared OR candidates. Legacy reports retain
 // their documented formats; the new writer additionally requires the complete template.
 export function evaluateCloseoutReadiness(state, report, readArtefact, { prepared = false } = {}) {
   const findings = [], fail = reason => findings.push(reason), route = state.mode_slice_decision?.decision;
   const structured = ['structured_slice', 'structured_delivery'].includes(route);
   if (typeof report !== 'string' || Buffer.byteLength(report) > 131072) return { ready: false, findings: ['or_unavailable_or_oversized'] };
-  if (prepared) for (const [field, label] of [['run_id', 'Run'], ['report_mode', 'Report mode'], ...(structured ? [['status', 'Status']] : [])]) {
+  if (prepared) for (const [field, label] of [...QUICK_CLOSEOUT_AUTHORING_FORMAT.required_metadata.map(row => [row.field, row.label]), ...(structured ? [['status', 'Status']] : [])]) {
     const declarations = [...report.matchAll(new RegExp(`^(?:- ${field}|${label}):[ \\t]*(.*)$`, 'gmu'))];
     if (declarations.length !== 1) fail('or_field_ambiguous:' + field);
   }
@@ -34,7 +60,7 @@ export function evaluateCloseoutReadiness(state, report, readArtefact, { prepare
   if (programme?.applicable && !programme.final_ready) fail('programme_aggregation_unfulfilled');
   if (!structured) {
     if (state.artefacts.get('CR')?.status !== 'done') fail('code_review_missing');
-    for (const section of ['Result', 'Evidence', 'Risk', 'Next Step']) if (!concrete(markdownSection(report, section).trim())) fail(`or_${section.toLowerCase().replaceAll(' ', '_')}_missing`);
+    for (const section of QUICK_CLOSEOUT_AUTHORING_FORMAT.required_sections) if (!concrete(markdownSection(report, section).trim())) fail(`or_${section.toLowerCase().replaceAll(' ', '_')}_missing`);
   } else {
     if (!['done', 'completed', 'pass'].includes(value(report, 'status', 'Status'))) fail('or_status_unconfirmed');
     for (const gate of ['UR', 'PRD', 'SD', 'TP', 'QA', 'UAT']) {
@@ -77,14 +103,13 @@ export function evaluateCloseoutReadiness(state, report, readArtefact, { prepare
         ...Object.keys(context), 'next_allowed_action', 'required_approval', 'forbidden_until_then']) {
         if ([...report.matchAll(new RegExp(`^- ${field}:[ \\t]*(.*)$`, 'gmu'))].length !== 1) fail('or_field_ambiguous:' + field);
       }
-      for (const [field, type] of Object.entries({ related_ur: 'UR', related_prd: 'PRD', related_sd: 'SD', related_tp: 'TP', related_qa_report: 'QA' })) {
+      for (const [field, type] of Object.entries(OR_SOURCE_FIELDS)) {
         if (value(report, field) !== state.artefacts.get(type)?.path) fail('or_source_reference_invalid:' + field);
       }
       if (value(report, 'mode_slice_decision') !== route || value(report, 'current_gate') !== 'OR' || value(report, 'decision') !== 'pass') fail('or_control_binding_invalid');
       const gateRows = tableRows(markdownSection(report, 'Gate State')).filter(row => row[0] !== 'Gate or step');
-      for (const type of ['UR', 'PRD', 'SD', 'TP', 'Brownfield Review', 'Brownfield Analysis', 'CD+Tests', 'CR', 'QA', 'UAT']) {
-        const rows = gateRows.filter(row => row[0] === type), expected = state.approvals.has(type) ? state.approvals.get(type).status : state.artefacts.get(type)?.status;
-        const reference = state.artefacts.get(type)?.path || state.approvals.get(type)?.evidence;
+      for (const type of OR_GATE_ROWS) {
+        const rows = gateRows.filter(row => row[0] === type), { status: expected, reference } = gateRowExpectation(state, type);
         if (rows.length !== 1 || rows[0][1] !== expected || !concrete(rows[0][2])
           || cleanStatusCell(rows[0][2]) !== cleanStatusCell(reference)) fail('or_gate_state_unconfirmed:' + type);
       }
@@ -93,11 +118,12 @@ export function evaluateCloseoutReadiness(state, report, readArtefact, { prepare
         if (!concrete(text) || /<[^>]+>|\|[ \t]*\|/u.test(text)) fail('or_section_incomplete:' + section);
       }
       for (const section of ['Missing Evidence', 'Risks And Open Items']) if (/\|\s*(?:revise|block)\s*\|/u.test(markdownSection(report, section))) fail('or_required_obligation_open:' + section);
-      if (!['context_graph', 'sot_registry', 'scope_artifact', 'open_questions', 'none'].includes(context.memory_target)
+      if (!OR_MEMORY_TARGETS.includes(context.memory_target)
         || !concrete(context.memory_reason) || !concrete(context.memory_refs)) fail('or_knowledge_decision_incomplete');
       if (value(report, 'required_approval') !== 'none') fail('or_required_approval_open');
     }
   }
   return { ready: findings.length === 0, findings, route, context_digest: closeoutContextDigest(report),
-    parent_reconciliation: parent ?? null, programme_aggregation: programme ?? null };
+    parent_reconciliation: parent ?? null, programme_aggregation: programme ?? null,
+    ...(prepared && structured && findings.length ? { expected: structuredOrExpectations(state, route) } : {}) };
 }

package/runtime/core/lib/control-evaluation/decision-content-placeholder.js

@@ -0,0 +1,9 @@
+// Template prompts and status-only values that never count as authored content. Pure, so the
+// run inventory and other `node:`-free readers share the same rule.
+const prompts = new Set(['describe the trustworthy outcome.', 'what outcome should become possible?',
+  'which tp tasks are fully done, partially done or not done?', 'what remains unverified?', 'which risks remain and what is their impact?']);
+export function isDecisionContentPlaceholder(value) {
+  if (typeof value !== 'string') return true;
+  const text = value.trim().replace(/^`([^`]+)`$/u, '$1').replace(/\s+/gu, ' ').toLowerCase();
+  return !text || prompts.has(text) || /^(?:todo|tbd|<[^>]+>|(?:draft|done|ready|blocked|pass|revise|block)(?:\s*\|\s*(?:draft|done|ready|blocked|pass|revise|block))+)$/.test(text);
+}

package/runtime/core/lib/control-evaluation/decision-content-readiness.js

@@ -3,14 +3,9 @@ import { containedRegularFile, hasSymlinkComponent } from '../control-state/cont
 import { artefactFileDigest } from '../control-state/run-seal-compute.js';
 import { readAuthoredContent, readReportDecision } from './report-decision.js';
 import { inspectQaReports } from './qa-follow-up.js';
+import { isDecisionContentPlaceholder } from './decision-content-placeholder.js';
 
-const prompts = new Set(['describe the trustworthy outcome.', 'what outcome should become possible?',
-  'which tp tasks are fully done, partially done or not done?', 'what remains unverified?', 'which risks remain and what is their impact?']);
-export function isDecisionContentPlaceholder(value) {
-  if (typeof value !== 'string') return true;
-  const text = value.trim().replace(/^`([^`]+)`$/u, '$1').replace(/\s+/gu, ' ').toLowerCase();
-  return !text || prompts.has(text) || /^(?:todo|tbd|<[^>]+>|(?:draft|done|ready|blocked|pass|revise|block)(?:\s*\|\s*(?:draft|done|ready|blocked|pass|revise|block))+)$/.test(text);
-}
+export { isDecisionContentPlaceholder };
 export function concreteDecisionContent(value, { allowNone = false } = {}) {
   return typeof value === 'string' && value.length <= 1200 && !isDecisionContentPlaceholder(value)
     && !/^(?:pass|passed|revise|block|done|ready|draft)$/iu.test(value.trim())

package/runtime/core/lib/control-evaluation/definition-sources.js

@@ -1,3 +1,4 @@
+import { runDocumentPath } from '../control-state/run-identity.js';
 import { readFileSync } from '../control-read/fs.js';
 import { hasSymlinkComponent, containedRegularFile } from '../control-state/contained-file.js';
 import { artefactFileDigest } from '../control-state/run-seal-compute.js';
@@ -14,7 +15,7 @@ export function inspectUxIntentDecision(content) {
 export function inspectDefinitionSources(root, state, runId, gate, sourceTypes) {
   const sources = [];
   const issue = (code, path, expected, observed, repairable = false) => ({ sources, issue: { code, path, expected, observed, repairable } });
-  const output = `.agdf/control/artefacts/${runId}/${gate}.md`;
+  const output = `${runDocumentPath(runId, '')}/${gate}.md`;
   if (!state || hasSymlinkComponent(root, output)) return issue('unsafe_destination', output, 'contained non-symlink output', 'unsafe');
   for (const type of sourceTypes) {
     const path = String(state.artefacts.get(type)?.path ?? '').replace(/^`|`$/gu, '');
@@ -29,7 +30,7 @@ export function inspectDefinitionSources(root, state, runId, gate, sourceTypes)
   const reviewSource = sources.find(source => source.type === 'Brownfield Review');
   const review = reviewSource ? readFileSync(containedRegularFile(root, reviewSource.path).path, 'utf8') : '';
   if (extractField(review, 'ux_intent_definition_required') === 'yes') {
-    const canonical = `.agdf/control/artefacts/${runId}/UX_INTENT_DEFINITION.md`;
+    const canonical = `${runDocumentPath(runId, '')}/UX_INTENT_DEFINITION.md`;
     const analysis = state.artefacts.get('UX Intent Definition');
     const path = String(analysis?.path || canonical).replace(/^`|`$/gu, '');
     if (path !== canonical || hasSymlinkComponent(root, path)) return issue('unsafe_ux_source', path, canonical, 'foreign or unsafe source');

package/runtime/core/lib/control-evaluation/delivery-map.js

@@ -1,5 +1,3 @@
-import { existsSync } from "../control-read/fs.js";
-import { join } from 'node:path';
 import { aggregate } from "../control-state/aggregate.js";
 import { resolveRuns } from "../control-state/run-state-resolver.js";
 import { resolveConfiguredChatLanguage } from "../resources/context.js";
@@ -7,7 +5,7 @@ import { isGateSatisfied, transitionDecisionForRunState } from "./gate-policy.js
 import { effectiveNextAllowedAction } from "./next-action.js";
 import { gateApprovalStatus, readRunState, resolvedArtefactFile } from "./run-state.js";
 import { deliveryRelationships, relationshipRequired, sameRelationship } from "./delivery-relationships.js";
-import { allowNoActiveRuns, filled, markdownSection, parseBacklogSection, readTargetFile } from "./shared.js";
+import { allowNoActiveRuns, filled } from "./shared.js";
 import { evaluateReconciliationState } from "./parent-reconciliation.js";
 import { readSourceRevisions, sourceRevisionObservation } from "../control-state/run-source-revisions.js";
 import { readArtefactBindings } from "../control-state/artefact-bindings.js";
@@ -153,14 +151,6 @@ export function deriveQualityOutlook(runState, findings = []) {
   return "No additional quality follow-up identified from the current control state.";
 }
 
-function readBacklogPointers(targetDir) {
-  const backlogPath = join(".agdf", "control", "MASTER_BACKLOG.md");
-  if (!existsSync(join(targetDir, backlogPath))) return [];
-
-  const backlog = readTargetFile(targetDir, backlogPath);
-  const activeSection = markdownSection(backlog, "Active Backlog");
-  return parseBacklogSection(activeSection);
-}
 
 export function evaluateDeliveryMap(targetDir, selection = {}, dependencies = {}) {
   const { evaluateDoctor, buildStatusCard, postApprovalTransition } = dependencies;
@@ -253,7 +243,7 @@ export function evaluateDeliveryMap(targetDir, selection = {}, dependencies = {}
       chatLanguage: resolveConfiguredChatLanguage(targetDir),
       findings: map.findings,
     }),
-    backlog_pointers: readBacklogPointers(targetDir),
+    backlog_pointers: [], // Legacy field: current relationships come from registered Run sources.
     artefacts: Object.fromEntries([...runState.artefacts.entries()]),
     approvals: Object.fromEntries([...runState.approvals.entries()]),
     mode_slice_decision: runState.mode_slice_decision,