create-agdf 0.30.0 → 0.32.0

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

@@ -11,6 +11,7 @@ import {
 import { normalizeTaskTargetSource, TASK_TARGET_SOURCES } from "../task-target-resolution.js";
 import { SKILL_DISPATCH_MAX_OUTPUT_BYTES, SkillDispatchInputError, emptySkillDispatchTiming } from "../skill-dispatch/contract.js";
 import { ARTIFACT_READINESS_GATES, ALL_ACTIVE_OPERATIONS, VARIANT_OPERATION, MODULE_OPERATION, CONTROL_INSPECT_OPERATIONS, GATE_CHECK_VARIANTS, ReadSelectionError, validateReadSelection } from "./selection.js";
+import { CLOSEOUT_AUTHORING_SCOPE } from './selection.js';
 
 export const CONTROL_INSPECT_SCHEMA_VERSION = "1";
 export const CONTROL_INSPECT_CONTRACT_VERSION = 1;
@@ -29,6 +30,7 @@ function deepFreeze(value) {
 export const PRESENTATION_OPERATIONS = Object.freeze(['presentation-document', 'presentation-preview']);
 export const BOUND_INSPECT_OPERATIONS = Object.freeze(['artifact-readiness', 'authoring-inputs', 'operation-contract', 'operation-status', 'native-qualification', ...PRESENTATION_OPERATIONS, 'runtime-generations']);
 export const PRESENTATION_CATALOG_MODULE = 'agdf_prepare/presentation.prepare';
+const CLI_MODULE_HINTS = Object.freeze({ 'agdf_approve/run-approve': 'agdf_approve/approval.record' });
 const uuidSchema = { type: 'string', pattern: REVISION_ID_PATTERN.source };
 const cursorSchema = { type: 'string', maxLength: 80, pattern: '^[0-9a-f]{64}:(?:0|[1-9][0-9]{0,6})$' };
 const fieldModel = {
@@ -43,36 +45,46 @@ const fieldModel = {
   expected_revision_id: { help: 'Bound inspections use current gate-check revision. Document/preview reads preserve the original selected catalog or conversation revision.', schema: { $ref: '#/$defs/i' }, description: 'gate-check revision; original for reads.', operations: BOUND_INSPECT_OPERATIONS },
   presentation_id: { help: 'Exact prepared ID from validated catalog or conversation. Never guess, select by timestamp, or prepare a replacement to read.', schema: { $ref: '#/$defs/i' }, description: 'ID from catalog/conversation.', operations: PRESENTATION_OPERATIONS },
   target_id: { help: 'Optional confirmed target hash on target-bound reads; when supplied it must match. Required for presentation reads; never grants authority.', schema: { type: 'string', pattern: '^sha256:[0-9a-f]{64}$' }, description: 'Optional verified target hash.' },
+  bundle: { help: 'authoring-inputs only: bounded multi-document pages with exact source bytes.', schema: { type: 'boolean' }, operations: ['authoring-inputs'] },
+  authoring_scope: { help: 'Bundled authoring-inputs for a completed structured Run: read only its current OR and QA.', schema: { type: 'string', const: CLOSEOUT_AUTHORING_SCOPE }, operations: ['authoring-inputs'] },
   cursor: { help: 'Omit initially; copy next_cursor. doctor requires all_active; catalog requires its declared module. Never exchange cursor types.', schema: cursorSchema, description: 'Copy next_cursor.', operations: [...PRESENTATION_OPERATIONS, 'operation-contract', 'authoring-inputs', 'doctor'] },
   variant: { help: 'gate-check view only; never records approval.', schema: { enum: [...GATE_CHECK_VARIANTS] }, description: 'gate-check view.', operations: [VARIANT_OPERATION] },
   module: { help: 'contract: advertised module; operation-contract: group/kind; operation-status: original operation UUID from saved receipt, never a new UUID. Setup uses project.initialize/ORIGINAL_UUID without Run/revision; Run operations require Run/revision.', schema: { type: 'string', minLength: 1, maxLength: 64 }, description: 'Contract, group/kind or receipt UUID.', operations: [MODULE_OPERATION, 'operation-contract', 'operation-status'] },
   all_active: { help: 'true: doctor/delivery-map only; false: selected Run.', schema: { type: 'boolean' }, description: 'doctor/delivery-map only.' },
 };
-const selectorKeys = { gate: 'gate', expected_revision_id: 'expectedRevisionId', presentation_id: 'presentationId', target_id: 'targetId', cursor: 'cursor', variant: 'variant', module: 'contractModule', planning: 'planning' };
+const selectorKeys = { gate: 'gate', expected_revision_id: 'expectedRevisionId', presentation_id: 'presentationId', target_id: 'targetId', cursor: 'cursor', variant: 'variant', module: 'contractModule', planning: 'planning', bundle: 'bundle', authoring_scope: 'authoringScope' };
 const moduleOperations = [MODULE_OPERATION, 'operation-contract', 'operation-status'];
 const inputSchema = {
   type: 'object', additionalProperties: false,
   required: ['operation', 'presentation_language', 'working_directory'],
-  $defs: { i: uuidSchema, b: { not: { enum: CONTROL_INSPECT_OPERATIONS.filter(op => !BOUND_INSPECT_OPERATIONS.includes(op)) } }, d: { enum: PRESENTATION_OPERATIONS }, m: { enum: ['operation-contract', 'operation-status'] } },
+  $defs: {
+    i: uuidSchema,
+    b: { not: { enum: CONTROL_INSPECT_OPERATIONS.filter(op => !BOUND_INSPECT_OPERATIONS.includes(op)) } },
+    d: { enum: PRESENTATION_OPERATIONS },
+    m: { enum: ['operation-contract', 'operation-status'] },
+    u: { not: { anyOf: [{ required: ['run_id'] }, { required: ['expected_revision_id'] }] } },
+  },
   properties: Object.fromEntries(Object.entries(fieldModel).map(([name, field]) => [name, { ...field.schema, description: field.description }])),
   dependentRequired: { target_source: ['primary_target'], primary_target: ['target_source'], target_id: ['primary_target', 'target_source'] },
   dependentSchemas: Object.fromEntries(Object.entries(fieldModel).filter(([, f]) => f.operations).map(([name, field]) => [name,
-    name === 'cursor' ? { anyOf: [ { properties: { operation: { enum: [...PRESENTATION_OPERATIONS, 'authoring-inputs'] } } },
+    // Bundle selects authoring-inputs, whose Run binding requires an expected revision.
+    name === 'authoring_scope' ? { properties: { bundle: { const: true } }, required: ['bundle', 'run_id'] }
+      : name === 'cursor' ? { anyOf: [ { properties: { operation: { enum: [...PRESENTATION_OPERATIONS, 'authoring-inputs'] } } },
       { properties: { operation: { const: 'doctor' }, all_active: { const: true } }, required: ['all_active'] },
       { properties: { operation: { const: 'operation-contract' }, module: { const: PRESENTATION_CATALOG_MODULE } } } ] }
       : { properties: { operation: field.operations === BOUND_INSPECT_OPERATIONS ? { $ref: '#/$defs/b' }
         : field.operations === PRESENTATION_OPERATIONS ? { $ref: '#/$defs/d' } : name === 'module' ? { enum: moduleOperations } : { enum: field.operations } } },
   ])),
   allOf: [
-    { if: { properties: { operation: { enum: ['project-state', 'planned-inventory', 'planned-entry'] } } }, then: { required: ['target_source', 'primary_target'], not: { anyOf: [{ required: ['run_id'] }, { required: ['expected_revision_id'] }] } } },
+    { if: { properties: { operation: { enum: ['project-state', 'planned-inventory', 'planned-entry'] } } }, then: { required: ['target_source', 'primary_target'], $ref: '#/$defs/u' } },
     { if: { properties: { operation: { const: 'planned-entry' } } }, then: { required: ['planning'] } },
-    { if: { required: ['planning'] }, then: { required: ['target_source', 'primary_target'], not: { anyOf: [{ required: ['run_id'] }, { required: ['expected_revision_id'] }] } } },
+    { if: { required: ['planning'] }, then: { required: ['target_source', 'primary_target'], $ref: '#/$defs/u' } },
     { not: { properties: { all_active: { const: true } }, required: ['all_active', 'run_id'] } },
     { anyOf: [{ properties: { all_active: { const: false } } }, { properties: { operation: { enum: [...ALL_ACTIVE_OPERATIONS] } } }] },
     { if: { properties: { operation: { $ref: '#/$defs/m' } } }, then: { required: ['module'] } },
     { if: { properties: { operation: { $ref: '#/$defs/b' } } }, then: { required: ['target_source'], anyOf: [
       { required: ['run_id', 'expected_revision_id'] },
-      { not: { anyOf: [{ required: ['run_id'] }, { required: ['expected_revision_id'] }] }, oneOf: [
+      { $ref: '#/$defs/u', oneOf: [
         { properties: { operation: { const: 'operation-status' } } },
         { properties: { operation: { const: 'operation-contract' }, module: { anyOf: [{ enum: ['agdf_run/run.create', 'agdf_project/project.initialize'] }, { pattern: '/(?:planned_|run\\.create_from_planned)' }] } }, required: ['module'] },
         { properties: { operation: { const: 'authoring-inputs' } }, required: ['planning'] },
@@ -85,21 +97,17 @@ const inputSchema = {
 
 inputSchema.dependentSchemas.operation = { allOf: inputSchema.allOf };
 delete inputSchema.allOf;
-const conciseHelp = { target_source: 'Pair primary_target; explicit=named; continued=confirmed; current=unambiguous repo.', primary_target: 'Confirmed root; pair target_source.',
-  module: 'contract:index; operation-contract:group/kind; status:UUID.',
-  run_id: 'Not for inventory/project/planned.',
-  expected_revision_id: 'Bound reads only; not gate-check.',
-  planning: 'Planning reads only.',
-  target_id: 'Required for docs; gate-check.',
-  gate: 'Not for gate-check.' };
-for (const [key, field] of Object.entries(inputSchema.properties)) {
-  delete field.description;
-  if (conciseHelp[key]) field.description = conciseHelp[key];
-}
+// Full selector help is available on demand; discovery keeps the exact guards.
+for (const field of Object.values(inputSchema.properties)) delete field.description;
+Object.assign(inputSchema.properties.target_source, { description: 'Pair primary_target.' });
+Object.assign(inputSchema.properties.primary_target, { description: 'Confirmed target.' });
+Object.assign(inputSchema.properties.module, { description: 'Contract, group/kind or receipt UUID.' });
+Object.assign(inputSchema.properties.gate, { description: 'Not for gate-check.' });
+Object.assign(inputSchema.properties.target_id, { description: 'Required for docs; gate-check.' });
 
 const inspectContract = {
   name: "agdf_inspect",
-  description: 'Read-only. Ex:{"operation":"operation-contract","module":"agdf_run/run.create","working_directory":"/r","target_source":"explicit_target","primary_target":"/r"}. navigation.next_calls sequentially; read all pages; never dispatch. Setup status: project.initialize/UUID, no Run/revision. Run status: original UUID+run_id+expected_revision_id.',
+  description: 'Read only. Use next_action.call. Raw bound reads need working_directory,presentation_language,primary_target,target_source. Run status needs run_id+expected_revision_id. Setup omits both.',
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   inputSchema: projectMcpInputSchema(inputSchema),
   outputSchema: {
@@ -175,14 +183,42 @@ export function inspectContractHelp() {
   });
 }
 
+function correctedOperationModule(module) {
+  if (typeof module !== 'string' || module.length > 64 || OPERATION_CONTRACT_MODULES.includes(module)) return null;
+  const exact = CLI_MODULE_HINTS[module];
+  if (exact && OPERATION_CONTRACT_MODULES.includes(exact)) return exact;
+  const kind = module.split('/').at(-1);
+  const matches = OPERATION_CONTRACT_MODULES.filter(value => value.split('/').at(-1) === kind);
+  return matches.length === 1 ? matches[0] : null;
+}
+
+// A new read-only schema lookup for one unambiguous registered owner. This
+// preserves explicit bindings; it never executes or repairs the invalid request.
+export function inspectModuleRecoveryCall(input) {
+  if (!input || input.operation !== 'operation-contract') return null;
+  const module = correctedOperationModule(input.module);
+  const allowed = new Set(['operation', 'module', 'working_directory', 'primary_target', 'target_source',
+    'presentation_language', 'run_id', 'expected_revision_id', 'gate', 'target_id']);
+  if (!module || Object.keys(input).some(key => !allowed.has(key))) return null;
+  for (const key of ['working_directory', 'primary_target', 'target_source', 'run_id'])
+    if (!Object.hasOwn(input, key) || schemaDiagnostics(input[key], fieldModel[key].schema).length) return null;
+  if (!isAbsolute(input.working_directory) || !isAbsolute(input.primary_target)
+    || typeof input.expected_revision_id !== 'string' || !REVISION_ID_PATTERN.test(input.expected_revision_id)
+    || input.presentation_language !== undefined && schemaDiagnostics(input.presentation_language, fieldModel.presentation_language.schema).length
+    || input.gate !== undefined && !APPROVAL_GATES.includes(input.gate)
+    || input.target_id !== undefined && (typeof input.target_id !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(input.target_id))) return null;
+  return { tool: 'agdf_inspect', arguments: { ...input, module } };
+}
+
 export function inspectInputValidationHint(input) {
   if (!input || typeof input !== 'object' || !CONTROL_INSPECT_OPERATIONS.includes(input.operation)) return '';
   const operation = input.operation, messages = [];
+  let diagnosedModule = input.module;
   if (operation === 'operation-contract' && typeof input.module === 'string' && input.module.length <= 64
     && !OPERATION_CONTRACT_MODULES.includes(input.module)) {
-    const kind = input.module.split('/').at(-1);
-    const matches = OPERATION_CONTRACT_MODULES.filter(module => module.split('/').at(-1) === kind);
-    messages.push(matches.length === 1 ? `Use module ${matches[0]}; this is the registered owner of ${kind}.`
+    const correction = correctedOperationModule(input.module);
+    if (correction) diagnosedModule = correction; // Help only; the original invalid request remains rejected.
+    messages.push(correction ? `Use module ${correction}; the original module is invalid and was not executed.`
       : 'Read contract without module for the registered operation_modules; do not guess a group/kind.');
   }
   for (const [name, field] of Object.entries(fieldModel)) {
@@ -194,8 +230,8 @@ export function inspectInputValidationHint(input) {
   // Diagnose the selected operation, rather than making the model interpret
   // errors from every alternative of the discovery schema's oneOf branches.
   const unboundContract = operation === 'operation-contract' &&
-    (['agdf_run/run.create', 'agdf_project/project.initialize'].includes(input.module)
-      || OPERATION_CONTRACT_MODULES.includes(input.module) && /\/(?:planned_|run\.create_from_planned)/u.test(input.module));
+    (['agdf_run/run.create', 'agdf_project/project.initialize'].includes(diagnosedModule)
+      || OPERATION_CONTRACT_MODULES.includes(diagnosedModule) && /\/(?:planned_|run\.create_from_planned)/u.test(diagnosedModule));
   const bound = BOUND_INSPECT_OPERATIONS.includes(operation) && !unboundContract
     && !(operation === 'operation-status' && !input.run_id && !input.expected_revision_id)
     && !(operation === 'authoring-inputs' && input.planning);
@@ -254,6 +290,7 @@ export function parseControlInspectFunctionArguments(argumentsValue, trustedCont
 
 // Shared language, target and read-selection rules; errors carry the invalid field.
 export function normalizeControlInspectInput(input) {
+  if (input.bundle !== undefined && typeof input.bundle !== 'boolean') throw new SkillDispatchInputError('bundle', 'bundle must be boolean');
   const operation = requireText(input.operation, "operation", 64);
   if (!CONTROL_INSPECT_OPERATIONS.includes(operation)) throw new SkillDispatchInputError("operation", `Unsupported inspect operation: ${operation}`);
   let requestedPresentationLanguage;
@@ -276,6 +313,9 @@ export function normalizeControlInspectInput(input) {
     throw new SkillDispatchInputError('target_id', 'A valid target hash requires a confirmed target');
   const runId = input.runId || null;
   const planning = input.planning;
+  if (input.authoringScope !== undefined && (input.authoringScope !== CLOSEOUT_AUTHORING_SCOPE
+    || input.bundle !== true || !runId || planning !== undefined))
+    throw new SkillDispatchInputError('authoring_scope', 'Closeout scope requires a bundled Run read');
   if (planning !== undefined && (schemaDiagnostics(planning, PLANNING_SCOPE_SCHEMA).length || runId || input.expectedRevisionId !== undefined || input.gate !== undefined
     || !primaryTarget || !fieldModel.planning.operations.includes(operation))) throw new SkillDispatchInputError('planning', 'Planning requires one exact pre-Run source scope and confirmed target; no Run/revision/gate');
   if (operation === 'operation-status' && Boolean(planning) !== /^(?:planned_ur\.|run\.create_from_planned\/)/u.test(input.contractModule ?? ''))
@@ -336,7 +376,7 @@ export function normalizeControlInspectInput(input) {
     target_source: targetSource,
     primary_target: primaryTarget,
     run_id: runId,
-    planning,
+    planning, bundle: input.bundle, authoring_scope: input.authoringScope,
     gate: input.gate,
     expected_revision_id: input.expectedRevisionId,
     presentation_id: input.presentationId, target_id: input.targetId, cursor: input.cursor,

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/material-recording-calls.js

@@ -0,0 +1,54 @@
+import { resolveTaskTarget } from '../task-target-resolution.js';
+import { preparedCommandCall } from '../control-state/prepared-control-calls.js';
+import { inspectUxIntentDecision, UX_DECISION_FORMAT } from '../control-evaluation/definition-sources.js';
+import { validateRunCommand } from '../control-state/run-command-schema.js';
+import { inspectAuthoringInputs } from './authoring-inputs.js';
+
+// Mirrors an explicit author declaration; never chooses a judgement or review.
+export function withUxSourceDecision(form, content) {
+  const observed = inspectUxIntentDecision(content);
+  const source_validation = { ...observed, format: UX_DECISION_FORMAT, authorizes: false };
+  if (!observed.well_formed || !observed.supported || observed.decision === 'not_applicable') return {
+    source_validation: { ...source_validation, recordable: false,
+      reason: !observed.well_formed ? 'ux_decision_malformed' : 'ux_decision_not_supported_for_required_analysis',
+      instruction: 'Correct the explicit - decision: field in the authored report, then stage the corrected bytes with the new material_call. No canonical record was attempted; choose ready or blocked from actual analysis, never from this diagnostic.' } };
+  const filled = structuredClone(form);
+  filled.call.arguments.command.payload.decision = observed.decision;
+  filled.required_inputs = filled.required_inputs.filter(p => p !== '/command/payload/decision');
+  filled.state = validateRunCommand(filled.call.tool, filled.call.arguments).length ? 'requires_author_input' : 'ready';
+  return { form: filled, source_validation: { ...source_validation, recordable: true,
+    decision_origin: 'exact explicit author declaration in staged source; not generated judgement' } };
+}
+
+// Reuse the canonical author/source selection, including analytical prerequisites
+// at an outer gate. Transport itself cannot choose a future/protected writer.
+export function withMaterialRecordingCalls(input, result) {
+  if (result.outcome !== 'accepted' || input.planning || !['put', 'seal'].includes(input.command.payload.action)) return result;
+  try {
+    const target = resolveTaskTarget({ workingDirectory: input.working_directory, primaryTarget: input.primary_target, targetSource: input.target_source });
+    if (target.resolution_state !== 'resolved') return result;
+    const authoring = inspectAuthoringInputs(target.governance_target, input);
+    if (!authoring.available || authoring.revision_id !== input.expected_revision_id) return result;
+    const slot = authoring.material_call?.call.arguments.command.payload.files[0].slot;
+    const files = (result.family_result.files ?? []).filter(file => file.reference && file.slot === slot);
+    if (files.length !== 1 || !authoring.formats?.available) return result;
+    const { group, kind } = authoring.formats;
+    if (kind === 'closeout.record') {
+      if (!['structured_delivery', 'structured_slice'].includes(authoring.mode)
+          || authoring.next_operation?.type !== 'record_closeout' || authoring.authoring_owner !== 'OR' || slot !== 'OR') return result;
+    } else if (!['step.record', 'artefact.record', 'ur_draft.replace'].includes(kind)) return result;
+    const form = preparedCommandCall(group, kind, input,
+      { gate: authoring.authoring_owner, material: files[0].reference, recording: authoring.recording });
+    if (kind === 'closeout.record' && form?.state !== 'ready') return result;
+    if (form && authoring.authoring_owner === 'UX Intent Definition' && input.command.payload.action === 'put') {
+      const text = input.command.payload.files.find(file => file.slot === slot)?.content;
+      if (typeof text === 'string') {
+        const checked = withUxSourceDecision(form, text);
+        return { ...result, source_validation: checked.source_validation,
+          ...(checked.form ? { recording_calls: [{ slot, ...checked.form }] }
+            : { recording_calls: [], material_call: authoring.material_call }) };
+      }
+    }
+    return form && !form.required_inputs.includes('/command/payload') ? { ...result, recording_calls: [{ slot, ...form }] } : result;
+  } catch { return result; } // Guidance cannot conceal an accepted private transfer.
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/project-state.js

@@ -37,7 +37,8 @@ export function inspectProjectState(root, input, gitObservation) {
       ? projectOperationStatusCall({ ...input, operation_id: original }) : null;
     const report = { available: true, target_id, repository, plan: inspectCanonicalInitializationPlan(), ...state,
       setup: { tool: 'agdf_project', kind: 'project.initialize', binding: { schema_version: '1', assurance: 'cooperative_local', ...common, target_id },
-        required_agent_fields: ['operation_id'], requires_explicit_intent: true }, next_calls: [...(next ? [next] : []), ...(statusCall ? [statusCall] : [])],
+        required_agent_fields: ['operation_id'], requires_explicit_intent: true }, next_calls: next ? [next] : [],
+      ...(statusCall ? { recovery_only: { status_call: statusCall, authorizes: false } } : {}),
       ...(input.operation === 'operation-status' ? { operation_id: input.operation_id, status: state.operation_status, current_setup: state.status } : {}),
       ...(state.status === 'pending' ? { recovery: { action: 'replay_original', operation_id: state.operation.operation_id,
         request_digest: state.operation.request_digest, instruction: 'Replay only the saved original project.initialize UUID/payload. Owned stage, target, plan and producer are revalidated before any effect.', authorizes: false } } : {}),

package/generated/plugins/copilot/agdf/runtime/create-agdf/runtime/core/lib/control-inspect/run-classification.js

@@ -0,0 +1,31 @@
+// Read-only run classification shared by the Codex cockpit and the companion run view (companion core
+// SDD-001, SDD-003). It lives apart from the cockpit so every runtime profile carries it, Copilot
+// included, whose projection leaves the private cockpit out. Nothing here evaluates a gate rule.
+import { ENDED_LIFECYCLES } from '../control-state/run-operations.js';
+
+// The read-failure codes passed through unchanged, and every code `boundedCode` can return.
+const READ_FAILURE_CODES = Object.freeze(['resource_denied', 'source_changed', 'timeout', 'resource_limit', 'read_failed']);
+export const BOUNDED_READ_CODES = Object.freeze(['control_layout_unsupported', 'run_version_unsupported', 'control_invalid', ...READ_FAILURE_CODES]);
+
+// Bounded reason code of a read failure.
+export function boundedCode(error) {
+  const code = error.code ?? error.message;
+  if (code === 'AGDF_CONTROL_LAYOUT_UNSUPPORTED' || code === 'control_layout_unsupported') return 'control_layout_unsupported';
+  if (code === 'AGDF_RUN_VERSION_UNSUPPORTED') return 'run_version_unsupported';
+  // The configuration owner's codes (resources/configuration.js configurationError).
+  if (code === 'AGDF_CONTROL_LAYOUT_INVALID' || code === 'configuration_invalid') return 'control_invalid';
+  return READ_FAILURE_CODES.includes(error.code) ? error.code : 'read_failed';
+}
+
+// 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 };
+}

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

@@ -2,6 +2,12 @@
 
 export const ARTIFACT_READINESS_GATES = Object.freeze(['UR', 'PRD', 'SD', 'TP']);
 export const CONTROL_INSPECT_OPERATIONS = Object.freeze(["doctor", "gate-check", "delivery-map", "contract", "artifact-readiness", "authoring-inputs", "operation-contract", "operation-status", "native-qualification", "presentation-document", "presentation-preview", "runtime-generations", "project-state", "inventory", "planned-inventory", "planned-entry"]);
+export const CLOSEOUT_AUTHORING_SCOPE = 'delivery-closeout';
+
+export function isCompletedStructuredCloseout(control, mode) {
+  return control.current_gate === 'OR' && control.completion?.fulfilled === true
+    && ['structured_delivery', 'structured_slice'].includes(mode);
+}
 export const ALL_ACTIVE_OPERATIONS = Object.freeze(["doctor", "delivery-map"]);
 export const VARIANT_OPERATION = "gate-check";
 export const MODULE_OPERATION = "contract";