create-agdf 0.30.0 → 0.32.0

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

@@ -1,4 +1,9 @@
+import { MATERIAL_LIMITS } from '../control-state/material-limits.js';
+import { AUTHORING_TEXT_HANDOFF } from '../control-state/authoring-text-handoff.js';
+import { approvalSummaryAuthoringFormat } from '../control-state/run-presentation-render.js';
+import { resolveArtifactPresentationLanguages } from '../resources/context.js';
 import { runDocumentPath } from '../control-state/run-identity.js';
+import { preparedCommandCall } from '../control-state/prepared-control-calls.js';
 import { inspectArtefactRecordingMode } from '../control-state/run-artefact-recording.js';
 import { readFileSync, statSync } from '../control-read/fs.js';
 import { captureControlScope } from '../control-read/snapshot.js';
@@ -14,6 +19,7 @@ import { evaluateGateCheck } from '../control-evaluation/gate-check.js';
 import { inspectPlannedEntry, inspectPlannedSelection } from '../control-state/planned-entry.js';
 import { assertPlannedNotTransferred } from '../control-state/planned-origin-reader.js';
 import { parseControlState } from '../control-state/run-state-parser.js';
+import { CLOSEOUT_AUTHORING_SCOPE, isCompletedStructuredCloseout } from './selection.js';
 
 const templateId = gate => ({ UR: 'UR', PRD: 'PRD', SD: 'SD', TP: 'TP', QA: 'QA_REPORT', OR: 'OR',
   'Brownfield Review': 'BROWNFIELD_REVIEW', 'Brownfield Analysis': 'BROWNFIELD_REVIEW', 'Mode/Slice Decision': 'BROWNFIELD_REVIEW',
@@ -24,29 +30,37 @@ const templateId = gate => ({ UR: 'UR', PRD: 'PRD', SD: 'SD', TP: 'TP', QA: 'QA_
 export function inspectAuthoringInputs(root, input, { gitObservation } = {}) {
   const unavailable = reason => ({ available: false, reason, authorizes: false });
   try {
-    const observeGit = () => !input.planning && gitObservation ? { head: gitObservation.gitValue(root, ['rev-parse', 'HEAD']),
+    const scopedCloseout = input.authoring_scope === CLOSEOUT_AUTHORING_SCOPE;
+    const observeGit = () => ({ head: gitObservation.gitValue(root, ['rev-parse', 'HEAD']),
       tracked: gitObservation.gitPathList(root, ['diff', 'HEAD', '--name-only']),
-      untracked: gitObservation.gitPathList(root, ['ls-files', '--others', '--exclude-standard']) } : null;
-    const git = observeGit(), observedGit = git ? { gitValue: () => git.head,
-      gitPathList: (_root, args) => args[0] === 'diff' ? git.tracked : git.untracked } : undefined;
+      untracked: gitObservation.gitPathList(root, ['ls-files', '--others', '--exclude-standard']) });
+    let git;
+    const currentGit = () => git ??= observeGit();
+    const observedGit = !input.planning && gitObservation ? { gitValue: () => currentGit().head,
+      gitPathList: (_root, args) => args[0] === 'diff' ? currentGit().tracked : currentGit().untracked } : undefined;
     const captured = captureControlScope(root, () => {
+      const languages = resolveArtifactPresentationLanguages(root, input.presentation_language);
       if (input.planning) {
         inspectPlannedSelection(root, input.planning, { presentationLanguage: input.presentation_language });
         const creating = input.planning.expected_digest === null;
         const entry = creating ? null : inspectPlannedEntry(root, input.planning.plan_id, { presentationLanguage: input.presentation_language });
         if (!creating) assertPlannedNotTransferred(root, input.planning.plan_id);
         const kind = creating ? 'planned_ur.create' : 'planned_ur.replace';
-        return { gate: null, authoring_owner: 'UR', mode: 'planning', recording: { mode: creating ? 'create_planned' : 'replace_planned', kind },
+        return { languages, gate: null, authoring_owner: 'UR', mode: 'planning', recording: { mode: creating ? 'create_planned' : 'replace_planned', kind },
           next_operation: { type: 'author_planned_ur', skill_id: 'ur-definition', kind }, status: 'draft', blocking_reason: null,
           sources: entry ? [{ type: 'UR', path: entry.path, status: 'draft', digest: entry.digest, content: entry.content }] : [] };
       }
       const state = readRunState(root, { runId: input.run_id, ignoreRunIdEnv: true });
       if (state.resolution_error || state.meta?.revision_id !== input.expected_revision_id || runSealState(root, state.content).status !== 'valid') throw Error('authoring_binding_stale_or_invalid');
       const evaluated = evaluateGateCheck(root, { runId: input.run_id, ignoreRunIdEnv: true, presentationLanguage: input.presentation_language }, observedGit);
+      const mode = state.mode_slice_decision?.decision;
+      if (scopedCloseout && !isCompletedStructuredCloseout(evaluated, mode)) throw Error('authoring_closeout_unavailable');
       const protectedSources = parseControlState(state.content, { closeoutArtefacts: ['Planned UR Snapshot', 'Planned UR Origin'] }).artefacts;
       const rows = [...new Map([...state.artefacts, ...protectedSources])].filter(([, r]) => r.path).map(([type, row]) => ({ type, ...row }));
       if (rows.length > 32) throw Error('authoring_source_limit');
-      const sources = rows.map(row => {
+      const selected = scopedCloseout ? rows.filter(row => row.type === 'OR' || row.type === 'QA') : rows;
+      if (scopedCloseout && selected.length !== 2) throw Error('authoring_closeout_unavailable');
+      const sources = selected.map(row => {
         const path = row.path.replace(/^`|`$/gu, '');
         if (!path.startsWith(`${runDocumentPath(input.run_id, '')}/`) || hasSymlinkComponent(root, path)) throw Error('authoring_source_unavailable');
         const file = containedRegularFile(root, path);
@@ -54,17 +68,19 @@ export function inspectAuthoringInputs(root, input, { gitObservation } = {}) {
         const content = new TextDecoder('utf-8', { fatal: true }).decode(readFileSync(file.path));
         return { type: row.type, path, status: row.status, digest: artefactFileDigest(root, path), content };
       });
+      if (scopedCloseout) return { languages, gate: evaluated.current_gate, mode, status: evaluated.status,
+        blocking_reason: evaluated.blocking_reason, next_operation: evaluated.next_operation, sources };
       // Match dispatch's initial UX prerequisite route as well as source reassessment.
       // Reuse its eligibility and contained-source facts; inspection grants no repair permission.
       const prdEligible = prdDefinitionEligible(evaluated, { ...input, skill_id: 'prd-definition' });
       const uxRequired = prdEligible && inspectDefinitionSources(root, state, input.run_id, 'PRD', ['UR', 'Brownfield Review']).issue?.repairable;
       const nextOperation = uxRequired ? { type: 'reassess_source_analysis', skill_id: 'ux-intent-definition', analysis: 'UX Intent Definition' } : evaluated.next_operation;
-      return { gate: evaluated.current_gate, authoring_owner: nextOperation?.type === 'record_closeout' ? 'OR'
-        : nextOperation?.analysis ?? nextOperation?.gate ?? evaluated.current_gate,
-        recording: inspectArtefactRecordingMode(state, evaluated.current_gate), mode: state.mode_slice_decision?.decision, next_operation: nextOperation, status: evaluated.status,
+      return { languages, gate: evaluated.current_gate, authoring_owner: nextOperation?.type === 'record_closeout' ? 'OR'
+        : nextOperation?.analysis ?? nextOperation?.internal_step ?? nextOperation?.gate ?? evaluated.current_gate,
+        recording: inspectArtefactRecordingMode(state, evaluated.current_gate), mode, next_operation: nextOperation, status: evaluated.status,
         blocking_reason: evaluated.blocking_reason, sources };
     });
-    const data = captured.data, ids = [data.gate === 'OR' && data.mode === 'verified_change' ? 'VERIFIED_CHANGE' : templateId(data.authoring_owner),
+    const data = captured.data, ids = scopedCloseout ? [] : [data.gate === 'OR' && data.mode === 'verified_change' ? 'VERIFIED_CHANGE' : templateId(data.authoring_owner),
       ...(['Brownfield Review', 'Mode/Slice Decision'].includes(data.gate) ? ['VERIFIED_CHANGE'] : [])].filter(Boolean);
     const templates = ids.map(id => {
       const path = resolveArtefactTemplatePath(id);
@@ -72,39 +88,108 @@ export function inspectAuthoringInputs(root, input, { gitObservation } = {}) {
       const content = new TextDecoder('utf-8', { fatal: true }).decode(readFileSync(path));
       return { role: 'template', type: id, digest: digest(canonicalRunText(content)), content, source: 'version_matched_plugin' };
     });
-    const documents = [...templates, ...data.sources.map(s => ({ role: 'source', ...s }))];
+    const sources = data.sources.map(s => ({ role: 'source', ...s }));
+    const currentDraft = sources.find(source => source.type === data.authoring_owner);
+    // The source being corrected must not move behind unrelated, growing sources.
+    // Keep the legacy template-first view; bundles put the current source first.
+    const documents = input.bundle && currentDraft
+      ? [currentDraft, ...templates, ...sources.filter(source => source !== currentDraft)]
+      : [...templates, ...sources];
     if (documents.length > 32) throw Error('authoring_source_limit');
     const manifest = digest(JSON.stringify({ target_id: resolveControlCommandTarget(root).target_id, run_id: input.run_id,
       ...(input.planning ? { planning: input.planning } : {}),
-      revision_id: input.expected_revision_id, gate: data.gate, authoring_owner: data.authoring_owner, recording: data.recording, documents: documents.map(({ content, ...r }) => r) })).slice(7);
+      ...(scopedCloseout ? { authoring_scope: input.authoring_scope } : {}),
+      revision_id: input.expected_revision_id, languages: data.languages, ...(input.bundle ? { bundle: 2 } : {}), gate: data.gate, authoring_owner: data.authoring_owner, recording: data.recording, documents: documents.map(({ content, ...r }) => r) })).slice(7);
     const chunks = [];
     for (const document of documents) {
       const { content, ...metadata } = document, bytes = Buffer.from(content);
+      if (input.bundle && !bytes.length) chunks.push({ ...metadata, content: '', byte_start: 0, byte_end: 0, total_bytes: 0 });
       for (let start = 0; start < bytes.length;) {
         let end = Math.min(start + 16384, bytes.length);
         while (end < bytes.length && (bytes[end] & 0xc0) === 0x80) end--;
-        chunks.push({ ...metadata, content: bytes.subarray(start, end).toString('utf8'), byte_start: start, byte_end: end, total_bytes: bytes.length });
+        let chunk;
+        for (;;) {
+          chunk = { ...metadata, content: bytes.subarray(start, end).toString('utf8'), byte_start: start, byte_end: end, total_bytes: bytes.length };
+          if (!input.bundle || Buffer.byteLength(JSON.stringify([chunk])) <= 48128) break;
+          end = start + Math.floor((end - start) / 2);
+          while (end > start && (bytes[end] & 0xc0) === 0x80) end--;
+          if (end <= start) throw Error('authoring_metadata_limit');
+        }
+        chunks.push(chunk);
         start = end;
       }
     }
+    const pages = [];
+    if (input.bundle) {
+      for (const chunk of chunks) {
+        const last = pages.at(-1);
+        if (!last || Buffer.byteLength(JSON.stringify([...last, chunk])) > 48128) pages.push([chunk]);
+        else last.push(chunk);
+      }
+    }
+    const selection = input.bundle ? pages : chunks;
     const prefix = `${manifest}:`;
     if (input.cursor !== undefined && (!input.cursor.startsWith(prefix) || !/^(0|[1-9][0-9]*)$/u.test(input.cursor.slice(prefix.length)))) throw Error('authoring_cursor_stale_or_invalid');
     const index = input.cursor === undefined ? 0 : Number(input.cursor.slice(prefix.length));
-    if (!Number.isSafeInteger(index) || index < 0 || index >= Math.max(chunks.length, 1)) throw Error('authoring_cursor_stale_or_invalid');
+    if (!Number.isSafeInteger(index) || index < 0 || index >= Math.max(selection.length, 1)) throw Error('authoring_cursor_stale_or_invalid');
+    if (git && JSON.stringify(observeGit()) !== JSON.stringify(git)) throw Error('authoring_binding_stale_or_invalid');
     captured.view.revalidate();
-    if (JSON.stringify(observeGit()) !== JSON.stringify(git)) throw Error('authoring_binding_stale_or_invalid');
-    const formats = input.planning ? operationContract('agdf_record', data.recording.kind) : data.authoring_owner === 'OR' ? operationContract('agdf_closeout', 'closeout.record')
+    const grouped = new Map();
+    for (const part of pages[index] ?? []) {
+      const key = JSON.stringify([part.role, part.type, part.path, part.digest]);
+      const prior = grouped.get(key);
+      if (prior) {
+        if (prior.byte_end !== part.byte_start) throw Error('authoring_fragment_order_invalid');
+        prior.content += part.content; prior.byte_end = part.byte_end;
+      } else grouped.set(key, { ...part });
+    }
+    const documentRows = [...grouped.values()].map(row => ({ ...row, complete: row.byte_start === 0 && row.byte_end === row.total_bytes }));
+    const documentPage = { documents: documentRows.filter(row => row.complete), fragments: documentRows.filter(row => !row.complete) };
+    if (input.bundle && Buffer.byteLength(JSON.stringify(documentPage)) > 49152) throw Error('authoring_page_limit');
+    const pageCall = page => ({ tool: 'agdf_inspect', arguments: { operation: 'authoring-inputs',
+      ...Object.fromEntries(['presentation_language', 'working_directory', 'primary_target', 'target_source', 'target_id',
+        'run_id', 'expected_revision_id', 'planning', 'bundle', 'authoring_scope'].filter(key => input[key] !== undefined).map(key => [key, input[key]])),
+      cursor: `${prefix}${page}` } });
+    const nextPage = index + 1 < selection.length ? pageCall(index + 1) : null;
+    if (scopedCloseout) return { available: true, ...data.languages, run_id: input.run_id, revision_id: input.expected_revision_id,
+      gate: data.gate, mode: data.mode, status: data.status, blocking_reason: data.blocking_reason, next_operation: data.next_operation,
+      authoring_scope: input.authoring_scope, manifest_digest: `sha256:${manifest}`,
+      document_manifest: documents.map(({ content, ...metadata }) => metadata), format: 'document_bundle_v2',
+      ...documentPage, page_bytes_limit: 49152, page_index: index, page_count: Math.max(selection.length, 1),
+      complete: !nextPage, next_cursor: nextPage?.arguments.cursor ?? null, next_calls: nextPage ? [nextPage] : [], authorizes: false };
+    const draftRow = currentDraft && documentRows.find(row => row.role === 'source' && row.type === currentDraft.type && row.path === currentDraft.path && row.digest === currentDraft.digest);
+    const draftPage = input.bundle && currentDraft ? pages.findIndex(page => page.some(row => row.role === 'source'
+      && row.type === currentDraft.type && row.path === currentDraft.path && row.digest === currentDraft.digest && row.byte_start === 0)) : -1;
+    const registeredUr = data.authoring_owner === 'UR' && data.sources.some(source => source.type === 'UR' && source.path);
+    const formats = input.planning ? operationContract('agdf_record', data.recording.kind)
+      : registeredUr ? operationContract('agdf_revise', 'ur_draft.replace', { gate: 'UR' }) : data.authoring_owner === 'OR' ? operationContract('agdf_closeout', 'closeout.record')
       : operationContract('agdf_record', ['PRD', 'SD', 'TP', 'QA'].includes(data.authoring_owner) ? 'artefact.record' : 'step.record', { gate: data.authoring_owner });
-    return { available: true, run_id: input.run_id, revision_id: input.expected_revision_id, gate: data.gate, mode: data.mode,
+    const summaryFormat = approvalSummaryAuthoringFormat(data.authoring_owner, currentDraft?.content ?? '', data.languages);
+    return { available: true, ...data.languages, run_id: input.run_id, revision_id: input.expected_revision_id, gate: data.gate, mode: data.mode,
       ...(input.planning ? { planning: input.planning, canonical_skill: 'ur-definition' } : {}),
       authoring_owner: data.authoring_owner, recording: data.recording,
+      ...(summaryFormat ? { approval_summary_format: summaryFormat } : {}),
+      ...(!input.planning && index === 0 ? { material_call: preparedCommandCall('agdf_record', 'material.stage',
+        { ...input, target_id: resolveControlCommandTarget(root).target_id }, { gate: data.authoring_owner }) } : {}),
       status: data.status, blocking_reason: data.blocking_reason, next_operation: data.next_operation,
-      manifest_digest: `sha256:${manifest}`, documents: documents.map(({ content, ...r }) => r),
-      chunk: chunks[index] ?? null, complete: index + 1 >= chunks.length, next_cursor: index + 1 < chunks.length ? `${prefix}${index + 1}` : null,
+      manifest_digest: `sha256:${manifest}`, ...(input.bundle ? { document_manifest: documents.map(({ content, ...r }) => r) } : { documents: documents.map(({ content, ...r }) => r) }),
+      ...(input.bundle ? { format: 'document_bundle_v2', ...documentPage, page_bytes_limit: 49152,
+        page_index: index, page_count: Math.max(selection.length, 1),
+        first_page_call: pageCall(0),
+        current_draft: currentDraft ? { type: currentDraft.type, path: currentDraft.path, status: currentDraft.status, digest: currentDraft.digest,
+          content_state: draftRow?.complete ? 'complete' : draftRow ? 'fragment' : 'not_on_page',
+          ...(draftPage >= 0 && (!draftRow || draftRow.byte_start > 0) ? { read_call: pageCall(draftPage) } : {}),
+          instruction: 'Metadata only, never document text or edit permission. Use the matching complete report.documents row. For a fragment, join matching report.fragments by byte offsets across next_calls before editing. If not_on_page or earlier fragment bytes were not retained, copy read_call.arguments unchanged to read its first page.' } : null }
+        : { chunk: chunks[index] ?? null }), complete: index + 1 >= selection.length,
+      next_cursor: index + 1 < selection.length ? `${prefix}${index + 1}` : null,
+      next_calls: nextPage ? [{ ...nextPage, instruction: 'Copy arguments unchanged to read the next page of this manifest. Retain earlier bytes; repeat until complete before editing a fragmented source. No JavaScript cloning or source/path discovery is needed.' }] : [],
       // The writer contract is identical on every page of one manifest; later pages only name it.
-      formats: index === 0 ? formats : { schema_version: formats.schema_version, available: formats.available, group: formats.group, kind: formats.kind,
+      formats: index === 0 ? input.bundle ? (({ schema, result_schema, ...authoring }) => authoring)(formats) : formats : { schema_version: formats.schema_version, available: formats.available, group: formats.group, kind: formats.kind,
         omitted: 'identical to the first page of this manifest' },
-      material_transport: { tool: 'agdf_record', kind: input.planning ? 'planned_material.stage' : 'material.stage', limits: { request_bytes: 65536, part_bytes: 16384, source_bytes: 131072 },
-        instructions: 'Read all chunks. Stage exact permitted material; seal to obtain identity. Record via the eligible typed writer with explicit cooperative review. No file/path discovery or shell hashing.' }, authorizes: false };
+      material_transport: { tool: 'agdf_record', kind: input.planning ? 'planned_material.stage' : 'material.stage', limits: { request_bytes: 65536, inline_file_bytes: MATERIAL_LIMITS.inline, part_bytes: MATERIAL_LIMITS.part, source_bytes: MATERIAL_LIMITS.file },
+        instructions: (input.bundle
+          ? 'MCP access: response.structuredContent.report (or JSON.parse(response.content[0].text).report). Read complete report.documents[].content; report.document_manifest and current_draft are metadata only. The registered current draft is prioritized; inspect current_draft.content_state before looking for its complete document. Join report.fragments by identity and byte offsets across all next_calls pages before editing. Absent content is an error, never the string undefined. Copy call.arguments unchanged and supply only authored content in the named fields; no JavaScript helper is required. Preserve bundle:true. '
+          : 'MCP access: response.structuredContent.report (or JSON.parse(response.content[0].text).report). This legacy view puts text in report.chunk.content; report.documents is metadata only. Follow every next_cursor with this exact binding, or request bundle:true for fewer round trips. ')
+          + 'The included formats and bound forms replace a second operation-contract read. Retain unchanged sources for this manifest. Prefer material_call: put takes exact UTF-8 <=48 KiB per file within the 64 KiB JSON request bound and seals once. Use returned recording_calls, adding only required author/review inputs. Larger files use multipart; each action has its own UUID. Follow next_calls exactly. No file/path discovery or shell hashing. ' + AUTHORING_TEXT_HANDOFF }, authorizes: false };
   } catch (e) { return unavailable(e.code ?? e.message); }
 }

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';
@@ -22,7 +24,11 @@ import { runSealState } from '../control-state/run-seal.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';
+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 };
 
 const CONTROL = '.agdf/control/';
 const SUPPORTED = new Map([['md', 'markdown'], ['json', 'json'], ['txt', 'text'], ['log', 'text']]);
@@ -31,14 +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'); };
-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;
+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);
@@ -46,18 +45,6 @@ export function projectRunClosure(content) {
     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 = 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'
-    : report.status === 'open' && report.blocking_reason === 'none' && report.missing_approval === 'none' ? 'open'
-    : 'unconfirmed';
-  return { state, authorizes: false };
-}
 
 export function createCockpitReader(root, options = {}) {
   let view = null, details = new Map(), documents = new Map();
@@ -96,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;
@@ -133,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,
@@ -218,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');
@@ -243,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;
@@ -371,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);