create-agdf 0.31.0 → 0.32.0

package/generated/plugins/copilot/agdf/runtime/create-agdf/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agdf/local-validator-runtime",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "private": true,
   "type": "module",
   "imports": {

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/companion/events.js

@@ -70,6 +70,8 @@ export function commandGate(command = {}) {
   const payload = command.payload ?? {};
   if (command.kind === 'closeout.record') return 'OR';
   if (command.kind === 'step.record') return payload.internal_step ?? RUN_STEP_SLOTS[payload.step] ?? null;
+  if (command.kind === 'verified_change.record') return 'Verified Change';
+  if (command.kind === 'ur_draft.replace') return 'UR';
   if (command.kind === 'operation.recover') return null;
   return typeof payload.gate === 'string' ? payload.gate : null;
 }
@@ -83,7 +85,8 @@ function successKind(command, result) {
   if (kind === 'approval.record') return 'approval_recorded';
   if (kind === 'closeout.record') return 'run_completed';
   if (kind === 'material.stage' && command.payload?.action === 'seal') return 'material_staged';
-  if (kind === 'step.record' || kind === 'artefact.record') return 'document_recorded';
+  // Every document recording of run-steps.recordRunStep (run-command-service.js).
+  if (['step.record', 'artefact.record', 'verified_change.record', 'ur_draft.replace'].includes(kind)) return 'document_recorded';
   return null;
 }
 

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/companion/figure-state.js

@@ -21,16 +21,18 @@ export function deriveFigureState(entry) {
   if (!entry) return { mood: 'bereit', reason: { key: 'idle' } };
   if (entry.valid === false) return { mood: 'blockiert', reason: { key: 'unreadable', reason: entry.unreadable_reason ?? 'run_state_invalid' } };
   if (entry.evaluation_error) return { mood: 'blockiert', reason: { key: 'unreadable', reason: entry.evaluation_error } };
-  if (entry.lifecycle === 'completed') return { mood: 'fertig', reason: { key: 'done' } };
+  // A completed run whose evaluation is blocked is not done: the block is shown like any other.
+  const blocked = entry.evaluated === true && (entry.status === 'blocked' || Boolean(entry.blocking_reason && entry.blocking_reason !== 'none'));
+  // A completed run without confirmed completion is still shown, but claims nothing: its own reason.
+  if (entry.lifecycle === 'completed' && !blocked) return entry.completion_confirmed === true
+    ? { mood: 'fertig', reason: { key: 'done' } } : { mood: 'bereit', reason: { key: 'completionUnconfirmed' } };
   if (ENDED_LIFECYCLES.includes(entry.lifecycle)) return { mood: 'bereit', reason: { key: 'ended' } };
   if (!entry.evaluated) return { mood: 'bereit', reason: { key: 'idle' } };
   const gate = entry.current_gate;
-  if (entry.status === 'blocked' || (entry.blocking_reason && entry.blocking_reason !== 'none'))
-    return { mood: 'blockiert', reason: { key: 'blocked', gate, decision: entry.blocking_reason } };
+  if (blocked) return { mood: 'blockiert', reason: { key: 'blocked', gate, decision: entry.blocking_reason } };
   const approval = pendingApproval(entry.missing_approval);
   if (approval) return { mood: 'wartet', reason: { key: 'waitingApproval', gate: approval } };
   if (entry.user_action_required === 'yes') return { mood: 'wartet', reason: { key: 'waitingDecision', gate } };
-  if (entry.status === 'pass') return { mood: 'fertig', reason: { key: 'done' } };
   if (STRUCTURED_MODES.includes(entry.mode) && BUILD_GATES.includes(gate)) return { mood: 'baut', reason: { key: 'building', gate } };
   return { mood: 'laeuft', reason: { key: 'working', gate } };
 }

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/companion/journal.js

@@ -160,6 +160,12 @@ export function createCompanionJournal({ dataRoot = process.env[COMPANION_DATA_R
   return Object.freeze({
     enabled,
     path: enabled ? journalPath(dataRoot) : null,
+    // Whether `observe` writes an event for this result, without writing: a facade asks this for a
+    // result its generation produced, and so already journaled.
+    observes(toolName, input, result) {
+      if (!enabled) return false;
+      try { return Boolean(eventKind(toolName, input, result)); } catch { return false; }
+    },
     observe(toolName, input, result) {
       if (!enabled) return false;
       try {

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/companion/run-view.js

@@ -4,8 +4,12 @@
 // 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 { readFileSync, statSync } from '../control-read/fs.js';
 import { captureControlScope } from '../control-read/snapshot.js';
+import { containedRegularFile, hasSymlinkComponent, isSafeControlRelativePath } from '../control-state/contained-file.js';
+import { parseControlState } from '../control-state/run-state-parser.js';
+import { runIdentity } from '../control-state/run-title.js';
+import { localizedDecisionFields } from '../control-evaluation/decision-content-readiness.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';
@@ -15,7 +19,7 @@ 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 { interactionLocales, resolveArtifactPresentationLanguages } from '../resources/context.js';
 import { deriveFigureState } from './figure-state.js';
 
 export const RUN_VIEW_SCHEMA = 'run-view/1';
@@ -43,13 +47,50 @@ export function projectDiagnosis(entries) {
   return { unreadable, counts: { unreadable: unreadable.length, readable: entries.length - unreadable.length, by_reason } };
 }
 
+const NAMING_TEXT_LIMIT = 500;
+const UR_READ_LIMIT = 131072;
+const bounded = value => (typeof value === 'string' && value.length > NAMING_TEXT_LIMIT ? `${value.slice(0, NAMING_TEXT_LIMIT - 1)}…` : value);
+
+// How a run names itself to a person, read inside the run's own snapshot: the stable title of the
+// shared Run title rule (registered UR heading, then the authored Objective; a bare Run ID is no
+// title) and the goal in the display language. Where display and artefact language differ, the goal
+// is the one the UR's localized approval summary states. An unreadable UR leaves both to the Run document.
+export function readRunNaming(root, runId, language = 'en') {
+  let content;
+  try { content = readFileSync(join(root, runRelativePath(runId, '', 'RUN_STATE.md')), 'utf8'); } catch { return null; }
+  let urHeading = '', localizedGoal = null;
+  try {
+    const path = String(parseControlState(content).artefacts.get('UR')?.path ?? '').replace(/^`|`$/gu, '').trim();
+    if (isSafeControlRelativePath(path) && path.startsWith('.agdf/control/') && !hasSymlinkComponent(root, path)) {
+      const file = containedRegularFile(root, path);
+      if (file.status === 'valid' && statSync(file.path).size <= UR_READ_LIMIT) {
+        const text = readFileSync(file.path, 'utf8');
+        urHeading = (text.match(/^#\s+(.+)$/mu)?.[1] ?? '').replace(/^UR:\s*/iu, '').trim();
+        const sourceLanguage = resolveArtifactPresentationLanguages(root, language).artifact_language;
+        localizedGoal = localizedDecisionFields('UR', text, { locale: String(language).split('-')[0], sourceLanguage, path }).fields.goal ?? null;
+      }
+    }
+  } catch (error) { if (error?.code === 'source_changed') throw error; }
+  const identity = runIdentity({ runId, runContent: content, urHeading });
+  return { run_title: identity.title_source === 'run_id' ? null : bounded(identity.title),
+    run_title_source: identity.title_source, goal: bounded(localizedGoal ?? identity.objective) };
+}
+
 // One run entry: inventory facts plus, when evaluated, the status card fields of its report.
-export function projectRunEntry(inventoryEntry, report, { registry = interactionLocales, language = 'en' } = {}) {
+// `naming` is readRunNaming's result for an evaluated run; without it the inventory names the run.
+export function projectRunEntry(inventoryEntry, report, { registry = interactionLocales, language = 'en', naming = null } = {}) {
+  const authored = inventoryEntry.title_source === 'objective' ? inventoryEntry.title ?? null : null;
   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,
+    // The stable human title, the same at every gate; null while only the Run ID could name the run.
+    run_title: naming ? naming.run_title : authored,
+    run_title_source: naming?.run_title_source ?? (authored ? 'objective' : 'run_id'),
+    // The goal in the display language where the UR states one, otherwise the authored objective.
+    goal: naming ? naming.goal : inventoryEntry.objective ?? null,
+    // The authored objective only, from the shared Run title rule; a template objective or a
+    // bare Run ID is no goal (CR finding C2).
+    objective: inventoryEntry.objective ?? null,
     lifecycle: inventoryEntry.lifecycle ?? null,
     valid: inventoryEntry.valid !== false,
     revision: inventoryEntry.revision ?? null,
@@ -66,6 +107,7 @@ export function projectRunEntry(inventoryEntry, report, { registry = interaction
     ...base,
     title: card.humanPresentation?.runTitle ?? base.title,
     evaluated: true,
+    completion_confirmed: base.lifecycle === 'completed' && report.completion?.fulfilled === true,
     status: card.status,
     current_gate: card.current_gate,
     path: card.breadcrumb.map(({ gate, status }) => ({ gate, status })),
@@ -122,9 +164,10 @@ export function readRunDrift(root, runId) {
   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';
+// Active runs are evaluated; terminal and unreadable runs are summarized unless requested by id, so
+// neither a large history nor many unreadable runs cost one evaluation per run. An unreadable run's
+// reason and figure come from the inventory findings.
+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).
@@ -152,12 +195,12 @@ export function readRunView(root, { language = 'en', runIds = [] } = {}) {
     try {
       return captured(readRoot, base => {
         const report = evaluateGateCheck(base, { runId, ignoreRunIdEnv: true, presentationLanguage: language });
-        return { report, drift: report?.status_card ? readRunDrift(base, runId) : null };
+        return { report, drift: report?.status_card ? readRunDrift(base, runId) : null, naming: readRunNaming(base, runId, language) };
       });
-    } catch (error) { return { report: { evaluation_error: boundedCode(error) }, drift: null }; }
+    } catch (error) { return { report: { evaluation_error: boundedCode(error) }, drift: null, naming: null }; }
   };
   const entryOf = (inventoryEntry, evaluated) => {
-    const entry = projectRunEntry(inventoryEntry, evaluated?.report ?? null, { language });
+    const entry = projectRunEntry(inventoryEntry, evaluated?.report ?? null, { language, naming: evaluated?.naming ?? null });
     return entry.evaluated && entry.valid !== false && evaluated.drift ? { ...entry, drift: evaluated.drift } : entry;
   };
   let inventory = null, store;

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/decision-content-placeholder.js

@@ -2,8 +2,11 @@
 // 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?']);
+// A bare generated Run ID (`run-<operation uuid>`) names the Run but states no outcome.
+const generatedRunId = /^run-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
 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);
+  return !text || prompts.has(text) || generatedRunId.test(text)
+    || /^(?:todo|tbd|<[^>]+>|(?:draft|done|ready|blocked|pass|revise|block)(?:\s*\|\s*(?:draft|done|ready|blocked|pass|revise|block))+)$/.test(text);
 }

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/gate-check.js

@@ -159,7 +159,7 @@ export function isReadyUserGateApproval({ status, currentGate, missingApproval }
 
 function buildBreadcrumbPath(modeSliceDecision, currentGate, runState) {
   const gates = BREADCRUMB_PATH_TEMPLATES[modeSliceDecision] ?? ["UR"];
-  return gates.map((gate) => {
+  return gates.map((gate, index) => {
     if (BREADCRUMB_STANDARD_GATES.includes(gate)) {
       if (gateApprovalStatus(runState, gate) === "approved") return { gate, status: "fulfilled" };
       if (gate === currentGate) return { gate, status: "current" };
@@ -170,6 +170,10 @@ function buildBreadcrumbPath(modeSliceDecision, currentGate, runState) {
     if (gate === currentGate) return { gate, status: "current" };
     if ((gate === "Verified Change" || gate === "Compact Delivery") && currentGate === "OR")
       return { gate, status: "fulfilled" };
+    // A path has one current entry: while an earlier gate is still the current one (a stored route
+    // with an unapproved UR), the route entry after it is open, not current by its route.
+    if (gates.slice(0, index).some((earlier) => earlier === currentGate && gateApprovalStatus(runState, earlier) !== "approved"))
+      return { gate, status: "open" };
     if (gate === "Verified Change" && modeSliceDecision === "verified_change")
       return { gate, status: "current" };
     if (gate === "Compact Delivery" && modeSliceDecision === "quick_task")

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/work-situation.js

@@ -0,0 +1,25 @@
+// Presentation of one canonical control assessment. This module never evaluates or authorizes work.
+export function projectWorkSituation({ assessment, gate, blockingReason, missingApproval, closureOutcome, persistedGate, persistedNext, nextAllowedAction } = {}) {
+  if (persistedGate !== undefined && (persistedGate !== gate || !(assessment === 'ended' && closureOutcome) && persistedNext !== nextAllowedAction)) assessment = 'unconfirmed';
+  let kind = 'unconfirmed';
+  if (assessment === 'open') kind = gate === 'CD+Tests' ? 'in_progress' : 'open';
+  else if (assessment === 'blocked') {
+    kind = blockingReason === 'presentation_version_decided' ? 'revision_required'
+      : blockingReason === 'none' && missingApproval === `Approval: ${gate}` ? 'approval_required'
+      : gate === 'UR' && blockingReason === 'AGDF_UR_REQUIREMENTS_INCOMPLETE' ? 'clarification_required' : 'blocked';
+  } else if (assessment === 'completed') kind = 'completed';
+  else if (assessment === 'ended' && closureOutcome) kind = 'ended';
+  const values = {
+    revision_required: ['clarification_required', 'Revision required', 'Überarbeitung nötig'],
+    approval_required: ['decision_required', 'Approval required', 'Freigabe erforderlich'],
+    clarification_required: ['clarification_required', 'Clarification required', 'Klärung erforderlich'],
+    in_progress: ['in_progress', 'In implementation', 'In Umsetzung'],
+    open: ['in_progress', 'Work may continue', 'Weiterarbeit offen'],
+    blocked: ['blocked', 'Blocked', 'Blockiert'],
+    completed: ['none', 'Completed', 'Vorhaben abgeschlossen'],
+    ended: ['none', 'Ended', 'Vorhaben beendet'],
+    unconfirmed: ['unclear', 'Current conditions unconfirmed', 'Aktuelle Voraussetzungen nicht bestätigt'],
+  };
+  const [code, en, de] = values[kind];
+  return { kind, code, en, de };
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-create-command.js

@@ -12,6 +12,7 @@ import { runSealState } from './run-seal.js';
 import { containedRegularFile, hasSymlinkComponent } from './contained-file.js';
 import { COOPERATIVE_ASSURANCE } from './approval-command-contract.js';
 import { withControlMutation } from './control-layout.js';
+import { isDecisionContentPlaceholder } from '../control-evaluation/decision-content-placeholder.js';
 
 import { creationRunId } from './run-identity.js';
 export { creationRunId };
@@ -50,7 +51,11 @@ export function createRunCommand(root, input, { requestDigest, packageVersion, c
           created_at: new Date().toISOString(), producer: { contract: 'run-command/1', package_version: packageVersion },
           assurance: COOPERATIVE_ASSURANCE, effect: { previous_revision_id: null,
             resulting_revision_id: parsed.meta.revision_id, revision: 1, record: { title: input.command.payload.title } } });
-        return appendRunOperation(content.replace('Describe the trustworthy outcome.', () => input.command.payload.title), receipt);
+        // Only a semantic title orients the Objective. A placeholder title such as the bare Run ID
+        // keeps the template prompt, so recording the UR projects its Goal there.
+        const title = input.command.payload.title;
+        const oriented = isDecisionContentPlaceholder(title) ? content : content.replace('Describe the trustworthy outcome.', () => title);
+        return appendRunOperation(oriented, receipt);
       },
       beforePublish: () => checkpoint('creation_before_publish'),
     });

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-inventory-reader.js

@@ -1,16 +1,30 @@
 import { readControlLayout } from './control-layout.js';
-import { prepareRunContentState } from '../control-evaluation/run-state.js';
+import { prepareRunContentState, readArtefactHeading } from '../control-evaluation/run-state.js';
 import { transitionDecisionForRunState } from '../control-evaluation/gate-policy.js';
+import { evaluateGateCheck } from '../control-evaluation/gate-check.js';
+import { projectCockpitAssessment } from '../control-inspect/run-classification.js';
+import { projectWorkSituation } from '../control-inspect/work-situation.js';
+import { runClosure } from './run-operations.js';
 import { existsSync } from "../control-read/fs.js";
 import { join } from "node:path";
 import { discoverRuns } from "./run-state-reader.js";
 import { buildRunInventory } from "./run-inventory.js";
+import { parseControlState } from './run-state-parser.js';
+import { runSealState, listedArtefactPaths } from './run-seal.js';
+import { isSafeControlRelativePath } from './contained-file.js';
+
+const READ_BOUNDARY_CODES = ['source_changed', 'resource_limit', 'resource_denied', 'timeout'];
+const inControlScope = path => isSafeControlRelativePath(path) && path.startsWith('.agdf/control/');
+// The detail reader's boundary: a run registering sources outside .agdf/control cannot be proven here.
+const registersOnlyControlSources = content => listedArtefactPaths(content).every(inControlScope);
 
 // Feeds the pure inventory from the run discovery of the current read view: each run's parsed text
 // and, when the full parser rejected it, its findings. No run state is read a second time. `observe: false`
 // skips the per-run gate observation, which reads registered documents, for a caller that evaluates the
 // runs itself (the companion run view, which reads each run in its own captured snapshot).
-export function readRunInventory(root, { language = "en", observe = true } = {}) {
+// `cockpitAssessment` evaluates active runs only, like the companion run view: terminal runs stay
+// summarized history, so a long history costs no gate evaluation per run and per refresh.
+export function readRunInventory(root, { language = "en", observe = true, includePresentation = false, cockpitAssessment = false } = {}) {
   if (!existsSync(join(root, '.agdf/control'))) return buildRunInventory(null, { language });
   readControlLayout(root);
   if (!existsSync(join(root, '.agdf/control/runs'))) return buildRunInventory([], { language,
@@ -20,12 +34,45 @@ export function readRunInventory(root, { language = "en", observe = true } = {})
   const store = discovered.filter((run) => run.run_id === "<repository>");
   const sources = discovered.filter(run => run.run_id !== '<repository>').map(run => {
     const source = { run_id: run.run_id, ...(typeof run.content === 'string' ? { text: run.content } : {}), findings: run.valid ? [] : run.findings };
+    if (includePresentation && typeof run.content === 'string') {
+      let name = '', seal = 'unconfirmed';
+      try {
+        const ur = parseControlState(run.content).artefacts.get('UR');
+        const path = String(ur?.path ?? '').replace(/^`|`$/g, '').trim();
+        if (inControlScope(path)) name = readArtefactHeading(root, ur).replace(/^UR:\s*/i, '').trim();
+      } catch { /* An unreadable title must not hide the inventory. */ }
+      try {
+        if (registersOnlyControlSources(run.content)) {
+          const result = runSealState(root, run.content).status;
+          seal = result === 'valid' ? 'valid' : result === 'unsealed' ? 'unsealed'
+            : ['invalid', 'content_changed', 'approvals_changed'].includes(result) ? 'invalid' : 'unconfirmed';
+        }
+      } catch { /* Unavailable evidence cannot prove a seal state. */ }
+      source.presentation = { name: name || null, seal };
+    }
     if (run.valid && observe) {
       try {
         const state = prepareRunContentState(root, run.content, run.path), decision = transitionDecisionForRunState(state);
         source.observation = { current_gate: decision.current_gate, decision: decision.status, missing: decision.missing_approval,
           next_action: decision.next_allowed_action, presentation_decision: Boolean(decision.presentation_decision?.decided) };
-      } catch { source.findings = [{ code: 'AGDF_RUN_OBSERVATION_UNAVAILABLE' }]; }
+        if (cockpitAssessment && run.meta?.lifecycle === 'active') {
+          let report = null;
+          if (registersOnlyControlSources(run.content)) { try { report = evaluateGateCheck(root, { runId: run.run_id, ignoreRunIdEnv: true }); } catch (error) {
+            if (READ_BOUNDARY_CODES.includes(error.code)) throw error;
+            // Preserve the Run but do not claim a verified assessment.
+          } }
+          const assessed = report ? projectCockpitAssessment(report, run.meta?.lifecycle) : { state: 'unconfirmed' };
+          source.observation.work_situation = projectWorkSituation({ assessment: assessed.state,
+            gate: report?.current_gate, blockingReason: report?.blocking_reason, missingApproval: report?.missing_approval,
+            persistedGate: report ? state.current_gate : undefined, persistedNext: state.next_allowed_action, nextAllowedAction: report?.next_allowed_action,
+            closureOutcome: runClosure(run.content)?.outcome });
+          if (report) Object.assign(source.observation, { current_gate: report.current_gate, decision: report.status,
+            missing: report.missing_approval, next_action: report.next_allowed_action });
+        }
+      } catch (error) {
+        if (cockpitAssessment && READ_BOUNDARY_CODES.includes(error.code)) throw error;
+        source.findings = [{ code: 'AGDF_RUN_OBSERVATION_UNAVAILABLE' }];
+      }
     }
     return source;
   });

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-inventory.js

@@ -3,7 +3,9 @@
 // Callers pass validity findings from the full parser; this module never validates receipts.
 import { scalarFields, sectionTableRows, projectRunFacts } from "./run-state-document.js";
 import { RUN_ID_PATTERN } from "./run-identity.js";
-import { isDecisionContentPlaceholder } from "../control-evaluation/decision-content-placeholder.js";
+import { normalizedRunTitle, runIdentity } from "./run-title.js";
+
+export { normalizedRunTitle };
 
 export const RUN_INVENTORY_SCHEMA_VERSION = "1";
 export const RUN_INVENTORY_LIFECYCLES = Object.freeze(["active", "completed", "superseded", "abandoned"]);
@@ -42,29 +44,10 @@ const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u;
 const plain = value => String(value ?? "").replace(/`/gu, "").trim();
 const clip = text => (text.length > TITLE_LIMIT ? `${text.slice(0, TITLE_LIMIT - 1)}…` : text);
 
-// The run-ID title every reader shows when no authored title exists.
-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";
-}
-
-// Lines of one level-two section up to the next heading; an empty section stays empty.
-function sectionLines(text, heading) {
-  const lines = text.split("\n"), start = lines.findIndex(line => line.trimEnd() === `## ${heading}`);
-  if (start < 0) return [];
-  const rest = lines.slice(start + 1), end = rest.findIndex(line => /^#{1,2} /u.test(line));
-  return end < 0 ? rest : rest.slice(0, end);
-}
-
-function objectiveTitle(text, runId) {
-  // The first paragraph, so hard-wrapped objectives stay whole.
-  const lines = sectionLines(text, "Objective").map(value => value.trim()), first = lines.findIndex(Boolean);
-  const paragraph = first < 0 ? [] : lines.slice(first), end = paragraph.indexOf("");
-  const line = (end < 0 ? paragraph : paragraph.slice(0, end)).join(" ");
-  const stripped = line.replace(/^(?:[-*>]|#+|\d+\.)\s+/u, "").replace(/\*\*|__|`/gu, "").replace(/\s+/gu, " ").trim();
-  return isDecisionContentPlaceholder(stripped)
-    ? { title: normalizedRunTitle(runId), title_source: "run_id" }
-    : { title: clip(stripped), title_source: "objective" };
+// The inventory reads no UR document, so its title source is the Objective or the Run ID.
+function titleFacts(text, runId) {
+  const { title, title_source, objective } = runIdentity({ runId, runContent: text });
+  return { title: clip(title), title_source, objective: objective === null ? null : clip(objective) };
 }
 
 // Base64url receipt cells decoded for display facts only; undecodable cells are skipped.
@@ -126,17 +109,19 @@ function entryOf(source, language) {
   const gateResult = facts?.artefacts.get(gate === 'Quick Task Execution' ? 'CR' : gate)?.status ?? null;
   const presentationDecision = source.observation?.presentation_decision === true;
   const missing = source.observation?.missing === 'none' ? '' : source.observation?.missing ?? '';
-  const attention = runAttention({ lifecycle, valid, decision, gateResult, presentationDecision, missing });
+  const situation = source.observation?.work_situation;
+  const attention = situation?.code ?? runAttention({ lifecycle, valid, decision, gateResult, presentationDecision, missing });
   const revision = /^[1-9]\d*$/u.test(meta.get("revision") ?? "") ? Number(meta.get("revision")) : null;
   const index = languageIndex(language);
   return {
     run_id: runId,
-    ...(text ? objectiveTitle(text, runId) : { title: normalizedRunTitle(runId), title_source: "run_id" }),
+    ...titleFacts(text, runId),
+    ...(source.presentation ? { presentation: source.presentation } : {}),
     valid,
     lifecycle: valid ? lifecycle : null,
     current_gate: gate,
     decision,
-    attention: { code: attention, label: LABELS[attention][index] },
+    attention: { code: attention, label: situation ? (index === 1 ? situation.de : situation.en) : LABELS[attention][index] },
     basis: revision === null ? TEXT.basisUnknown[index]() : TEXT.basis[index](revision),
     last_activity: text ? lastActivity(decoded) : { at: null, source: "none", precision: null },
     revision,

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-presentation-render.js

@@ -355,6 +355,35 @@ function artifactSummary(gate, markdown, { runId, revisionId, language, sourceLa
   return { markdown: summary, digest: hash(summary) };
 }
 
+// Cockpit presentation reuses the same language and summary owner as authoring checks.
+// The structured rows are derived from that summary; no second content authority is created.
+export function projectCockpitSummary(gate, markdown, languages, context = {}) {
+  if (!['UR', 'PRD', 'SD', 'TP'].includes(gate)) return null;
+  try {
+    const readiness = evaluateApprovalSummaryReadiness(gate, markdown, languages, { path: context.artefactPath });
+    if (!readiness.ready) return null;
+    const summary = artifactSummary(gate, markdown, { ...context, language: languages.presentation_language, sourceLanguage: languages.artifact_language });
+    const priorities = {
+      UR: [/^(?:Ziel|Goal)$/iu, /^(?:Umfang|Scope)$/iu, /^(?:Abnahme|Abnahmesignal|Acceptance)$/iu],
+      PRD: [/^(?:Ziel|Nutzerziel|Goal|User intent)$/iu, /^(?:Umfang|Produktumfang|Scope|Product scope)$/iu, /^(?:AC-[A-Z0-9-]+)$/iu],
+      SD: [/^(?:Lösung|Solution)$/iu, /^(?:Verantwortung|Ownership)$/iu, /^(?:Entscheidungen|Design decisions)$/iu],
+      TP: [/^(?:Aufgaben|Tasks)$/iu, /^(?:Tests)$/iu, /^(?:Risiken|Risks)$/iu],
+    };
+    const rows = summary.markdown.split(/\r?\n/u).flatMap(line => {
+      const match = line.match(/^[-*]\s+([^:\n]{1,80}):\s*(\S.*)$/u);
+      return match && match[2].length <= 1200 ? [{ label: match[1].trim(), text: match[2].trim() }] : [];
+    });
+    const items = priorities[gate].flatMap(pattern => {
+      const matches = rows.filter(row => pattern.test(row.label));
+      return matches.length === 1 ? matches : [];
+    });
+    return { state: 'available', gate, items, markdown: summary.markdown, authorizes: false };
+  } catch (error) {
+    if (String(error.message).startsWith('approval_summary_')) return null;
+    throw error;
+  }
+}
+
 // A compact decision brief is a projection of the already validated, source-
 // authored summary. Missing authored fields stay absent; no agent/UI paraphrase.
 export function decisionBriefFromSummary(summary, language) {

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-title.js

@@ -0,0 +1,43 @@
+// One owner for a Run's human title and orienting Objective. Pure: no `node:` import, so the run
+// inventory, the cockpit, the companion run view and the status card share exactly this rule.
+// Precedence: registered UR heading, then the authored Objective, then the normalized Run ID.
+import { isDecisionContentPlaceholder } from "../control-evaluation/decision-content-placeholder.js";
+
+// The run-ID title every reader shows when no authored title exists.
+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";
+}
+
+// A heading as display text: no leading hashes and no inline Markdown marks.
+export function plainHeading(value) {
+  return String(value ?? "").replace(/^#+\s*/u, "").replace(/[`*_]/gu, "").replace(/\s+/gu, " ").trim();
+}
+
+// Lines of one level-two section up to the next heading; an empty section stays empty.
+function sectionLines(text, heading) {
+  const lines = text.split("\n"), start = lines.findIndex(line => line.trimEnd() === `## ${heading}`);
+  if (start < 0) return [];
+  const rest = lines.slice(start + 1), end = rest.findIndex(line => /^#{1,2} /u.test(line));
+  return end < 0 ? rest : rest.slice(0, end);
+}
+
+// The first paragraph of the Objective, so hard-wrapped objectives stay whole. A template prompt,
+// a status word or a bare generated Run ID is no orientation and yields null.
+export function authoredObjective(runContent) {
+  const text = String(runContent ?? "").replace(/^/u, "").replace(/\r\n?/gu, "\n");
+  const lines = sectionLines(text, "Objective").map(value => value.trim()), first = lines.findIndex(Boolean);
+  if (first < 0) return null;
+  const paragraph = lines.slice(first), end = paragraph.indexOf("");
+  const value = (end < 0 ? paragraph : paragraph.slice(0, end)).join(" ")
+    .replace(/^(?:[-*>]|#+|\d+\.)\s+/u, "").replace(/\*\*|__|`/gu, "").replace(/\s+/gu, " ").trim();
+  return isDecisionContentPlaceholder(value) ? null : value;
+}
+
+// `urHeading` is the registered UR document heading without its "UR:" prefix, when the caller read it.
+export function runIdentity({ runId, runContent, urHeading } = {}) {
+  const objective = authoredObjective(runContent), ur = plainHeading(urHeading);
+  if (ur) return { title: ur, title_source: "ur", objective };
+  if (objective) return { title: objective, title_source: "objective", objective };
+  return { title: normalizedRunTitle(runId), title_source: "run_id", objective: null };
+}

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

@@ -20,7 +20,8 @@ export function validateInteractionCatalog(registry) {
     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"]);
+    // Beside the moods the status line names a run view that cannot be read and a project without AGDF.
+    check(`${language}.companion.statusStates`, pack.companion?.statusStates, [...COMPANION_MOODS, "unreadable", "notSetUp"]);
     const unreadable = pack.companion?.unreadable;
     check(`${language}.companion.unreadable`, unreadable && Object.fromEntries(COMPANION_UNREADABLE_REASONS.map(key => [key, unreadable[key]])), COMPANION_UNREADABLE_REASONS);
   }

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

@@ -1,5 +1,6 @@
 import { RUN_ID_PATTERN } from "./control-state/run-identity.js";
-import { normalizedRunTitle, runInventoryHistoryLine } from "./control-state/run-inventory.js";
+import { runInventoryHistoryLine } from "./control-state/run-inventory.js";
+import { authoredObjective, normalizedRunTitle, plainHeading, runIdentity } from "./control-state/run-title.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";
 
@@ -229,16 +230,11 @@ function stripMarkdown(value) {
     .trim();
 }
 
-function section(content, heading) {
-  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return content.match(new RegExp(`(?:^|\\n)## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`))?.[1]?.trim() ?? "";
-}
-
 export { normalizedRunTitle };
 
+// The current artefact heading names the card's document; otherwise the shared Run title rule applies.
 export function resolveHumanRunTitle({ currentArtefactHeading, urHeading, runContent, runId }) {
-  const objective = section(String(runContent ?? ""), "Objective").split(/\r?\n/).map(stripMarkdown).find(Boolean) ?? "";
-  return [currentArtefactHeading, urHeading, objective].map(stripMarkdown).find(Boolean) || normalizedRunTitle(runId);
+  return plainHeading(currentArtefactHeading) || runIdentity({ runId, runContent, urHeading }).title;
 }
 
 function displaySafeTitle(value, fallback) {
@@ -271,7 +267,7 @@ export function buildRunCandidates(runs) {
       return {
         run_id: run.run_id,
         display_title: displaySafeTitle(title, normalizedRunTitle(run.run_id)),
-        objective: displaySafeObjective(section(String(run.content ?? ""), "Objective"), normalizedRunTitle(run.run_id)),
+        objective: displaySafeObjective(authoredObjective(run.content), normalizedRunTitle(run.run_id)),
         current_gate: currentGate,
         decision: String(run.control_state?.decision || "unknown").replaceAll("`", "").trim() || "unknown",
         next_allowed_action: String(run.control_state?.next_allowed_action ?? "").trim(),

package/generated/plugins/copilot/agdf/runtime/runtime-manifest.json

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "b38eba8c15f4c412c909e2667187cd47a7c9fcd41fc09d8289d557a4df5e23a2"
+  "digest": "6adaa20191c11cc43e70669bb4be3b24eca02dfeedfa88be30bfb92abd5b6de3"
 }