create-agdf 0.20.2 → 0.31.0

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-store-inspection.js

@@ -1,6 +1,7 @@
 import { lstatSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { doctorRequiredFiles } from "../control-evaluation/required-files.js";
+import { readControlLayout, CURRENT_LAYOUT } from './control-layout.js';
 
 export function canonicalScaffoldRequired(root, path) {
   const error = new Error(
@@ -24,11 +25,12 @@ export function regularFileSnapshot(path) {
   return Object.freeze({ path, dev: stats.dev, ino: stats.ino, content: readFileSync(path) });
 }
 
-export function assertCanonicalRunStore(root) {
+export function assertCanonicalRunStore(root, { historicalRead = false } = {}) {
   const directoryPaths = [
     root,
     join(root, ".agdf"),
     join(root, ".agdf", "control"),
+    join(root, ".agdf", "control", "planned"),
     join(root, ".agdf", "control", "runs"),
   ];
   const directories = [];
@@ -40,10 +42,20 @@ export function assertCanonicalRunStore(root) {
       throw canonicalScaffoldRequired(root, path);
     }
   }
+  // Original creation lookup reads its sealed staged receipt before resolving
+  // today's configuration. This read-only path requires containment, not a
+  // current layout decision.
+  if (!historicalRead) {
+    try { readControlLayout(root); }
+    catch (error) {
+      if (error.message === 'AGDF_CONTROL_PATH_INVALID') throw canonicalScaffoldRequired(root, join(root, '.agdf/control/config.json'));
+      throw error;
+    }
+  }
   const requiredPaths = [...new Set([
     join(".agdf", "control", "config.json"),
     join(".agdf", "control", "README.md"),
-    ...doctorRequiredFiles.filter((path) => !path.endsWith("AGDF_RUN.md")),
+    ...doctorRequiredFiles,
   ])];
   const files = [];
   for (const relativePath of requiredPaths) {

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-verified-change.js

@@ -0,0 +1,81 @@
+import { runDocumentPath, runControlPath } from './run-identity.js';
+import { canonicalJson, digest } from './approval-command-contract.js';
+import { canonicalRunText } from './run-seal.js';
+import { prepareOwnedOutput } from './run-owned-outputs.js';
+import { replaceFirstScalar } from './run-state-edits.js';
+import { prepareRunContentState } from '../control-evaluation/run-state.js';
+import { evaluateVerifiedChange, extractField, parseVerifiedChangePathList, readVerifiedChangeRecord } from '../control-evaluation/verified-change.js';
+import { filled, isPlaceholderValue } from '../control-evaluation/shared.js';
+import { closeoutConfirmation, closeoutContextDigest } from '../control-evaluation/closeout-readiness.js';
+import { currentOwnedMutationClaimPaths } from './control-layout.js';
+
+// These exact transient paths belong to the locks/journal of the active recording
+// owner. Caller paths, foreign locks and arbitrary suffixes are never ignored.
+export function ownedRecordingGitObservation(observation, runId) {
+  const transient = new Set([`.agdf/control/runs/${runId}/RUN_STATE.md.lock`,
+    runControlPath(runId, 'RUN_STEP_PENDING.json')]);
+  return { gitValue: observation?.gitValue, gitPathList(root, args) {
+    const ownClaims = new Set(currentOwnedMutationClaimPaths(root));
+    return observation?.gitPathList?.(root, args)?.filter(p => !transient.has(p) && !ownClaims.has(p)) ?? null;
+  } };
+}
+const invariantFields = ['related_ur', 'escalation_target', 'canonical_owner', 'allowed_source_paths', 'allowed_derived_paths',
+  'prohibited_impacts', 'propagation_command', 'validation_commands', 'baseline_commit', 'baseline_tracked_paths', 'baseline_untracked_paths'];
+const scalar = (text, key, value) => {
+  if ([...text.matchAll(new RegExp(`^- ${key}:.*$`, 'gmu'))].length !== 1) throw Error('verified_change_field_ambiguous');
+  return replaceFirstScalar(text, key, value);
+};
+
+// Domain preparation inside the existing Run transaction owner. Core
+// still evaluates the same compact eligibility rules as the CLI.
+export function prepareVerifiedChangeRecording(root, run, control, before, input, source, gitObservation) {
+  const phase = input.step === 'closeout' ? 'closeout' : input.phase;
+  const route = control.mode_slice_decision.decision;
+  if (control.approvals.get('UR')?.status !== 'approved' || control.meta.lifecycle !== 'active') throw Error('verified_change_not_ready');
+  if (phase === 'eligibility') {
+    if (!['Brownfield Review', 'Mode/Slice Decision', 'Verified Change Execution'].includes(before.current_gate)
+      || control.artefacts.get('Verified Change')?.path) throw Error('verified_change_not_ready');
+  } else if (route !== 'verified_change' || !['Verified Change Execution', 'OR'].includes(before.current_gate)) throw Error('verified_change_not_ready');
+  const observation = ownedRecordingGitObservation(gitObservation, input.runId);
+  const actual = () => ({ head: observation.gitValue?.(root, ['rev-parse', 'HEAD']) ?? null,
+    tracked: observation.gitPathList(root, ['diff', 'HEAD', '--name-only']), untracked: observation.gitPathList(root, ['ls-files', '--others', '--exclude-standard']) });
+  const seen = actual();
+  if (!seen.head || seen.tracked === null || seen.untracked === null) throw Error('verified_change_git_unavailable');
+  const path = `${runDocumentPath(input.runId, '')}/VERIFIED_CHANGE.md`;
+  let content = source.content;
+  if (phase === 'eligibility') {
+    content = scalar(content, 'baseline_commit', seen.head);
+    content = scalar(content, 'baseline_tracked_paths', seen.tracked.join(', ') || 'none');
+    content = scalar(content, 'baseline_untracked_paths', seen.untracked.join(', ') || 'none');
+    if (extractField(content, 'status') !== 'eligible') throw Error('verified_change_status_invalid');
+  } else {
+    const prior = readVerifiedChangeRecord(root, control);
+    if (prior.status !== 'present' || invariantFields.some(key => extractField(prior.content, key) !== extractField(content, key))) throw Error('verified_change_scope_changed');
+    if (phase === 'execution') {
+      if (!['executed', 'escalated'].includes(extractField(content, 'status'))) throw Error('verified_change_status_invalid');
+      const baseline = new Set([...parseVerifiedChangePathList(extractField(prior.content, 'baseline_tracked_paths')),
+        ...parseVerifiedChangePathList(extractField(prior.content, 'baseline_untracked_paths'))]);
+      const changed = [...new Set([...seen.tracked, ...seen.untracked])].filter(p => !baseline.has(p)).sort();
+      content = scalar(content, 'execution_changed_paths', changed.join(', ') || 'none');
+    }
+  }
+  let text = run.content;
+  const hash = digest(canonicalRunText(content)), proposedArtefacts = new Map([[path, { content, digest: hash }]]);
+  const candidate = prepareRunContentState(root, text, run.path, { proposedArtefacts });
+  candidate.artefacts = new Map(candidate.artefacts);
+  candidate.artefacts.set('Verified Change', { path, status: extractField(content, 'status') });
+  const evaluated = evaluateVerifiedChange(root, candidate, { ...observation, proposedArtefacts });
+  if (evaluated.findings.length && evaluated.status !== 'escalated' || phase === 'closeout' && evaluated.status !== 'executed') throw Error('verified_change_validation_failed:' + evaluated.findings.map(f => f.code).join(','));
+  if (phase === 'closeout') {
+    if (before.current_gate !== 'OR' || ['revise', 'block'].includes(control.context_graph?.gate_effect)) throw Error('verified_change_closeout_not_ready');
+    if (!['delivered', 'intentionally_not_delivered', 'residual_risk', 'next_step'].every(key => filled(extractField(content, key)) && !isPlaceholderValue(extractField(content, key)))) throw Error('verified_change_mini_closeout_incomplete');
+    if (input.confirmation !== closeoutConfirmation(input.runId, input.revisionId, input.operationId, hash)) throw Error('confirmation_required');
+    text = replaceFirstScalar(text, 'lifecycle', 'completed');
+  }
+  const record = phase === 'closeout' ? { mode: 'verified_change', verified_change: { path, digest: hash }, lifecycle: 'completed',
+    context_evidence_digest: closeoutContextDigest(content), confirmation_digest: digest(input.confirmation) } : null;
+  // Ignore only the transaction's own new control output when comparing paths.
+  const stable = value => canonicalJson({ ...value, tracked: value.tracked?.filter(p => p !== path), untracked: value.untracked?.filter(p => p !== path) });
+  return { text, content, path, digest: hash, record, outputs: [prepareOwnedOutput(root, input.runId, path, content)],
+    validate() { if (stable(actual()) !== stable(seen)) throw Error('verified_change_git_changed'); } };
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-work-summary-shape.d.ts

@@ -0,0 +1 @@
+export function validWorkSummary(value: unknown, runId: string): boolean;

package/{runtime/core/lib/control-state/backlog-summary-shape.js → generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-work-summary-shape.js}

@@ -1,24 +1,14 @@
-import { SUMMARY_KINDS } from '../control-evaluation/backlog-vocabulary.js';
+import { SUMMARY_KINDS } from '../control-evaluation/work-vocabulary.js';
+import { RUN_ID_PATTERN, runDocumentPath, runEvidencePath } from './run-identity.js';
 const exactObject = (v, keys) => !!v && typeof v === 'object' && !Array.isArray(v)
   && Object.keys(v).length === keys.length && keys.every(k => Object.hasOwn(v, k));
-export const BACKLOG_SUMMARY_FIELDS = ['schema_version', 'target_id', 'run_id', 'section', 'row_digest', 'revision_id', 'observed_at',
-  'kind', 'phase', 'qa_outcome', 'lifecycle', 'recorded_approvals', 'decisive_obligation', 'open_obligation_count',
-  'display_action', 'sources', 'limitations', 'authorizes'];
-const id = value => typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/u.test(value);
+const id = value => typeof value === 'string' && RUN_ID_PATTERN.test(value);
 const hash = value => typeof value === 'string' && /^sha256:[a-f0-9]{64}$/u.test(value);
 const text = value => typeof value === 'string' && !value.includes('\0');
 const list = value => Array.isArray(value) && value.every(text);
-const sourcePath = value => typeof value === 'string' && value.startsWith('.agdf/control/artefacts/')
+const sourcePath = (value, runId) => typeof value === 'string'
+  && [runDocumentPath(runId, ''), runEvidencePath(runId, '')].some(prefix => value.startsWith(`${prefix}/`))
   && !/[\\:%?#\0]/u.test(value) && value.split('/').every(part => part && part !== '.' && part !== '..');
-const sections = ['Active Backlog', 'Planned / Parking Lot', 'Completed / Superseded Pointers'];
-
-export function validBacklogSummary(row) {
-  return exactObject(row, BACKLOG_SUMMARY_FIELDS) && row.schema_version === 1 && hash(row.target_id) && id(row.run_id)
-    && sections.includes(row.section) && hash(row.row_digest)
-    && typeof row.revision_id === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u.test(row.revision_id)
-    && text(row.observed_at) && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{3})?Z$/u.test(row.observed_at) && Number.isFinite(Date.parse(row.observed_at))
-    && validWorkSummary(row, row.run_id);
-}
 
 export function validWorkSummary(row, runId) {
   if (!row || !id(runId)) return false;
@@ -30,11 +20,9 @@ export function validWorkSummary(row, runId) {
     && (row.decisive_obligation === null || exactObject(row.decisive_obligation, ['id', 'routing_target', 'action', 'source_path'])
       && text(row.decisive_obligation.id) && row.decisive_obligation.id.length <= 128
       && ['UR', 'PRD', 'SD', 'TP', 'CD+Tests', 'evidence_obligation'].includes(row.decisive_obligation.routing_target)
-      && text(row.decisive_obligation.action) && sourcePath(row.decisive_obligation.source_path)
-      && row.decisive_obligation.source_path.startsWith(`.agdf/control/artefacts/${runId}/`))
+      && text(row.decisive_obligation.action) && sourcePath(row.decisive_obligation.source_path, runId))
     && Number.isSafeInteger(row.open_obligation_count) && row.open_obligation_count >= 0 && row.open_obligation_count <= 64
     && text(row.display_action) && Array.isArray(row.sources) && row.sources.length <= 64
-    && row.sources.every(s => exactObject(s, ['path', 'digest', 'state']) && sourcePath(s.path)
-      && s.path.startsWith(`.agdf/control/artefacts/${runId}/`) && hash(s.digest) && s.state === 'available')
+    && row.sources.every(s => exactObject(s, ['path', 'digest', 'state']) && sourcePath(s.path, runId) && hash(s.digest) && s.state === 'available')
     && list(row.limitations) && row.authorizes === false;
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/delivery-continuation/service.js

@@ -1,67 +1,6 @@
-import process from "node:process";
-import { evaluateGateCheck } from "../control-evaluation/gate-check.js";
-import { correctRunRelationship } from "../control-state/run-relationship-correction.js";
-import { DISPATCH_RECOVERY } from "../interaction-catalog.js";
-import { localePack } from "../interaction-presentation.js";
-import { createSkillDispatchFailure, createSkillDispatchService } from "../skill-dispatch/service.js";
+import { createSkillDispatchService } from '../skill-dispatch/service.js';
 
-// Application owner for authorized continuation. Routing itself remains read-only.
-// Neither the initial route nor a correction refusal is emitted until this call returns.
-export function createDeliveryContinuationService(dependencies = {}) {
-  const route = createSkillDispatchService(dependencies);
-  const evaluateGate = dependencies.evaluateGateCheck ?? evaluateGateCheck;
-  const correct = dependencies.correctRunRelationship ?? correctRunRelationship;
-  const now = dependencies.now ?? (() => process.hrtime.bigint());
-  const elapsed = start => Math.round(Math.max(0, Number(now() - start) / 1_000_000) * 1000) / 1000;
-
-  return function executeDeliveryContinuation(rawInput) {
-    const started = now();
-    const initial = route(rawInput);
-    // A successful route supplies the validated intent, target and exact control binding.
-    // Invalid, unresolved, stale-assignment, status and judgement routes cannot mutate.
-    if (rawInput.continueDelivery !== true || initial.outcome !== "control_result"
-        || initial.skill?.dispatch_mode !== "deterministic_control"
-        || initial.target?.resolution_state !== "resolved"
-        || initial.control?.run_id !== rawInput.runId || !initial.control?.revision_id
-        || initial.control.blocking_reason !== "AGDF_DELIVERY_RELATIONSHIP_MISSING") return initial;
-
-    const correctionStarted = now();
-    let correction;
-    const fail = details => createSkillDispatchFailure({
-      skill: initial.skill, runtime: initial.runtime,
-      timing: { ...initial.timing, control_ms: initial.timing.control_ms + elapsed(correctionStarted), total_ms: elapsed(started) },
-      code: DISPATCH_RECOVERY.control_evaluation_failed, details,
-      interactionLocales: rawInput.interactionLocales, presentationLanguage: rawInput.presentationLanguage,
-      renderRecovery: dependencies.renderSkillDispatchRecovery,
-    });
-    try {
-      correction = correct(initial.target.governance_target, {
-        runId: initial.control.run_id, revisionId: initial.control.revision_id,
-      }, { evaluateGateCheck: evaluateGate });
-      if (correction.reason === "correction_commit_unconfirmed") {
-        return fail(`AGDF_CORRECTION_COMMIT_UNCONFIRMED: ${correction.run_id}; committed revision ${correction.revision_id}.`);
-      }
-      if (correction.outcome !== "corrected") {
-        initial.timing.control_ms += elapsed(correctionStarted);
-        initial.timing.total_ms = elapsed(started);
-        return initial;
-      }
-      const correctionMs = elapsed(correctionStarted);
-      // Reuse the resolved target; evaluate the committed run afresh and route exactly once.
-      const freshRoute = createSkillDispatchService({ ...dependencies,
-        resolveTaskTarget: () => initial.target,
-        evaluateGateCheck: (root, selection) => {
-          const report = evaluateGate(root, selection);
-          return { ...report, relationship_correction: { ...correction,
-            message: localePack(rawInput.interactionLocales ?? dependencies.pluginDefinition?.interactionLocales,
-              report.status_card?.presentation_language ?? rawInput.presentationLanguage).operationalValues.relationshipCorrected } };
-        },
-      });
-      const result = freshRoute(rawInput);
-      for (const field of ["input_ms", "target_ms", "control_ms", "render_ms"]) result.timing[field] += initial.timing[field];
-      result.timing.control_ms += correctionMs;
-      result.timing.total_ms = elapsed(started);
-      return result;
-    } catch { return fail(); }
-  };
-}
+// Continuation consumes the same derived current facts as a read-only route.
+// Relationships come from canonical bindings; there is no editable projection
+// for this application layer to repair or synchronize.
+export const createDeliveryContinuationService = dependencies => createSkillDispatchService(dependencies);

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/delivery-path-search/persistence.js

@@ -1,4 +1,9 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from 'node:crypto';
+import { runEvidencePath } from '../control-state/run-identity.js';
+import { readSelectedRun } from '../control-state/run-state-reader.js';
+import { runSealState } from '../control-state/run-seal.js';
+import { hasSymlinkComponent } from '../control-state/contained-file.js';
+import { mkdirSync, writeFileSync, readFileSync, lstatSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { validateSearchResult } from "./contracts.js";
 
@@ -17,14 +22,27 @@ export function persistSearchResult(targetDir, result) {
   if (validated.provenance.valid_evaluations < 1) {
     throw new Error("search result requires at least one valid evaluation before persistence");
   }
-  const root = join(targetDir, ".agdf", "control", "artefacts", validated.scope_key);
-  const jsonPath = join(root, "DELIVERY_PATH_SEARCH.json");
-  const markdownPath = join(root, "DELIVERY_PATH_SEARCH.md");
-  mkdirSync(dirname(jsonPath), { recursive: true });
+  const run = readSelectedRun(targetDir, validated.scope_key);
+  if (!run.valid || runSealState(targetDir, run.content).status !== 'valid') throw Error('AGDF_SEARCH_CURRENT_RUN_REQUIRED');
+  const relative = runEvidencePath(run.run_id, '');
+  if (hasSymlinkComponent(targetDir, relative)) throw Error('AGDF_RUN_PATH_INVALID');
+  const root = join(targetDir, relative);
   const safe = safeResult(validated);
-  writeFileSync(jsonPath, `${JSON.stringify(safe, null, 2)}\n`, "utf8");
+  const jsonText = `${JSON.stringify(safe, null, 2)}\n`;
+  const identity = createHash('sha256').update(jsonText).digest('hex');
+  const jsonPath = join(root, `DELIVERY_PATH_SEARCH-${identity}.json`);
+  const markdownPath = join(root, `DELIVERY_PATH_SEARCH-${identity}.md`);
+  mkdirSync(dirname(jsonPath), { recursive: true });
+  if (hasSymlinkComponent(targetDir, relative)) throw Error('AGDF_RUN_PATH_INVALID');
+  const publish = (path, text) => {
+    try { writeFileSync(path, text, { encoding: 'utf8', flag: 'wx' }); }
+    catch (error) {
+      if (error.code !== 'EEXIST' || !lstatSync(path).isFile() || lstatSync(path).isSymbolicLink() || readFileSync(path, 'utf8') !== text) throw error;
+    }
+  };
+  publish(jsonPath, jsonText);
   const recommendation = safe.recommendation?.action ?? "No safe recommendation";
-  writeFileSync(markdownPath, [
+  publish(markdownPath, [
     "# Delivery Path Search Decision",
     "",
     `- status: ${safe.status}`,
@@ -46,6 +64,6 @@ export function persistSearchResult(targetDir, result) {
     "",
     "This summary contains model judgements, not measured facts. Canonical AGDF gate-check remains authoritative.",
     "",
-  ].join("\n"), "utf8");
+  ].join("\n"));
   return { jsonPath, markdownPath };
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/delivery-path-search/state-adapter.js

@@ -31,7 +31,7 @@ export function searchInputFromControl(targetDir, options = {}, dependencies = {
   const evaluatedRevision = gate.status_presentation?.revision_id ?? "";
   const runId = metaField(content, "run_id");
   const runRevision = metaField(content, "revision_id");
-  const runGate = metaField(content, "current_gate");
+  const runGate = run.current_gate ?? "";
   let inputFailureCode = "";
   if (!content || run.resolution_error) inputFailureCode = "canonical_control_unavailable";
   else if (!evaluatedRunId || !evaluatedRevision) inputFailureCode = "canonical_snapshot_identity_missing";

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/index.js

@@ -1,14 +1,24 @@
 import { resources } from "./resources/context.js";
-import { readRuntimeContract, readSkillRuntimeContracts } from "./resources/contracts.js";
+import { readRuntimeContract, readSkillRuntimeContracts, runtimeContractModules } from "./resources/contracts.js";
 import { createDeliveryContinuationService } from "./delivery-continuation/service.js";
 import { createControlInspectService } from "./control-inspect/service.js";
 import { createRunCommandService } from "./control-state/run-command-service.js";
+import { createRunMaterialStore } from './control-state/run-material.js';
+import { withMaterialRecordingCalls } from './control-inspect/material-recording-calls.js';
+import { evaluateGateCheck } from './control-evaluation/gate-check.js';
+import { evaluateDoctor } from './control-evaluation/doctor.js';
 export { createResourceContext, resources } from "./resources/context.js";
 export function createCoreServices({ resources: context = resources, observers = {}, runtimeBinding } = {}) {
-  const contracts = { readRuntimeContract: module => readRuntimeContract(module, { context }), readSkillRuntimeContracts: skill => readSkillRuntimeContracts(skill, { context }) };
-  return Object.freeze({ ...contracts, resources: context, runtimeBinding,
-    dispatch: createDeliveryContinuationService({ ...observers, ...contracts, pluginDefinition: context.pluginDefinition }),
-    inspect: createControlInspectService({ ...observers, ...contracts }),
-    command: createRunCommandService({ packageVersion: context.pluginDefinition.version, enabledGroups: observers.commandGroups, runtimeControl: observers.runtimeControl }),
+  const contracts = { runtimeContractModules: () => runtimeContractModules(context.pluginDefinition), readRuntimeContract: module => readRuntimeContract(module, { context }), readSkillRuntimeContracts: skill => readSkillRuntimeContracts(skill, { context }) };
+  const store = createRunMaterialStore();
+  const material = Object.freeze({ ...store, stage: input => withMaterialRecordingCalls(input, store.stage(input)) });
+  const reads = observers.gitObservation ? { ...observers,
+    evaluateGateCheck: observers.evaluateGateCheck ?? ((root, selection) => evaluateGateCheck(root, selection, observers.gitObservation)),
+    evaluateDoctor: observers.evaluateDoctor ?? ((root, selection) => evaluateDoctor(root, selection, observers.gitObservation)),
+  } : observers;
+  return Object.freeze({ ...contracts, resources: context, runtimeBinding, material,
+    dispatch: createDeliveryContinuationService({ ...reads, ...contracts, pluginDefinition: context.pluginDefinition }),
+    inspect: createControlInspectService({ ...reads, ...contracts }),
+    command: createRunCommandService({ inputDefaults: context.defaults, packageVersion: context.pluginDefinition.version, enabledGroups: observers.commandGroups, runtimeControl: observers.runtimeControl, materialGrants: observers.materialGrants, gitObservation: observers.gitObservation, initializationProducer: observers.runtimeEvidence?.runtime_digest }),
   });
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/interaction-catalog-validation.js

@@ -1,5 +1,6 @@
 import { INSTALL_SETUP_STATES, INSTALL_ACTIONS, INSTALL_FAILURE_PHASES, INSTALL_FAILURE_CODES,
-  DISPATCH_RECOVERY_CODES, CODEX_HOOK_STATES, DECISION_CARD_LABEL_KEYS, FLOW_EVIDENCE_LABEL_KEYS } from "./interaction-catalog.js";
+  DISPATCH_RECOVERY_CODES, CODEX_HOOK_STATES, DECISION_CARD_LABEL_KEYS, FLOW_EVIDENCE_LABEL_KEYS,
+  COMPANION_MOODS, COMPANION_UNREADABLE_REASONS } from "./interaction-catalog.js";
 
 // Build-time validation, not a second vocabulary. Unknown and missing copy both fail closed.
 export function validateInteractionCatalog(registry) {
@@ -18,6 +19,10 @@ export function validateInteractionCatalog(registry) {
     check(`${language}.skillDispatch.recoveries`, pack.skillDispatch?.recoveries, DISPATCH_RECOVERY_CODES);
     check(`${language}.decisionCard`, pack.decisionCard, DECISION_CARD_LABEL_KEYS);
     check(`${language}.flowEvidence`, pack.flowEvidence, FLOW_EVIDENCE_LABEL_KEYS);
+    check(`${language}.companion.states`, pack.companion?.states, COMPANION_MOODS);
+    check(`${language}.companion.statusStates`, pack.companion?.statusStates, [...COMPANION_MOODS, "unreadable"]);
+    const unreadable = pack.companion?.unreadable;
+    check(`${language}.companion.unreadable`, unreadable && Object.fromEntries(COMPANION_UNREADABLE_REASONS.map(key => [key, unreadable[key]])), COMPANION_UNREADABLE_REASONS);
   }
   for (const row of Object.values(CODEX_HOOK_STATES)) {
     if (!INSTALL_SETUP_STATES[row.state]?.actions.includes(row.action)) throw new Error("AGDF_INTERACTION_CATALOG_HOOK_INVALID");

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/interaction-catalog.js

@@ -9,8 +9,8 @@ function freeze(value) {
 }
 export const INSTALL_SETUP_STATES = freeze({
   cancelled: { result: "cancelled", actions: ["cancelled"] },
-  control_migration_required: { result: "partial", actions: ["migrate_control"] },
-  control_repair_required: { result: "partial", actions: ["repair_control"] },
+  control_unsupported: { result: "partial", actions: ["inspect_control"] },
+  control_repair_required: { result: "partial", actions: ["inspect_control"] },
   plugin_ready_mcp_absent: { result: "success", actions: ["restart_host"] },
   plugin_ready_mcp_in_plugin: { result: "success", actions: ["restart_host"] },
   mcp_ready_hook_review_required: { result: "partial", actions: ["review_codex_hook"] },
@@ -58,7 +58,7 @@ export const INSTALL_ACTIONS = freeze([...new Set(Object.values(INSTALL_SETUP_ST
 export const DISPATCH_RECOVERY_CODES = freeze([
   "target_evaluation_failed", "target_presentation_failed", "control_evaluation_failed",
   "control_presentation_failed", "runtime_contracts_unavailable", "runtime_evidence_invalid",
-  "internal_failure", "output_too_large", "intake_run_collision", "intake_scaffold_required",
+  "internal_failure", "output_too_large", "intake_run_collision", "intake_scaffold_required", "intake_run_id_invalid",
   "run_assignment_inventory_invalid", "prd_authoring_inputs_invalid", "sd_authoring_inputs_invalid", "tp_authoring_inputs_invalid",
   "AGDF_ARTEFACT_TEMPLATE_UNSUPPORTED", "AGDF_ARTEFACT_TEMPLATE_ROOT_UNAVAILABLE",
   "AGDF_ARTEFACT_TEMPLATE_UNAVAILABLE", "AGDF_ARTEFACT_TEMPLATE_UNSAFE",
@@ -96,3 +96,11 @@ export const DECISION_CARD_COPY_BUDGETS = freeze(Object.fromEntries(DECISION_CAR
       'previewUnavailable', 'previewChanged', 'previewIllustrative', 'previewUnsupported'].includes(key)
       ? 'description' : 'label'
 ])));
+
+// Companion figure moods (SD SDD-004) and the per-run reasons it names; the catalog's companion
+// section must carry copy for exactly these keys in every locale.
+export const COMPANION_MOODS = freeze(['laeuft', 'baut', 'wartet', 'blockiert', 'fertig', 'bereit']);
+// The store reasons are every bounded code `boundedCode` can return (CR finding B9).
+export const COMPANION_UNREADABLE_REASONS = freeze(['run_version_unsupported', 'run_state_invalid', 'too_large', 'missing',
+  'control_layout_unsupported', 'control_invalid', 'read_failed', 'resource_denied', 'source_changed', 'timeout', 'resource_limit',
+  'unavailable', 'exit', 'malformed']);

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/interaction-presentation.js

@@ -1,4 +1,5 @@
 import { RUN_ID_PATTERN } from "./control-state/run-identity.js";
+import { normalizedRunTitle, runInventoryHistoryLine } from "./control-state/run-inventory.js";
 import { DISPATCH_RECOVERY_CODES, DECISION_CARD_COPY_BUDGETS } from "./interaction-catalog.js";
 import { TASK_TARGET_SOURCES, TASK_TARGET_UNRESOLVED_REASONS } from "./task-target-resolution.js";
 
@@ -126,7 +127,7 @@ function validateReadLocaleRegistry(registry) {
       const budget = cardBudget ? budgets[cardBudget]
         : key.startsWith("sourceRevision.") || key.startsWith("mcpErrors.") ? budgets.description
         : key.startsWith("gateTitles.") || key.startsWith("gateActionTitles.") ? budgets.title
-        : key.includes("Description") || key.includes("fallbackReasons") || key.startsWith("runResolution.") || key.startsWith("controlSetup.") || key.startsWith("operationalValues.") || key.startsWith("gateRequiredDecisions.") || key.startsWith("taskTargetResolution.nextActions.") || key.startsWith("skillDispatch.recoveries.") || key.startsWith("skillDispatch.sourceInput.") || key.startsWith("primary.actions.") || key.startsWith("primary.afterApproval.") || key.startsWith("primary.narration.") || key.startsWith("gateRationale.") || key.startsWith("interaction.why.") || key.startsWith("mcpLifecycle.actions.") || key.startsWith("mcpLifecycle.permissionEffects.") || key.startsWith("mcpLifecycle.diagnostics.") || key.startsWith("installSetup.actions.") || key.startsWith("installSetup.blockReasons.") || key.startsWith("installSetup.runtimeConsent.") || ["installSetup.invalidChoice", "installSetup.emptyChoice", "installSetup.blockedChoice", "interaction.decisionInstruction", "interaction.decisionPrompt", "interaction.exactTextRequest", "interaction.decisionFollows", "interaction.presentationFailure", "interaction.nonReadyDecision", "primary.quality"].includes(key)
+        : key.includes("Description") || key.includes("fallbackReasons") || key.startsWith("companion.") || key.startsWith("runResolution.") || key.startsWith("controlSetup.") || key.startsWith("operationalValues.") || key.startsWith("gateRequiredDecisions.") || key.startsWith("taskTargetResolution.nextActions.") || key.startsWith("skillDispatch.recoveries.") || key.startsWith("skillDispatch.sourceInput.") || key.startsWith("primary.actions.") || key.startsWith("primary.afterApproval.") || key.startsWith("primary.narration.") || key.startsWith("gateRationale.") || key.startsWith("interaction.why.") || key.startsWith("mcpLifecycle.actions.") || key.startsWith("mcpLifecycle.permissionEffects.") || key.startsWith("mcpLifecycle.diagnostics.") || key.startsWith("installSetup.actions.") || key.startsWith("installSetup.blockReasons.") || key.startsWith("installSetup.runtimeConsent.") || ["installSetup.invalidChoice", "installSetup.emptyChoice", "installSetup.blockedChoice", "interaction.decisionInstruction", "interaction.decisionPrompt", "interaction.exactTextRequest", "interaction.decisionFollows", "interaction.presentationFailure", "interaction.nonReadyDecision", "primary.quality"].includes(key)
           ? budgets.description
           : budgets.label;
       if (Number.isInteger(budget) && value.length > budget) errors.push(`length_budget:${locale}:${key}`);
@@ -233,13 +234,7 @@ function section(content, heading) {
   return content.match(new RegExp(`(?:^|\\n)## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`))?.[1]?.trim() ?? "";
 }
 
-export function normalizedRunTitle(runId) {
-  const words = String(runId ?? "")
-    .replace(/[._-]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-  return words ? words.replace(/\b\p{L}/gu, (letter) => letter.toUpperCase()) : "AGDF run";
-}
+export { normalizedRunTitle };
 
 export function resolveHumanRunTitle({ currentArtefactHeading, urHeading, runContent, runId }) {
   const objective = section(String(runContent ?? ""), "Objective").split(/\r?\n/).map(stripMarkdown).find(Boolean) ?? "";
@@ -266,7 +261,7 @@ export function buildRunCandidates(runs) {
   return [...(runs ?? [])]
     .filter((run) => run?.valid && run?.meta?.lifecycle === "active" && typeof run.run_id === "string")
     .map((run) => {
-      const currentGate = stripMarkdown(run.control_state?.current_gate || run.meta?.current_gate || "unknown") || "unknown";
+      const currentGate = stripMarkdown(run.control_state?.current_gate || "unknown") || "unknown";
       const title = resolveHumanRunTitle({
         currentArtefactHeading: run.current_artefact_heading,
         urHeading: run.ur_heading,
@@ -278,7 +273,7 @@ export function buildRunCandidates(runs) {
         display_title: displaySafeTitle(title, normalizedRunTitle(run.run_id)),
         objective: displaySafeObjective(section(String(run.content ?? ""), "Objective"), normalizedRunTitle(run.run_id)),
         current_gate: currentGate,
-        decision: String(run.meta?.decision || "unknown").replaceAll("`", "").trim() || "unknown",
+        decision: String(run.control_state?.decision || "unknown").replaceAll("`", "").trim() || "unknown",
         next_allowed_action: String(run.control_state?.next_allowed_action ?? "").trim(),
         revision_id: String(run.meta?.revision_id ?? "").trim(),
         last_updated_at: String(run.meta?.updated_at || run.last_updated_at || "").trim(),
@@ -301,7 +296,8 @@ export function reconcileRunScope({ requestText = "", scopeKey = "", runs = [] }
   const requested = normalizeReconciliationText(scopeKey || requestText);
   if (!requested) return Object.freeze({ outcome: "match_uncertain", matches: [], reason: "scope_input_missing" });
   const matches = [...(runs ?? [])]
-    .filter((run) => run?.valid && ["active", "completed"].includes(run?.meta?.lifecycle) && typeof run.run_id === "string")
+    // A superseded or abandoned Run is history like a completed one: it can match, never as active work.
+    .filter((run) => run?.valid && ["active", "completed", "superseded", "abandoned"].includes(run?.meta?.lifecycle) && typeof run.run_id === "string")
     .filter((run) => {
       const keys = [run.scope_key, run.display_title, run.current_artefact_heading, run.ur_heading]
         .map(normalizeReconciliationText)
@@ -312,7 +308,7 @@ export function reconcileRunScope({ requestText = "", scopeKey = "", runs = [] }
       run_id: run.run_id,
       lifecycle: run.meta.lifecycle,
       display_title: displaySafeTitle(run.display_title || run.ur_heading || run.run_id, normalizedRunTitle(run.run_id)),
-      current_gate: run.control_state?.current_gate || run.meta?.current_gate || "unknown",
+      current_gate: run.control_state?.current_gate || "unknown",
     }))
     .sort((left, right) => left.run_id.localeCompare(right.run_id));
   if (matches.length !== 1) return Object.freeze({ outcome: matches.length ? "match_uncertain" : "no_match", matches, reason: matches.length > 1 ? "multiple_exact_matches" : "no_exact_match" });
@@ -441,6 +437,29 @@ export function isOperationalValueRenderable(value, { registry, requestedLocale
   }
 }
 
+// The localized status-card text of one operational value (next step, after-approval action),
+// exactly as the status card renders it; null when the locale cannot render it.
+export function localizeOperationalValue(value, { registry, requestedLocale } = {}) {
+  try {
+    const locale = resolvePresentationLocale(registry, requestedLocale);
+    const fallbackLocale = resolvePresentationLocale(registry, registry.fallbackLocale);
+    return localizedOperationalValue(value, localePack(registry, locale), localePack(registry, fallbackLocale), locale === fallbackLocale);
+  } catch {
+    return null;
+  }
+}
+
+// The localized status-card text of a blocking condition, exactly as the status card renders it.
+export function localizeBlockingCondition(value, { registry, requestedLocale } = {}) {
+  try {
+    const locale = resolvePresentationLocale(registry, requestedLocale);
+    const fallbackLocale = resolvePresentationLocale(registry, registry.fallbackLocale);
+    return localizedBlockingCondition(value, localePack(registry, locale), localePack(registry, fallbackLocale), locale === fallbackLocale);
+  } catch {
+    return null;
+  }
+}
+
 function localizedOperationalList(value, pack, fallbackPack, fallbackLocale) {
   if (!Array.isArray(value) || value.length === 0) return pack.primary.none;
   const localized = value.map((item) => localizedOperationalValue(item, pack, fallbackPack, fallbackLocale));
@@ -455,6 +474,8 @@ function localizedBlockingCondition(value, pack, fallbackPack, fallbackLocale) {
     const reasonKeys = {
       AGDF_UR_REQUIREMENTS_INCOMPLETE: "blockedUrRequirements",
       AGDF_PRD_DECISIONS_OPEN: "blockedPrdDecisionsOpen",
+      AGDF_PRD_READINESS_INCOMPLETE: "blockedPrdReadiness",
+      AGDF_APPROVAL_SUMMARY_INCOMPLETE: "blockedApprovalSummary",
       AGDF_SD_DECISIONS_OPEN: "blockedSdDecisionsOpen",
       AGDF_SD_TRACEABILITY_INCOMPLETE: "blockedSdTraceability",
       AGDF_TP_TRACEABILITY_INCOMPLETE: "blockedTpTraceability",
@@ -1264,6 +1285,27 @@ export function renderActiveRunInventory(report, registry, language) {
   return { markdown: lines.join("\n"), authorizes: false };
 }
 
+// The shared run inventory: active and invalid runs by attention, history as counts. Classes rest
+// on stored state; each line carries its basis so no reader mistakes them for a live evaluation.
+export function renderRunInventory(inventory, registry, language) {
+  const copy = localePack(registry, language).activeRunInventory;
+  if (!copy) throw new Error("active_run_inventory_copy_missing");
+  const safe = (value) => String(value ?? "").replace(/[\r\n`|]/gu, " ").replace(/\*\*/gu, "");
+  // Authored titles are untrusted text: escape every Markdown metacharacter.
+  const text = (value) => safe(value).replace(/[\\[\]()<>*_#!~]/gu, (char) => `\\${char}`);
+  const open =inventory.runs.filter((run) => !run.valid || run.lifecycle === "active");
+  const lines = [inventory.state === "absent" ? copy.absentDescription
+    : inventory.state === "complete" && open.length === 0 ? copy.noneDescription
+      : copy.countDescription.replace("{count}", String(inventory.counts.lifecycle.active))];
+  if (inventory.state === "incomplete") lines.push("", copy.incompleteDescription);
+  if (open.length) lines.push("", ...open.map((run) => `- **${text(run.title)}** · \`${safe(run.run_id)}\` · ${safe(run.current_gate ?? "?")} · ${safe(run.attention.label)} · ${safe(run.basis)}`));
+  if (inventory.state !== "absent") lines.push("", runInventoryHistoryLine(inventory.counts.lifecycle, language));
+  const findings = [...(inventory.findings ?? []).map((finding) => `- \`${safe(finding.code)}\``),
+    ...inventory.runs.flatMap((run) => run.findings.map((finding) => `- \`${safe(finding.code)}\` · \`${safe(run.run_id)}\` · ${safe(finding.next_step)}`))];
+  if (findings.length) lines.push("", copy.findingsDescription, "", ...findings);
+  return { markdown: lines.join("\n"), authorizes: false };
+}
+
 // Lifecycle observations never act as a gate approval or an implementation grant.
 export function renderSourceRevision(result, registry, language, input = {}) {
   const copy = localePack(registry, language).sourceRevision;
@@ -1281,6 +1323,7 @@ export function renderSourceRevision(result, registry, language, input = {}) {
     `${copy.retained}: ${safe(result.impact.retained.join(", ") || copy.none)}`,
     `${copy.superseded}: ${safe(result.impact.superseded.join(", "))}`);
   if (outcome === "preview" && result.sources && result.impact) {
+    if (result.confirmation_selector) lines.push(`--confirmation: ${safe(result.confirmation_selector)}`);
     lines.push(`${copy.intent}: ${safe(result.intended_change)}`, `${copy.binding}: ${safe(result.preview_digest)}`,
       "", copy.sources, ...result.sources.map(source => `- ${safe(source.type)}: ${safe(source.path)} · ${safe(source.digest)}`),
       "", `${copy.artefacts}: ${safe(result.impact.superseded.join(", "))}`,