create-agdf 0.20.2 → 0.30.0

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

@@ -1,24 +1,30 @@
+import { RUN_ID_PATTERN } from '../control-state/run-identity.js';
 // One wire-schema owner for the bounded cockpit connection. No filesystem selectors.
 import { COCKPIT_UI_URI } from '../mcp-resource-contract.js';
+import { READ_SESSION_CAPACITY } from '../control-read/cockpit-pool.js';
 export { COCKPIT_UI_URI, DECISION_UI_URI } from '../mcp-resource-contract.js';
 export const COCKPIT_MIME = 'text/html;profile=mcp-app';
 export const COCKPIT_LIMITS = Object.freeze({ html: 4 * 1024 ** 2, idle: 30 * 60_000, lifetime: 8 * 60 * 60_000,
-  sessions: 4, capture: 64 * 1024 ** 2, workerOldGeneration: 256 });
+  sessions: READ_SESSION_CAPACITY, capture: 64 * 1024 ** 2, workerOldGeneration: 256 });
 const id = { type: 'string', format: 'uuid' };
-const run = { type: 'string', pattern: '^[A-Za-z0-9_-]{1,128}$' };
+const run = { type: 'string', pattern: RUN_ID_PATTERN.source };
 function operation(name, fields = {}, optional = []) {
   const properties = { operation: { const: name }, session_id: id, ...fields };
   return { type: 'object', additionalProperties: false, properties, required: Object.keys(properties).filter(key => !optional.includes(key)) };
 }
 export const COCKPIT_READ_SCHEMA = Object.freeze({ oneOf: [
-  operation('snapshot', { run_id: run }, ['run_id']),
-  operation('backlog_titles', { snapshot_id: id, row_ids: { type: 'array', minItems: 1, maxItems: 12, uniqueItems: true, items: id } }),
+  operation('snapshot', { run_id: run, view: { type: 'string', enum: ['runs'] } }, ['run_id', 'view']),
+  operation('archive', { snapshot_id: id, row_id: id, resource_id: id }, ['resource_id']),
+  operation('planned', { snapshot_id: id, row_id: id }),
   operation('run', { snapshot_id: id, run_id: run }),
   operation('artifact_readiness', { snapshot_id: id, run_id: run, gate: { type: 'string', enum: ['UR', 'PRD', 'SD', 'TP'] }, expected_revision_id: id }),
   operation('document', { snapshot_id: id, run_id: run, resource_id: id }),
   operation('preview', { snapshot_id: id, run_id: run, resource_id: id }),
   operation('freshness', { snapshot_id: id }),
   operation('changes', { snapshot_id: id }),
+  operation('decision_display', { owner_epoch: id, nonce: id, surface_id: id,
+    document_digest: { type: 'string', pattern: '^sha256:[a-f0-9]{64}$' }, visible: { const: true } }),
+  operation('decision_state'),
   operation('context', { snapshot_id: id, run_id: run }),
   operation('prepare_context', { snapshot_id: id, run_id: run, revision_id: id, resource_id: id,
     graph_ids: { type: 'array', maxItems: 16, uniqueItems: true, items: id },
@@ -69,6 +75,7 @@ export function parseCockpitArguments(value, render = false) {
     if (typeof value.run_id !== 'string' || !new RegExp(run.pattern).test(value.run_id)) return reject();
     return { run_id: value.run_id };
   }
+  if (value.operation === 'snapshot' && Object.hasOwn(value, 'run_id') && Object.hasOwn(value, 'view')) return reject();
   const branch = COCKPIT_READ_SCHEMA.oneOf.find(row => row.properties.operation.const === value.operation);
   if (!branch || Object.keys(value).some(key => !Object.hasOwn(branch.properties, key)) || branch.required.some(key => !Object.hasOwn(value, key))) return reject();
   const valid = (item, rule) => {

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/cockpit-list.d.ts

@@ -1,17 +1,21 @@
-export const COCKPIT_BACKLOG_SECTIONS: readonly ['Active Backlog', 'Planned / Parking Lot', 'Completed / Superseded Pointers'];
-export interface ListEntry { section: string; key: string; title: string; stored_status: string; selectable: boolean }
+export const COCKPIT_WORK_SECTIONS: readonly ['active', 'planned', 'completed', 'archive'];
+export interface ListEntry { section: string; key: string; title: string; stored_status: string; selectable: boolean; identity: string; source: { path: string; digest: string | null } }
 export interface ListDiagnostic { code: string; section?: string; key?: string | null }
 export interface ListInventory<T extends ListEntry = ListEntry, D extends ListDiagnostic = ListDiagnostic> {
-  entries: T[]; diagnostics: D[]; counts: Record<string, number>; content_digest: string; source_path: string;
+  entries: T[]; diagnostics: D[]; counts: Record<string, number>; content_digest: string; source_path: string; layout?: string;
 }
 export interface CockpitListRow<T extends ListEntry = ListEntry> {
   entry: T; index: number; identity: string; selectable: boolean; displayTitle: string;
-  provenance: { path: string; digest: string; originalTitle: string };
+  provenance: { path: string; digest: string | null; originalTitle: string };
 }
 export interface CockpitList<T extends ListEntry = ListEntry, D extends ListDiagnostic = ListDiagnostic> {
   section: string; query: string; coverage: 'complete' | 'partial' | 'unavailable'; diagnostics: D[];
   sectionCount: number | null; matchCount: number | null; rows: CockpitListRow<T>[];
 }
-export function hasConsistentBacklogCounts(inventory: unknown): boolean;
-export function backlogRowKey(entry: ListEntry, index: number, digest: string): string;
+export function hasConsistentWorkCounts(inventory: unknown): boolean;
 export function projectCockpitList<T extends ListEntry, D extends ListDiagnostic>(inventory: ListInventory<T, D> | null, options?: { section?: string; query?: string }): CockpitList<T, D>;
+
+export interface RunListEntry { valid: boolean; lifecycle: string | null; run_id: string; title: string; attention: { label: string } }
+export function projectCockpitRuns<T extends RunListEntry>(inventory: { runs: T[]; state: string }, options?: { section?: string; query?: string }): {
+  rows: T[]; sectionCount: number; matchCount: number; coverage: 'complete' | 'partial' | 'unavailable';
+};

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

@@ -1,45 +1,36 @@
-// Pure internal Core policy shared by Node readers and browser list presentations.
-// Raw entries and opaque selectors remain in source order and are never modified here.
-export const COCKPIT_BACKLOG_SECTIONS = Object.freeze([
-  'Active Backlog', 'Planned / Parking Lot', 'Completed / Superseded Pointers',
-]);
-const unreadableLayout = /^(backlog_(section_missing|layout_missing|layout_unsupported)|AGDF_BACKLOG_LAYOUT_UNKNOWN)$/;
-
-export function hasConsistentBacklogCounts(inventory) {
-  if (!inventory || !Array.isArray(inventory.entries) || !inventory.counts || typeof inventory.counts !== 'object') return false;
-  const actual = new Map();
-  for (const row of inventory.entries) {
-    if (!row || !COCKPIT_BACKLOG_SECTIONS.includes(row.section)) return false;
-    actual.set(row.section, (actual.get(row.section) ?? 0) + 1);
-  }
-  return Object.entries(inventory.counts).every(([section, count]) => COCKPIT_BACKLOG_SECTIONS.includes(section)
-    && Number.isSafeInteger(count) && count >= 0 && count === (actual.get(section) ?? 0))
-    && [...actual.keys()].every(section => Object.hasOwn(inventory.counts, section));
+// Pure current-model list policy shared by Core and the browser.
+export const COCKPIT_WORK_SECTIONS = Object.freeze(['active', 'planned', 'completed', 'archive']);
+export function hasConsistentWorkCounts(inventory) {
+  if (!inventory || inventory.layout !== 'run-folders-v1' || !Array.isArray(inventory.entries)
+    || !inventory.counts || typeof inventory.counts !== 'object' || Object.keys(inventory.counts).length !== COCKPIT_WORK_SECTIONS.length) return false;
+  return COCKPIT_WORK_SECTIONS.every(section => Number.isSafeInteger(inventory.counts[section])
+    && inventory.counts[section] === inventory.entries.filter(row => row?.section === section).length)
+    && inventory.entries.every(row => row && COCKPIT_WORK_SECTIONS.includes(row.section));
 }
-
-export function backlogRowKey(entry, index, digest) {
-  return JSON.stringify([digest, index, entry.section, entry.key]);
+export function projectCockpitList(inventory, { section = 'active', query = '' } = {}) {
+  if (!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]
+    .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 } }));
+  return { section, query: normalized, coverage: diagnostics.length || selected.some(row => !row.entry.selectable) ? 'partial' : 'complete',
+    diagnostics, sectionCount: selected.length, matchCount: rows.length, rows };
 }
 
-export function projectCockpitList(inventory, { section = COCKPIT_BACKLOG_SECTIONS[0], query = '' } = {}) {
-  if (!COCKPIT_BACKLOG_SECTIONS.includes(section)) throw Error('dto_invalid');
-  const normalizedQuery = query.trim().toLowerCase();
-  const unavailable = { section, query: normalizedQuery, coverage: 'unavailable', diagnostics: [], sectionCount: null, matchCount: null, rows: [] };
-  if (!inventory) return unavailable;
-  if (!hasConsistentBacklogCounts(inventory)) throw Error('dto_invalid');
-  const diagnostics = inventory.diagnostics.filter(d => !d.section || d.section === section);
-  if (!Object.hasOwn(inventory.counts, section) || diagnostics.some(d => unreadableLayout.test(d.code))) return { ...unavailable, diagnostics };
-  const rows = [];
-  let sectionCount = 0, nonselectable = false;
-  inventory.entries.forEach((entry, index) => {
-    if (entry.section !== section) return;
-    sectionCount++;
-    nonselectable ||= !entry.selectable;
-    if (normalizedQuery && ![entry.title, entry.key, entry.stored_status].some(field => field.toLowerCase().includes(normalizedQuery))) return;
-    rows.push({ entry, index, identity: backlogRowKey(entry, index, inventory.content_digest), selectable: entry.selectable,
-      displayTitle: entry.title.replace(/^\[(framework[-_]maintenance|external[-_]delivery)\]\s*/i, '') || entry.title,
-      provenance: { path: inventory.source_path, digest: inventory.content_digest, originalTitle: entry.title } });
-  });
-  return { section, query: normalizedQuery, coverage: diagnostics.length || nonselectable ? 'partial' : 'complete', diagnostics,
-    sectionCount, matchCount: rows.length, rows: rows.reverse() };
+// 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');
+  const normalized = query.trim().toLowerCase();
+  const entries = inventory.runs.filter(run => 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,
+    coverage: inventory.state === 'complete' ? 'complete' : inventory.state === 'absent' ? 'unavailable' : 'partial' };
 }

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

@@ -10,13 +10,13 @@ import { COCKPIT_LIMITS, parseCockpitArguments, parsePluginCockpitArguments } fr
 
 // One connection owns bounded independent read views. Retiring workers still occupy slots.
 export function createCockpitSessionService(root, {
-  poolFactory = viewRoot => new ReadWorkerPool(viewRoot, { limits: { total: COCKPIT_LIMITS.capture },
-    maxOldGenerationSizeMb: COCKPIT_LIMITS.workerOldGeneration }), now = Date.now, pluginMode = false,
+  budget, poolFactory = viewRoot => new ReadWorkerPool(viewRoot, { limits: { total: COCKPIT_LIMITS.capture },
+    maxOldGenerationSizeMb: COCKPIT_LIMITS.workerOldGeneration, budget }), now = Date.now, pluginMode = false,
 } = {}) {
   const target = pluginMode ? null : { target_id: resolveControlCommandTarget(root).target_id, display_path: root };
   const sessions = new Map();
   let closed = false, renderGeneration = 0, publication = null;
-  const failure = (code, viewTarget = target) => ({ schema_version: '1', target: viewTarget, snapshot_id: null, observed_as_of: 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) {
     if (publication?.session_id !== session.id) return;
@@ -153,7 +153,7 @@ export function createCockpitSessionService(root, {
           if (active(session.id) !== session || generation !== session.generation) return fail('session_expired');
           touch(session); return result;
         }
-        if (input.operation === 'backlog_titles' && input.row_ids.some(id => !session.rows.has(id))) return fail('resource_denied');
+        if (['planned', 'archive'].includes(input.operation) && !session.rows.has(input.row_id)) return fail('resource_denied');
         if (['document', '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');
@@ -171,14 +171,14 @@ export function createCockpitSessionService(root, {
           if (publication.phase !== 'prepared') return fail('context_superseded');
         }
         if (input.operation === 'artifact_readiness' && publication) return fail(publication.phase === 'uncertain' ? 'context_cleanup_uncertain' : 'busy');
-        const replacement = ['snapshot', 'backlog_titles', 'run', 'document', 'context', 'artifact_readiness'].includes(input.operation);
-        if (['backlog_titles', 'run', 'document', 'context', 'artifact_readiness'].includes(input.operation)) {
+        const replacement = ['snapshot', 'run', 'document', 'context', 'artifact_readiness'].includes(input.operation);
+        if (['run', 'document', 'context', 'artifact_readiness'].includes(input.operation)) {
           discardPacket(session); ++session.generation; session.documents.clear(); session.snapshot = null; session.draft = null;
         }
         generation = session.generation;
         if (replacement) session.rows.clear();
         const result = await session.pool.request({ operation: input.operation, snapshot: input.snapshot_id,
-          selector: ['run', 'context'].includes(input.operation) ? input.run_id : input.resource_id, input }, signal);
+          selector: ['planned', 'archive'].includes(input.operation) ? input.row_id : ['run', 'context'].includes(input.operation) ? input.run_id : input.resource_id, input }, signal);
         if (active(session.id) !== session || generation !== session.generation) return fail('session_expired');
         const response = { ...result, authorizes: false };
         if (Buffer.byteLength(JSON.stringify(response), 'utf8') > READ_LIMITS.response) throw new ControlReadError('resource_limit');
@@ -190,7 +190,7 @@ export function createCockpitSessionService(root, {
         }
         if (!['resource_denied', 'context_superseded', 'busy', 'context_cleanup_uncertain'].includes(result.code)) touch(session);
         if (replacement && result.snapshot_id) session.snapshot = result.snapshot_id;
-        if (replacement && result.data?.kind === 'backlog') for (const row of result.data.entries) session.rows.add(row.row_id);
+        if (replacement && result.data?.kind === 'work') for (const row of result.data.entries) session.rows.add(row.row_id);
         if (replacement) { session.run_id = result.data?.run?.run_id ?? null; session.draft = result.data?.run?.draft_check?.source ?? null; }
         if (replacement && result.data?.run?.resources) for (const resource of result.data.run.resources) {
           session.documents.set(resource.resource_id, `${result.snapshot_id}:${result.data.run.run_id}`);

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

@@ -0,0 +1,33 @@
+import { readCockpitArchive, archiveRows } from './cockpit-archive.js';
+import { readWorkInventory } from '../control-state/planned-inventory.js';
+import { digest, canonicalJson } from '../control-state/approval-command-contract.js';
+import { COCKPIT_WORK_SECTIONS as sections } from './cockpit-list.js';
+
+// Compatibility DTO for the existing list/session protocol. The explicit layout
+// 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' });
+  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,
+      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,
+      current_spec: null, source: row.source, coverage: row.coverage, actions: row.actions,
+      handoff_ready: planned ? row.handoff_ready : false, planning_origins: row.planning_origins ?? [],
+      selectable: planned ? row.source.digest !== null && row.coverage !== 'unavailable' : row.valid, authorizes: false };
+  });
+  let archive = null;
+  try { archive = readCockpitArchive(root); } catch (error) { inventory.findings.push({ code: error.code ?? 'archive_invalid', section: 'archive' }); inventory.state = 'partial'; }
+  entries.push(...archiveRows(archive));
+  return { state: inventory.state === 'partial' ? 'partial' : entries.length ? 'available' : 'empty',
+    code: inventory.state === 'partial' ? 'work_inventory_partial' : null,
+    data: { kind: 'work', layout: 'run-folders-v1', entries, diagnostics: inventory.findings,
+      source_path: '.agdf/control/', content_digest: digest(canonicalJson(inventory)).slice(7),
+      counts: Object.fromEntries(sections.map(section => [section, entries.filter(row => row.section === section).length])),
+      planning_references: inventory.planning_references, authorizes: false } };
+}

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

@@ -1,4 +1,8 @@
-import { relative, join, posix, sep } from 'node:path';
+import { readCockpitArchive, readArchiveDocument } from './cockpit-archive.js';
+import { runDocumentPath } 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';
 import { randomUUID, createHash } from 'node:crypto';
 import { captureControlScope, fail, READ_LIMITS } from '../control-read/snapshot.js';
 import { withControlReadView } from '../control-read/fs.js';
@@ -10,13 +14,15 @@ import { resolveControlCommandTarget } from '../control-state/approval-command-c
 import { localePack, resolveHumanRunTitle } from '../interaction-presentation.js';
 import { interactionLocales } from '../resources/context.js';
 import { projectCockpitContext, composeCockpitPacket } from './cockpit-context.js';
-import { projectCockpitBacklog, projectBacklogUrTitle } from './cockpit-backlog.js';
+import { projectCockpitWork } from './cockpit-work.js';
+import { readControlLayout } from '../control-state/control-layout.js';
+import { inspectPlannedEntry } from '../control-state/planned-entry.js';
 import { runWorkSummary } from '../control-evaluation/run-work-summary.js';
 import { runSealState } from '../control-state/run-seal.js';
-import { canonicalJson } from '../control-state/approval-command-contract.js';
 import { ARTIFACT_READINESS_GATES, projectArtifactReadiness, describeArtifactReadiness } from './artifact-readiness.js';
 import { artefactFileDigest } from '../control-state/run-seal-compute.js';
 import { inspectApprovedArtefact } from '../control-state/artefact-binding-proof.js';
+import { runClosure, ENDED_LIFECYCLES } from '../control-state/run-operations.js';
 
 const CONTROL = '.agdf/control/';
 const SUPPORTED = new Map([['md', 'markdown'], ['json', 'json'], ['txt', 'text'], ['log', 'text']]);
@@ -26,14 +32,25 @@ 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'); };
 function boundedCode(error) {
+  const code = error.code ?? error.message;
+  if (code === 'AGDF_CONTROL_LAYOUT_UNSUPPORTED') return 'control_layout_unsupported';
+  if (code === 'AGDF_RUN_VERSION_UNSUPPORTED') return 'run_version_unsupported';
+  if (code === 'AGDF_CONTROL_LAYOUT_INVALID') return 'control_invalid';
   return ['resource_denied', 'source_changed', 'timeout', 'resource_limit', 'read_failed'].includes(error.code) ? error.code : 'read_failed';
 }
 const objective = 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);
+  return closure && { outcome: closure.outcome, reason: closure.reason, successor: closure.successor, confirmed_by: closure.confirmed_by,
+    closed_at: closure.closed_at, operation_id: closure.operation_id, receipt: closure.receipt, authorizes: false };
+}
 
 // Read-only projection of the evaluated decision, never a second gate evaluator.
 // Doctor warnings are already considered by evaluateGateCheck; they are not a UI veto.
 export function projectCockpitAssessment(report, lifecycle) {
-  const state = lifecycle === 'completed' ? report.completion?.fulfilled === true ? 'completed' : 'unconfirmed'
+  const state = ENDED_LIFECYCLES.includes(lifecycle) ? 'ended'
+    : lifecycle === 'completed' ? report.completion?.fulfilled === true ? 'completed' : 'unconfirmed'
     : lifecycle !== 'active' ? 'unconfirmed'
     : report.status === 'blocked' || (report.blocking_reason && report.blocking_reason !== 'none')
       || (report.missing_approval && report.missing_approval !== 'none') ? 'blocked'
@@ -45,12 +62,12 @@ export function projectCockpitAssessment(report, lifecycle) {
 export function createCockpitReader(root, options = {}) {
   let view = null, details = new Map(), documents = new Map();
   let graph = null, inspected = null, packet = null;
-  let backlogRows = new Map(), backlogDigest = null;
+  let plannedRows = new Map(), archiveRows = new Map();
   // One result belongs to this existing reader, never to a shared or durable cache.
   let checkedDraft = null;
   const invalidate = () => { packet = null; };
   const target = { target_id: resolveControlCommandTarget(root).target_id, display_path: root };
-  const meta = () => ({ schema_version: '1', target, snapshot_id: view?.snapshot_id ?? null,
+  const meta = () => ({ schema_version: '2', target, snapshot_id: view?.snapshot_id ?? null,
     observed_as_of: view?.observed_as_of ?? null, source_digest: view?.digest ?? null });
   const envelope = (data, state = 'available', code = null, retryable = false) => ({ ...meta(), state, code, retryable, data });
   function evaluation(state, report, lifecycle) {
@@ -117,30 +134,17 @@ export function createCockpitReader(root, options = {}) {
     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 work_summary = outside.length ? null : runWorkSummary(root, run.content, state.path);
-    const savedRows = projectCockpitBacklog(root).data?.entries.filter(row => row.key === run.run_id) ?? [];
-    const saved = savedRows.length === 1 ? savedRows[0].saved_summary?.record : null;
-    let comparison = 'unavailable', comparison_reason = 'saved_observation_unverified';
-    if (outside.length) comparison_reason = 'evaluation_out_of_scope';
-    else if (runSealState(root, run.content).status !== 'valid') comparison_reason = 'run_source_unconfirmed';
-    else if (work_summary?.limitations.length) comparison_reason = 'summary_source_unconfirmed';
-    else if (saved && work_summary) {
-      const keys = ['kind', 'phase', 'qa_outcome', 'lifecycle', 'recorded_approvals', 'decisive_obligation',
-        'open_obligation_count', 'display_action', 'sources', 'limitations', 'authorizes'];
-      comparison = saved.revision_id === run.meta.revision_id && keys.every(key => canonicalJson(saved[key]) === canonicalJson(work_summary[key])) ? 'matching' : 'different';
-      comparison_reason = comparison === 'matching' ? 'same_revision_and_sources' : 'saved_observation_differs';
-    }
     const draft_check = draftDescriptor(run, state, report);
     const document_states = documentStates(run, state, report, resources, draft_check);
     return { run_id: run.run_id, revision_id: run.meta.revision_id, lifecycle: run.meta.lifecycle,
-      work_summary, backlog_comparison: { state: comparison, reason: comparison_reason,
-        saved_revision_id: saved?.revision_id ?? null, authorizes: false },
+      closure: projectRunClosure(run.content), work_summary,
       // 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,
-        decision: run.meta.decision, artefacts: [...state.artefacts].map(([type, value]) => ({ type, ...value })) },
+        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,
         state.evidence_applicability[group].map(row => ({ step: row.step ?? null, path: row.report?.path ?? row.source, reason: row.reason, available: row.available }))])) };
@@ -186,7 +190,7 @@ export function createCockpitReader(root, options = {}) {
   function draftDescriptor(run, state, report) {
     const gate = report?.current_gate ?? state.current_gate;
     const source = { run_id: run.run_id, gate, revision_id: run.meta.revision_id,
-      artifact_path: ARTIFACT_READINESS_GATES.includes(gate) ? `.agdf/control/artefacts/${run.run_id}/${gate}.md` : null,
+      artifact_path: ARTIFACT_READINESS_GATES.includes(gate) ? `${runDocumentPath(run.run_id, '')}/${gate}.md` : null,
       artifact_digest: null, available: false, reason: 'artifact_gate_invalid' };
     if (!source.artifact_path) {
       checkedDraft = null;
@@ -245,12 +249,12 @@ export function createCockpitReader(root, options = {}) {
     if (!retainCheck) checkedDraft = null;
     invalidate(); inspected = null; graph = null; view = null;
     details = new Map(); documents = new Map();
-    backlogRows = new Map(); backlogDigest = null;
+    plannedRows = new Map(); archiveRows = new Map();
   }
   function selectedRun(runId) {
     const run = discoverRuns(root).find(row => row.run_id === runId);
     if (!run) { checkedDraft = null; return { state: 'missing', code: 'run_missing', data: { kind: 'run', requested_run_id: runId, run: null } }; }
-    if (!run.valid) { checkedDraft = null; return { state: 'invalid', code: 'invalid_run', data: { kind: 'run', requested_run_id: runId,
+    if (!run.valid) { checkedDraft = null; return { state: run.findings.some(row => row.classification === 'unsupported_version') ? 'unsupported' : 'invalid', code: run.findings.some(row => row.classification === 'unsupported_version') ? 'run_version_unsupported' : 'invalid_run', data: { kind: 'run', requested_run_id: runId,
       run: { run_id: runId, revision_id: null, lifecycle: null, resources: [], diagnostics: run.findings } } };
     }
     const data = detail(run);
@@ -262,22 +266,25 @@ export function createCockpitReader(root, options = {}) {
     // before recording a candidate; a failed candidate never restores them.
     discardScope(retainCheck);
     try {
+      if (existsSync(join(root, '.agdf/control'))) readControlLayout(root);
       const captured = captureControlScope(root, candidate => {
         view = candidate; details = new Map(); documents = new Map(); graph = null; inspected = null;
         return project();
       }, options);
       view = captured.view;
       return envelope(captured.data.data, captured.data.state, captured.data.code, !!captured.data.code);
-    } catch (error) { discardScope(); return envelope(null, 'error', boundedCode(error), true); }
+    } catch (error) { discardScope(); const code = boundedCode(error); return envelope(null, code.endsWith('_unsupported') ? 'unsupported' : 'error', code, true); }
   }
   const sameRegistration = (a, b) => a.run_id === b.run_id && a.type === b.type && a.registered_reference === b.registered_reference;
-  function backlogScope(removedRunId = null, titleRows = [], expectedDigest = null) {
-    const result = projectCockpitBacklog(root);
-    backlogRows = new Map(); backlogDigest = result.data?.content_digest ?? null;
-    if (expectedDigest && backlogDigest !== expectedDigest) fail('source_changed');
-    if (result.data) result.data.entries.forEach((row, index) => {
-      row.row_id = randomUUID(); backlogRows.set(row.row_id, index);
-      if (titleRows.includes(index)) row.title_observation = projectBacklogUrTitle(root, view, row, backlogDigest);
+  function workScope(removedRunId = null) {
+    readControlLayout(root);
+    const result = projectCockpitWork(root);
+    plannedRows = new Map(); archiveRows = new Map();
+    if (result.data) result.data.entries.forEach(row => {
+      if (row.kind === 'run') row.selectable = row.selectable && existsSync(join(root, '.agdf/control/runs', row.key, 'RUN_STATE.md'));
+      row.row_id = randomUUID();
+      if (row.kind === 'archive') archiveRows.set(row.row_id, { id: row.key, digest: row.source.digest });
+      if (row.kind === 'planned') plannedRows.set(row.row_id, { plan_id: row.key, digest: row.source.digest });
     });
     if (result.data) Object.assign(result.data, { file_count: view.file_count, byte_count: view.byte_count,
       ...(removedRunId ? { removed_run_id: removedRunId } : {}) });
@@ -285,7 +292,7 @@ export function createCockpitReader(root, options = {}) {
   }
   function reopenRun(runId, wasInspected) {
     const selected = selectedRun(runId);
-    return selected.code === 'run_missing' && wasInspected ? backlogScope(runId) : selected;
+    return selected.code === 'run_missing' && wasInspected ? workScope(runId) : selected;
   }
   function selectedDocument(previous, runId) {
     const selected = selectedRun(runId);
@@ -297,21 +304,52 @@ export function createCockpitReader(root, options = {}) {
     return { state: document.state, code: document.code, data: { kind: 'document', run: selected.data.run, document: document.data } };
   }
   return Object.freeze({
-    snapshot(runId) {
-      if (runId !== undefined && !/^[A-Za-z0-9_-]{1,128}$/.test(runId)) fail('resource_denied');
+    snapshot(runId, scope = 'runs') {
+      if (scope !== 'runs' || runId !== undefined && scope !== 'runs') fail('resource_denied');
+      if (runId !== undefined && !RUN_ID_PATTERN.test(runId)) fail('resource_denied');
       const wasInspected = details.get(runId)?.state === 'available';
       return replaceScope(() => {
         if (view.control_absent) return { state: 'missing', code: 'control_absent', data: null };
         if (runId) return reopenRun(runId, wasInspected);
-        return backlogScope();
+        return workScope();
       });
     },
     run(runId, id) {
-      if (!/^[A-Za-z0-9_-]{1,128}$/.test(runId)) fail('resource_denied');
+      if (!RUN_ID_PATTERN.test(runId)) fail('resource_denied');
       assertSnapshot(id);
       const wasInspected = details.get(runId)?.state === 'available';
       return replaceScope(() => reopenRun(runId, wasInspected), true);
     },
+    planned(rowId, id) {
+      const selected = plannedRows.get(rowId);
+      if (!selected) fail('resource_denied');
+      assertSnapshot(id);
+      const entry = withControlReadView(view, () => inspectPlannedEntry(root, selected.plan_id, { presentationLanguage: 'de' }));
+      if (entry.digest !== selected.digest) fail('source_changed');
+      view.revalidate();
+      return envelope({ kind: 'planned', entry: { plan_id: entry.plan_id, title: entry.title, priority: entry.priority,
+        path: entry.path, digest: entry.digest, content: entry.content, readiness: entry.readiness, authorizes: false } });
+    },
+    archive(rowId, id, resourceId) {
+      const selected = archiveRows.get(rowId); if (!selected) fail('resource_denied');
+      assertSnapshot(id);
+      // The overview capture is frozen. Read an immutable archive reference in a
+      // separate bounded capture, checking its index digest against that overview.
+      const captured = captureControlScope(root, () => {
+        const index = readCockpitArchive(root);
+        if (!index || index.digest !== selected.digest) fail('source_changed');
+        const run = index.entries.find(row => row.id === selected.id); if (!run) fail('resource_denied');
+        const resources = run.documents.map(doc => { const h = rawDigest(Buffer.from(doc.path)); return { ...doc,
+          resource_id: `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-8${h.slice(17, 20)}-${h.slice(20, 32)}` }; });
+        const doc = resourceId === undefined ? null : resources.find(row => row.resource_id === resourceId);
+        if (resourceId !== undefined && !doc) fail('resource_denied');
+        const document = doc ? { resource_id: doc.resource_id, ...readArchiveDocument(root, doc) } : null;
+        return { kind: 'archive', entry: { id: run.id, title: run.title, entry_kind: run.entry_kind, recorded_lifecycle: run.recorded_lifecycle,
+          recorded_gate: run.recorded_gate, source_control_version: run.source_control_version, recorded_approvals: run.recorded_approvals, resources, authorizes: false }, document };
+      }, options);
+      assertSnapshot(id);
+      return envelope(captured.data);
+    },
     artifactReadiness(runId, id, gate, revision) {
       const previous = details.get(runId)?.data?.draft_check?.source;
       if (!previous || !previous.available || previous.gate !== gate || previous.revision_id !== revision) fail('resource_denied');
@@ -333,13 +371,6 @@ export function createCockpitReader(root, options = {}) {
         return selected;
       });
     },
-    backlogTitles(rowIds, id) {
-      if (!Array.isArray(rowIds) || !rowIds.length || rowIds.length > 12 || new Set(rowIds).size !== rowIds.length
-        || rowIds.some(row => !backlogRows.has(row))) fail('resource_denied');
-      assertSnapshot(id);
-      const rows = rowIds.map(row => backlogRows.get(row)), digest = backlogDigest;
-      return replaceScope(() => backlogScope(null, rows, digest));
-    },
     document(resourceId, id, runId) {
       // Check selectors before revalidation or replacing the legitimate view.
       const previous = documents.get(resourceId);