create-agdf 0.31.0 → 0.32.0

package/generated/plugins/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/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/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/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/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/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/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/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/cockpit-list.js

@@ -8,14 +8,16 @@ export function hasConsistentWorkCounts(inventory) {
     && inventory.entries.every(row => row && COCKPIT_WORK_SECTIONS.includes(row.section));
 }
 export function projectCockpitList(inventory, { section = 'active', query = '' } = {}) {
-  if (!COCKPIT_WORK_SECTIONS.includes(section)) throw Error('dto_invalid');
+  if (section !== 'runs' && !COCKPIT_WORK_SECTIONS.includes(section)) throw Error('dto_invalid');
   const normalized = query.trim().toLowerCase();
   if (!inventory) return { section, query: normalized, coverage: 'unavailable', diagnostics: [], sectionCount: null, matchCount: 0, rows: [] };
   if (!hasConsistentWorkCounts(inventory)) throw Error('dto_invalid');
-  const diagnostics = inventory.diagnostics.filter(row => !row.section || row.section === section);
-  if (diagnostics.some(row => row.code === 'work_section_unavailable')) return { section, query: normalized, coverage: 'unavailable', diagnostics, sectionCount: null, matchCount: null, rows: [] };
-  const selected = inventory.entries.map((entry, index) => ({ entry, index })).filter(row => row.entry.section === section);
-  const rows = selected.filter(({ entry }) => !normalized || [entry.title, entry.key, entry.stored_status]
+  const sections = section === 'runs' ? ['active', 'completed'] : [section];
+  const diagnostics = inventory.diagnostics.filter(row => !row.section || sections.includes(row.section));
+  const unavailable = sections.filter(s => diagnostics.some(row => row.code === 'work_section_unavailable' && (!row.section || row.section === s)));
+  if (unavailable.length === sections.length) return { section, query: normalized, coverage: 'unavailable', diagnostics, sectionCount: null, matchCount: null, rows: [] };
+  const selected = inventory.entries.map((entry, index) => ({ entry, index })).filter(row => sections.includes(row.entry.section) && !unavailable.includes(row.entry.section));
+  const rows = selected.filter(({ entry }) => !normalized || [entry.title, entry.key, entry.stored_status, entry.objective ?? '']
     .some(value => value.toLowerCase().includes(normalized))).map(({ entry, index }) => ({ entry, index,
       identity: JSON.stringify([entry.identity, entry.source.digest]), selectable: entry.selectable, displayTitle: entry.title.replace(/^\[(framework[-_]maintenance|external[-_]delivery)\]\s*/i, '') || entry.title,
       provenance: { path: entry.source.path, digest: entry.source.digest, originalTitle: entry.title } }));
@@ -25,10 +27,10 @@ export function projectCockpitList(inventory, { section = 'active', query = '' }
 
 // Presentation-only grouping/search over the shared inventory's already ordered entries.
 export function projectCockpitRuns(inventory, { section = 'active', query = '' } = {}) {
-  if (!['active', 'completed'].includes(section)) throw Error('dto_invalid');
+  if (!['active', 'completed', 'runs'].includes(section)) throw Error('dto_invalid');
   const normalized = query.trim().toLowerCase();
-  const entries = inventory.runs.filter(run => section === 'active'
-    ? !run.valid || run.lifecycle === 'active' : run.valid && run.lifecycle !== 'active');
+  const entries = inventory.runs.filter(run => section === 'runs' || (section === 'active'
+    ? !run.valid || run.lifecycle === 'active' : run.valid && run.lifecycle !== 'active'));
   const rows = entries.filter(run => !normalized || [run.title, run.run_id, run.attention.label]
     .some(value => value.toLowerCase().includes(normalized)));
   return { rows, sectionCount: entries.length, matchCount: rows.length,

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/cockpit-session.js

@@ -11,11 +11,11 @@ import { COCKPIT_LIMITS, parseCockpitArguments, parsePluginCockpitArguments } fr
 // One connection owns bounded independent read views. Retiring workers still occupy slots.
 export function createCockpitSessionService(root, {
   budget, poolFactory = viewRoot => new ReadWorkerPool(viewRoot, { limits: { total: COCKPIT_LIMITS.capture },
-    maxOldGenerationSizeMb: COCKPIT_LIMITS.workerOldGeneration, budget }), now = Date.now, pluginMode = false,
+    maxOldGenerationSizeMb: COCKPIT_LIMITS.workerOldGeneration, budget }), now = Date.now, pluginMode = false, integrationSurface,
 } = {}) {
   const target = pluginMode ? null : { target_id: resolveControlCommandTarget(root).target_id, display_path: root };
   const sessions = new Map();
-  let closed = false, renderGeneration = 0, publication = null;
+  let closed = false, renderGeneration = 0, publication = null, resourceIdentity = null;
   const failure = (code, viewTarget = target) => ({ schema_version: '2', target: viewTarget, snapshot_id: null, observed_as_of: null,
     source_digest: null, state: 'blocked', code, retryable: code !== 'session_expired', data: null, authorizes: false });
   function losePublication(session) {
@@ -59,6 +59,12 @@ export function createCockpitSessionService(root, {
   function touch(session) { session.touched = now(); schedule(session); }
   return Object.freeze({
     failure,
+    bindResourceIdentity({ digest, version } = {}) {
+      if (resourceIdentity || sessions.size || !/^[a-f0-9]{64}$/u.test(digest ?? '')
+        || typeof version !== 'string' || !/^[0-9A-Za-z.+-]{1,80}$/u.test(version)) throw Error('resource_identity_invalid');
+      resourceIdentity = Object.freeze({ schema_version: '1', version, resource_digest: `sha256:${digest}`,
+        resource_scope: 'server_validated', host_display: 'unconfirmed', candidate_match: 'unverified' });
+    },
     inspectOwnership() {
       return { views: sessions.size, active: [...sessions.values()].filter(row => !row.retired).length,
         uncertain: publication?.phase === 'uncertain' ? 1 : 0 };
@@ -99,6 +105,8 @@ export function createCockpitSessionService(root, {
       sessions.set(session.id, session); schedule(session);
       return { schema_version: '1', authorizes: false, target: viewTarget,
         _meta: { agdf_cockpit: { session_id: session.id, target: viewTarget, render_generation: ++renderGeneration,
+          ...(['codex', 'claude'].includes(integrationSurface) ? { integration_surface: integrationSurface } : {}),
+          ...(resourceIdentity ? { provenance: resourceIdentity } : {}),
           ...(input.run_id ? { initial_run_id: input.run_id } : {}),
           idle_timeout_ms: COCKPIT_LIMITS.idle, lifetime_ms: COCKPIT_LIMITS.lifetime } } };
     },
@@ -154,7 +162,7 @@ export function createCockpitSessionService(root, {
           touch(session); return result;
         }
         if (['planned', 'archive'].includes(input.operation) && !session.rows.has(input.row_id)) return fail('resource_denied');
-        if (['document', 'prepare_context'].includes(input.operation)
+        if (['document', 'preview', 'prepare_context'].includes(input.operation)
           && session.documents.get(input.resource_id) !== `${input.snapshot_id}:${input.run_id}`) return fail('resource_denied');
         if (['context', 'artifact_readiness'].includes(input.operation) && input.run_id !== session.run_id) return fail('resource_denied');
         if (input.operation === 'artifact_readiness' && (!session.draft?.available || session.draft.gate !== input.gate

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

@@ -7,13 +7,15 @@ import { COCKPIT_WORK_SECTIONS as sections } from './cockpit-list.js';
 // discriminator changes policy: order and per-row source identity come from Core,
 // never a Markdown table, stored rank, or adapter-specific lifecycle database.
 export function projectCockpitWork(root) {
-  const inventory = readWorkInventory(root, { language: 'de' });
+  const inventory = readWorkInventory(root, { language: 'de', includePresentation: true, cockpitAssessment: true });
   if (inventory.state === 'unavailable') return { state: 'error', code: 'work_inventory_unavailable', data: null };
   const entries = inventory.entries.map(row => {
     const planned = row.kind === 'planned';
     const section = planned ? sections[1] : row.lifecycle === 'active' || row.lifecycle === null ? sections[0] : sections[2];
     const key = planned ? row.plan_id : row.run_id;
-    return { kind: row.kind, identity: row.identity, section, key, original_key: key, title: row.title,
+    return { kind: row.kind, identity: row.identity, section, key, original_key: key, title: planned ? row.title : row.presentation?.name || key,
+      ...(!planned ? { title_source: row.presentation?.name ? 'ur' : 'run_id', objective: row.objective ?? null,
+        last_activity: row.last_activity, seal: row.presentation?.seal ?? 'unconfirmed', lifecycle: row.lifecycle, attention_code: row.attention.code } : {}),
       stored_status: planned ? ({ ready: 'Bereit zur Übergabe', draft: 'UR in Klärung', recovery_required: 'Wiederherstellung erforderlich', unconfirmed: 'Zuordnung ungeklärt', unavailable: 'Quelle nicht verfügbar' })[row.coverage]
         : row.attention.label, scope: planned ? 'UR-Planung' : 'Run', priority: row.priority ?? null,
       stored_next_step: planned ? row.actions.join(' · ') : row.next_action ?? '', source_links: row.source.path,

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/cockpit.js

@@ -1,5 +1,5 @@
 import { readCockpitArchive, readArchiveDocument } from './cockpit-archive.js';
-import { runDocumentPath } from '../control-state/run-identity.js';
+import { runDocumentPath, runEvidencePath } from '../control-state/run-identity.js';
 import { existsSync } from '../control-read/fs.js';
 import { RUN_ID_PATTERN } from '../control-state/run-identity.js';
 import { join, posix, sep } from 'node:path';
@@ -11,8 +11,10 @@ import { readRunState, readArtefactHeading } from '../control-evaluation/run-sta
 import { evaluateGateCheck } from '../control-evaluation/gate-check.js';
 import { isSafeControlRelativePath } from '../control-state/contained-file.js';
 import { resolveControlCommandTarget } from '../control-state/approval-command-contract.js';
-import { localePack, resolveHumanRunTitle } from '../interaction-presentation.js';
-import { interactionLocales } from '../resources/context.js';
+import { localePack } from '../interaction-presentation.js';
+import { runIdentity } from '../control-state/run-title.js';
+import { interactionLocales, resolveArtifactPresentationLanguages } from '../resources/context.js';
+import { projectCockpitSummary } from '../control-state/run-presentation-render.js';
 import { projectCockpitContext, composeCockpitPacket } from './cockpit-context.js';
 import { projectCockpitWork } from './cockpit-work.js';
 import { readControlLayout } from '../control-state/control-layout.js';
@@ -23,6 +25,7 @@ import { ARTIFACT_READINESS_GATES, projectArtifactReadiness, describeArtifactRea
 import { artefactFileDigest } from '../control-state/run-seal-compute.js';
 import { inspectApprovedArtefact } from '../control-state/artefact-binding-proof.js';
 import { runClosure } from '../control-state/run-operations.js';
+import { projectRunEntry } from '../companion/run-view.js';
 // Shared with the companion run view, in a module every runtime profile carries.
 import { boundedCode, projectCockpitAssessment } from './run-classification.js';
 export { boundedCode, projectCockpitAssessment };
@@ -34,7 +37,7 @@ const DOCUMENT_GATES = new Set(['UR', 'PRD', 'SD', 'TP', 'QA', 'UAT']);
 const DESCRIPTION_LIMIT = 256 * 1024;
 const rawDigest = bytes => createHash('sha256').update(bytes).digest('hex');
 const assertDescriptionBound = value => { if (Buffer.byteLength(JSON.stringify(value)) > DESCRIPTION_LIMIT) fail('resource_limit'); };
-const objective = content => content?.match(/(?:^|\n)## Objective\s*\n([\s\S]*?)(?=\n## |$)/)?.[1]?.trim() ?? null;
+const storedObjective = content => content?.match(/(?:^|\n)## Objective\s*\n([\s\S]*?)(?=\n## |$)/)?.[1]?.trim() ?? null;
 // History of an ended Run, read only from its sealed closure receipt; null for every other Run.
 export function projectRunClosure(content) {
   const closure = runClosure(content);
@@ -80,9 +83,16 @@ export function createCockpitReader(root, options = {}) {
   function manifest(runId, state) {
     const result = [];
     const paths = new Set();
-    // The canonical state itself and each explicit Artefacts row are registrations.
-    // The canonical state path is platform-native; registrations use POSIX separators.
+    // Keep Run State and artefact registrations ahead of standalone evidence reports.
     const rows = [{ type: 'Run State', path: state.path?.split(sep).join(posix.sep) }, ...[...state.artefacts].map(([type, row]) => ({ type, ...row }))];
+    const evidenceRoot = runEvidencePath(runId, '') + '/';
+    for (const row of state.evidence_applicability.current) {
+      const path = row.report?.path;
+      if (row.available !== true || !path?.startsWith(evidenceRoot) || !isSafeControlRelativePath(path)
+        || !SUPPORTED.has(path.split('.').at(-1)?.toLowerCase())) continue;
+      const { bytes } = view.readOptionalFileSync(join(root, path), READ_LIMITS.preview);
+      if (bytes && !bytes.includes(0)) rows.push({ type: 'Evidence', path });
+    }
     for (const row of rows) {
       const path = String(row.path ?? '').replace(/^`|`$/g, '').trim();
       if (!path || path === 'none' || paths.has(path)) continue;
@@ -117,17 +127,23 @@ export function createCockpitReader(root, options = {}) {
     const resources = manifest(run.run_id, state);
     const outside = resources.filter(r => r.status === 'blocked' && isSafeControlRelativePath(r.registered_reference)).map(r => r.registered_reference);
     const report = outside.length ? null : evaluateGateCheck(root, { runId: run.run_id, ignoreRunIdEnv: true });
+    const assessed = report ? evaluation(state, report, run.meta.lifecycle) : outOfScopeEvaluation(state, outside);
+    const figure = report?.status_card && assessed.control_assessment.state !== 'unconfirmed'
+      ? projectRunEntry({ run_id: run.run_id, lifecycle: run.meta.lifecycle }, report).figure
+      : undefined;
     const work_summary = outside.length ? null : runWorkSummary(root, run.content, state.path);
     const draft_check = draftDescriptor(run, state, report);
     const document_states = documentStates(run, state, report, resources, draft_check);
+    const urTitle = readArtefactHeading(root, state.artefacts.get('UR')).replace(/^UR:\s*/i, '').trim();
+    const identity = runIdentity({ runId: run.run_id, runContent: run.content, urHeading: urTitle });
     return { run_id: run.run_id, revision_id: run.meta.revision_id, lifecycle: run.meta.lifecycle,
       closure: projectRunClosure(run.content), work_summary,
+      ...(figure && { figure }),
       // The cockpit identifies the undertaking; the gate card can still name its current artefact.
-      objective: objective(run.content), title: resolveHumanRunTitle({
-        urHeading: readArtefactHeading(root, state.artefacts.get('UR')).replace(/^UR:\s*/i, ''),
-        runContent: run.content, runId: run.run_id,
-      }),
-      evaluation: report ? evaluation(state, report, run.meta.lifecycle) : outOfScopeEvaluation(state, outside), persisted: { current_gate: state.current_gate, next_allowed_action: state.next_allowed_action,
+      // The detail shows the stored Objective as written, placeholders included (owner decision);
+      // the title follows the shared Run title rule.
+      objective: storedObjective(run.content), title_source: identity.title_source, title: identity.title,
+      evaluation: assessed, persisted: { current_gate: state.current_gate, next_allowed_action: state.next_allowed_action,
         decision: report?.status ?? 'unavailable', artefacts: [...state.artefacts].map(([type, value]) => ({ type, ...value })) },
       context_graph: { refs: state.context_graph.refs }, resources,
       draft_check, document_states, evidence_applicability: Object.fromEntries(['current', 'superseded', 'applicability_unknown'].map(group => [group,
@@ -202,7 +218,8 @@ export function createCockpitReader(root, options = {}) {
       view.revalidate();
     } catch (error) { checkedDraft = null; invalidate(); inspected = null; graph = null; throw error; }
   }
-  function readDocument(resourceId) {
+  // Only the gate preview shows the authored summary; full document reads stay content-only.
+  function readDocument(resourceId, { withSummary = false } = {}) {
       const resource = documents.get(resourceId);
       if (!resource) fail('resource_denied');
       if (resource.status === 'blocked') return envelope({ resource }, 'blocked', 'resource_denied');
@@ -227,7 +244,12 @@ export function createCockpitReader(root, options = {}) {
         if (registered) links[href] = registered.resource_id;
       }
       const document_state = details.get(resource.run_id)?.data?.document_states?.find(row => row.resource_id === resourceId);
-      return envelope({ resource, format, content, content_digest: rawDigest(bytes), links, ...(document_state ? { document_state } : {}) });
+      const summary = withSummary && format === 'markdown' && document_state && ['UR', 'PRD', 'SD', 'TP'].includes(resource.type)
+        ? projectCockpitSummary(resource.type, content, resolveArtifactPresentationLanguages(root, 'de'), { runId: resource.run_id,
+          revisionId: document_state.revision_id, artefactPath: resource.path }) : null;
+      const cockpit_summary = summary && { ...summary, run_id: resource.run_id, resource_id: resource.resource_id,
+        revision_id: document_state.revision_id, content_digest: rawDigest(bytes) };
+      return envelope({ resource, format, content, content_digest: rawDigest(bytes), links, ...(document_state ? { document_state } : {}), ...(cockpit_summary ? { cockpit_summary } : {}) });
   }
   function discardScope(retainCheck = false) {
     if (!retainCheck) checkedDraft = null;
@@ -355,6 +377,14 @@ export function createCockpitReader(root, options = {}) {
         return selected;
       });
     },
+    preview(resourceId, id, runId) {
+      const resource = documents.get(resourceId);
+      if (!resource || resource.run_id !== runId) fail('resource_denied');
+      assertSnapshot(id);
+      const result = readDocument(resourceId, { withSummary: true });
+      assertSnapshot(id);
+      return result;
+    },
     document(resourceId, id, runId) {
       // Check selectors before revalidation or replacing the legitimate view.
       const previous = documents.get(resourceId);

package/generated/plugins/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/agdf/runtime/create-agdf/runtime/core/lib/control-read/cockpit-worker.js

@@ -18,6 +18,7 @@ parentPort.on('message', ({ id, operation, selector, snapshot, input }) => {
       : operation === 'planned' ? reader.planned(selector, snapshot)
       : operation === 'artifact_readiness' ? reader.artifactReadiness(input.run_id, snapshot, input.gate, input.expected_revision_id)
       : operation === 'document' ? reader.document(selector, snapshot, input?.run_id)
+      : operation === 'preview' ? reader.preview(selector, snapshot, input?.run_id)
       : operation === 'freshness' ? reader.freshness(snapshot)
       : operation === 'context' ? reader.context(selector, snapshot)
       : operation === 'prepare_context' ? reader.prepareContext(input)

package/generated/plugins/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/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;
   });