create-agdf 0.20.2 → 0.31.0

package/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,18 @@ 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 } from '../control-state/run-operations.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']]);
@@ -25,32 +34,24 @@ 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) {
-  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;
-
-// 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'
-    : 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 };
+// 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 };
 }
 
+
 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 +118,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 +174,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 +233,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 +250,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 +276,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 +288,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 +355,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);

package/runtime/core/lib/control-inspect/contract.js

@@ -1,7 +1,7 @@
+import { projectMcpInputSchema } from '../mcp-input-schema.js';
 import { isAbsolute } from "node:path";
 import { RUN_ID_PATTERN, REVISION_ID_PATTERN } from "../control-state/run-identity.js";
-import { ARTIFACT_READINESS_GATES } from "./artifact-readiness.js";
-import { RUN_COMMAND_GROUPS } from '../control-state/run-command-contract.js';
+import { RUN_COMMAND_GROUPS, PLANNING_COMMAND_KINDS, PLANNING_SCOPE_SCHEMA, schemaDiagnostics } from '../control-state/run-command-schema.js';
 import { APPROVAL_GATES } from '../control-state/run-identity.js';
 import {
   PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE,
@@ -10,12 +10,13 @@ import {
 } from "../interaction-presentation.js";
 import { normalizeTaskTargetSource, TASK_TARGET_SOURCES } from "../task-target-resolution.js";
 import { SKILL_DISPATCH_MAX_OUTPUT_BYTES, SkillDispatchInputError, emptySkillDispatchTiming } from "../skill-dispatch/contract.js";
-import { ALL_ACTIVE_OPERATIONS, VARIANT_OPERATION, MODULE_OPERATION, CONTROL_INSPECT_OPERATIONS, GATE_CHECK_VARIANTS, ReadSelectionError, validateReadSelection } from "./selection.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;
 // Shared discovery budget across hosts (SDD-005).
-export const CONTROL_INSPECT_MAX_DEFINITION_BYTES = 5000;
+export const CONTROL_INSPECT_MAX_DEFINITION_BYTES = 6144;
 export const OPERATION_CONTRACT_MODULES = Object.freeze(Object.entries(RUN_COMMAND_GROUPS)
   .flatMap(([group, kinds]) => kinds.map(kind => `${group}/${kind}`)));
 
@@ -27,44 +28,68 @@ function deepFreeze(value) {
 
 // Shared discovery, selector guards and on-demand help.
 export const PRESENTATION_OPERATIONS = Object.freeze(['presentation-document', 'presentation-preview']);
-export const BOUND_INSPECT_OPERATIONS = Object.freeze(['artifact-readiness', 'operation-contract', 'operation-status', 'native-qualification', ...PRESENTATION_OPERATIONS, 'runtime-generations']);
+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 = {
   operation: { help: 'Read only; never prepare or approve.', schema: { enum: [...CONTROL_INSPECT_OPERATIONS] }, description: 'Read action.' },
-  presentation_language: { help: 'Required BCP47 tag; unsupported valid languages fall back to complete English.', schema: { type: 'string', maxLength: 64, pattern: PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE }, description: 'Reply BCP47 tag.' },
+  presentation_language: { help: 'Optional MCP override of configured chat language; valid unsupported tags use complete English.', schema: { type: 'string', maxLength: 64, pattern: PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE }, description: 'Reply BCP47 tag.' },
   working_directory: { help: 'Absolute context; never selects a target.', schema: { type: 'string', minLength: 1, maxLength: 4096 }, description: 'Context; not target authority.' },
   target_source: { help: 'Actual provenance: explicit_target = specified; continued_target = confirmed; current_repository = unambiguous.', schema: { enum: [...TASK_TARGET_SOURCES] }, description: 'Requires primary_target.' },
   primary_target: { help: 'Confirmed absolute root paired with target_source; cwd is not target authority.', schema: { type: 'string', minLength: 1, maxLength: 4096 }, description: 'Pair: target_source.' },
   run_id: { help: 'Named or confirmed Run; never select by recency.', schema: { type: 'string', pattern: RUN_ID_PATTERN.source }, description: 'Confirmed run.' },
-  gate: { help: 'Requested document gate or catalog filter, never a selection heuristic. artifact-readiness: UR/PRD/SD/TP only.', schema: { enum: [...APPROVAL_GATES] }, description: 'Document gate. Never with gate-check.', operations: ['artifact-readiness', 'operation-contract', ...PRESENTATION_OPERATIONS] },
+  planning: { help: 'Selected pre-Run plan and canonical source digest; null digest is permitted for initial capture/inspection. Never combine with Run/revision.', schema: PLANNING_SCOPE_SCHEMA, description: 'Pre-Run source scope.', operations: ['authoring-inputs', 'planned-entry', 'operation-status'] },
+  gate: { help: 'Requested document gate or catalog filter, never a selection heuristic. artifact-readiness: UR/PRD/SD/TP only.', schema: { enum: [...APPROVAL_GATES] }, description: 'Document gate.', operations: ['artifact-readiness', 'operation-contract', ...PRESENTATION_OPERATIONS] },
   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: 'Copy target hash from operation-contract binding or catalog read_arguments; never grants authority.', schema: { type: 'string', pattern: '^sha256:[0-9a-f]{64}$' }, description: 'Target hash: operation-contract.', operations: PRESENTATION_OPERATIONS },
-  cursor: { help: 'Omit initially; copy next_cursor. Catalog cursors: only operation-contract module=agdf_prepare/presentation.prepare. Never exchange cursor types.', schema: cursorSchema, description: 'Copy next_cursor.', operations: [...PRESENTATION_OPERATIONS, 'operation-contract'] },
+  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.', 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: 'All runs: doctor/delivery-map.' },
+  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' };
+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: moduleOperations } },
+  $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'] },
+  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: { $ref: '#/$defs/d' } } },
+    // 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' ? { $ref: '#/$defs/m' } : { enum: field.operations } } },
+        : 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'], $ref: '#/$defs/u' } },
+    { if: { properties: { operation: { const: 'planned-entry' } } }, then: { required: ['planning'] } },
+    { 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: ['run_id', 'expected_revision_id', 'target_source'] } },
+    { if: { properties: { operation: { $ref: '#/$defs/b' } } }, then: { required: ['target_source'], anyOf: [
+      { required: ['run_id', 'expected_revision_id'] },
+      { $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'] },
+      ] },
+    ] } },
     { if: { properties: { operation: { const: 'artifact-readiness' } } }, then: { required: ['gate'], properties: { gate: { enum: [...ARTIFACT_READINESS_GATES] } } } },
     { if: { properties: { operation: { $ref: '#/$defs/d' } } }, then: { required: ['gate', 'presentation_id', 'target_id'] } },
   ],
@@ -72,12 +97,19 @@ const inputSchema = {
 
 inputSchema.dependentSchemas.operation = { allOf: inputSchema.allOf };
 delete inputSchema.allOf;
+// 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. gate-check: language, cwd, target_source+primary_target, Run; omit gate/module. Follow navigation.next_calls sequentially; read all pages.",
+  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,
+  inputSchema: projectMcpInputSchema(inputSchema),
   outputSchema: {
     type: 'object', required: ['outcome', 'terminal', 'authorizes', 'operation', 'report', 'presentation', 'host_action', 'target', 'recovery'],
     properties: {
@@ -112,7 +144,7 @@ export const CONTROL_INSPECT_OUTPUT_SCHEMA = deepFreeze(inspectContract.outputSc
 export const CONTROL_INSPECT_FUNCTION_DEFINITION = deepFreeze({
   ...inspectContract,
   outputSchema: { type: 'object', required: inspectContract.outputSchema.required,
-    properties: { ...Object.fromEntries(Object.entries(inspectContract.outputSchema.properties).filter(([key]) => key !== 'report').map(([key, value]) => [key, key === 'recovery' ? { required: value.required, properties: value.properties } : value])),
+    properties: { authorizes: { const: false },
       outcome: { enum: ['inspect_result', 'target_unresolved', 'invalid_input', 'evaluator_error'] },
     },
     if: { properties: { outcome: { const: 'inspect_result' } } },
@@ -123,23 +155,98 @@ export const CONTROL_INSPECT_FUNCTION_DEFINITION = deepFreeze({
 
 export function inspectContractHelp() {
   const base = { presentation_language: 'de', working_directory: '/workspace/project', target_source: 'explicit_target', primary_target: '/workspace/project', run_id: 'demo-run-01' };
+  const { run_id: _exampleRun, ...projectBase } = base;
   const revision = '00000000-0000-4000-8000-000000000001';
   return deepFreeze({ schema_version: '1', authorizes: false,
+    input_completion: 'MCP inherits matching configured language. Current native adapters require explicit working_directory; private trustworthy task context alone may supply it. Bindings remain explicit.',
     parameters: Object.fromEntries(Object.entries(fieldModel).map(([key, field]) => [key, { description: field.help ?? field.description, operations: field.operations ?? [...CONTROL_INSPECT_OPERATIONS] }])),
     operations: Object.fromEntries(CONTROL_INSPECT_OPERATIONS.map(operation => [operation, {
-      required: [...inputSchema.required, ...(BOUND_INSPECT_OPERATIONS.includes(operation) ? ['run_id', 'expected_revision_id', 'target_source', 'primary_target'] : []),
-        ...(['contract', 'operation-contract', 'operation-status'].includes(operation) ? ['module'] : []),
+      required: [...CONTROL_INSPECT_FUNCTION_DEFINITION.inputSchema.required, ...(BOUND_INSPECT_OPERATIONS.includes(operation) ? ['run_id', 'expected_revision_id', 'target_source', 'primary_target'] : []),
+        ...(['operation-contract', 'operation-status'].includes(operation) ? ['module'] : []),
         ...(operation === 'artifact-readiness' ? ['gate'] : PRESENTATION_OPERATIONS.includes(operation) ? ['gate', 'presentation_id', 'target_id'] : [])],
+      omit: [...Object.entries(fieldModel).filter(([, field]) => field.operations && !field.operations.includes(operation)).map(([name]) => name),
+        ...(['inventory', 'planned-inventory', 'planned-entry', 'project-state'].includes(operation) ? ['run_id'] : [])],
+      ...(['operation-contract', 'operation-status'].includes(operation) ? { unbound: {
+        module: operation === 'operation-contract' ? 'agdf_run/run.create' : 'project.initialize/original-UUID or original run.create UUID',
+        required: [...CONTROL_INSPECT_FUNCTION_DEFINITION.inputSchema.required, 'target_source', 'primary_target', 'module'],
+        omit: ['run_id', 'expected_revision_id'],
+      } } : {}),
     }])),
     examples_are_illustrative: true,
     examples: [ { ...base, operation: 'gate-check' },
       { ...base, operation: 'operation-contract', module: PRESENTATION_CATALOG_MODULE, expected_revision_id: revision, gate: 'UR' },
-      { ...base, operation: 'presentation-document', expected_revision_id: revision, gate: 'UR', presentation_id: '00000000-0000-4000-8000-000000000002', target_id: `sha256:${'0'.repeat(64)}` } ],
+      { ...base, operation: 'presentation-document', expected_revision_id: revision, gate: 'UR', presentation_id: '00000000-0000-4000-8000-000000000002', target_id: `sha256:${'0'.repeat(64)}` },
+      { ...projectBase, operation: 'project-state' },
+      { ...projectBase, operation: 'operation-status', module: `project.initialize/${revision}` } ],
     provenance: 'Preserve exact conversation bindings; otherwise require unique complete catalog discovery or explicit selection. Reads keep original revisions. Prepared proves neither viewing nor approval. Catalog cursors require the catalog module.',
     catalog_limits: { page_candidates: 16, record_files: 256, record_bytes: 1048576, directory_entries: 1024 },
   });
 }
 
+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 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)) {
+    if (Object.hasOwn(input, name) && field.operations && !field.operations.includes(operation))
+      messages.push(`Remove ${name} for ${operation}.`);
+  }
+  if (input.run_id && ['inventory', 'project-state', 'planned-inventory', 'planned-entry'].includes(operation))
+    messages.push(`Remove run_id for ${operation}; it reads the target scope.`);
+  // 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(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);
+  const required = [...(['operation-contract', 'operation-status'].includes(operation) ? ['module'] : []),
+    ...(bound ? ['run_id', 'expected_revision_id'] : []),
+    ...(BOUND_INSPECT_OPERATIONS.includes(operation) || ['project-state', 'planned-inventory', 'planned-entry'].includes(operation)
+      ? ['primary_target', 'target_source'] : []),
+    ...(PRESENTATION_OPERATIONS.includes(operation) ? ['gate', 'presentation_id', 'target_id'] : [])];
+  for (const key of required) if (!Object.hasOwn(input, key)) messages.push(`Supply ${key} for ${operation}.`);
+  if (PRESENTATION_OPERATIONS.includes(operation)) messages.push('Copy the exact agdf_inspect arguments from presentation.prepare next_calls or the presentation catalog.');
+  if (bound && (!input.run_id || !input.expected_revision_id))
+    messages.push('Read gate-check with the confirmed target and run_id to inspect the current binding; never silently replace a requested revision.');
+  return messages.join(' ').slice(0, 768);
+}
+
 export function controlInspectDefinitionBytes(definition = CONTROL_INSPECT_FUNCTION_DEFINITION) {
   return Buffer.byteLength(JSON.stringify(definition), "utf8");
 }
@@ -183,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;
@@ -201,19 +309,40 @@ export function normalizeControlInspectInput(input) {
   if (Boolean(rawTargetSource) !== Boolean(primaryTarget)) throw new SkillDispatchInputError("primary_target", "target_source and primary_target must be supplied together");
   if (primaryTarget && (!isAbsolute(primaryTarget) || primaryTarget.length > 4096)) throw new SkillDispatchInputError("primary_target", "primary_target must be an absolute bounded path");
   const targetSource = rawTargetSource ? normalizeTaskTargetSource(rawTargetSource, { allowEmpty: false }) : null;
+  if (input.targetId !== undefined && (!primaryTarget || !/^sha256:[0-9a-f]{64}$/u.test(input.targetId)))
+    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 ?? ''))
+    throw new SkillDispatchInputError('planning', 'Pre-Run planning status needs its original operation kind/UUID and planning scope');
   if (runId && !RUN_ID_PATTERN.test(runId)) throw new SkillDispatchInputError("run_id", "run_id is invalid");
-  if (operation === "artifact-readiness") {
+  if (runId && input.allActive === true) throw new SkillDispatchInputError('all_active', 'All-active and selected Run scopes cannot be combined');
+  if (operation === 'planned-inventory' || operation === 'planned-entry' || operation === 'authoring-inputs' && planning) {
+    if (!primaryTarget || runId || input.expectedRevisionId !== undefined || input.gate !== undefined || operation !== 'planned-inventory' && !planning)
+      throw new SkillDispatchInputError('planning', 'A confirmed target and planning scope are required; inventory needs only the target');
+  } else if (operation === 'project-state') {
+    if (!primaryTarget || runId || input.expectedRevisionId !== undefined || input.gate !== undefined) throw new SkillDispatchInputError('binding', 'Project state requires only the confirmed target, no Run/revision');
+  } else if (operation === "artifact-readiness") {
     if (!runId) throw new SkillDispatchInputError("run_id", "artifact-readiness requires an explicit run_id");
     if (!primaryTarget) throw new SkillDispatchInputError("primary_target", "artifact-readiness requires an explicit target binding");
     if (!ARTIFACT_READINESS_GATES.includes(input.gate)) throw new SkillDispatchInputError("gate", "Unsupported draft gate");
     if (!REVISION_ID_PATTERN.test(input.expectedRevisionId ?? "")) throw new SkillDispatchInputError("expected_revision_id", "A valid expected revision is required");
   } else if (BOUND_INSPECT_OPERATIONS.includes(operation)) {
-    if (!runId || !primaryTarget || !REVISION_ID_PATTERN.test(input.expectedRevisionId ?? '')) throw new SkillDispatchInputError('binding', 'An exact target, Run and expected revision binding is required');
+    const creation = !runId && input.expectedRevisionId === undefined && (operation === 'operation-status'
+      || operation === 'operation-contract' && (['agdf_run/run.create', 'agdf_project/project.initialize'].includes(input.contractModule) || input.contractModule?.startsWith('agdf_project/planned_layout.')
+        || PLANNING_COMMAND_KINDS.includes(input.contractModule?.split('/')[1])));
+    if (!primaryTarget || !creation && (!runId || !REVISION_ID_PATTERN.test(input.expectedRevisionId ?? ''))) throw new SkillDispatchInputError('binding', 'An exact target, Run and expected revision binding is required; creation lookup uses target/original UUID');
     if (operation === 'operation-contract' && !OPERATION_CONTRACT_MODULES.includes(input.contractModule)) {
       throw new SkillDispatchInputError('module', 'Unsupported command group/operation module', { allowedValues: OPERATION_CONTRACT_MODULES });
     }
-    if (operation === 'operation-status' && !REVISION_ID_PATTERN.test(input.contractModule ?? '')) throw new SkillDispatchInputError('operation_id', 'An original operation UUID is required');
+    if (operation === 'operation-status' && !(REVISION_ID_PATTERN.test(input.contractModule ?? '')
+      || !runId && /^(?:project\.initialize|planned_layout\.apply|planned_ur\.(?:create|replace)|run\.create_from_planned)\/[0-9a-f-]{36}$/u.test(input.contractModule ?? '')
+        && REVISION_ID_PATTERN.test(input.contractModule.split('/')[1]))) throw new SkillDispatchInputError('operation_id', 'An original operation UUID is required');
     if (input.gate !== undefined && (!['operation-contract', 'presentation-document', 'presentation-preview'].includes(operation) || !APPROVAL_GATES.includes(input.gate))) throw new SkillDispatchInputError('gate', 'Unsupported operation gate');
   } else if (input.gate !== undefined || input.expectedRevisionId !== undefined) {
     throw new SkillDispatchInputError("gate", "Draft binding fields are supported only by artifact-readiness");
@@ -222,7 +351,7 @@ export function normalizeControlInspectInput(input) {
     if (!APPROVAL_GATES.includes(input.gate) || !REVISION_ID_PATTERN.test(input.presentationId ?? '')
       || !/^sha256:[0-9a-f]{64}$/u.test(input.targetId ?? '')
       || input.cursor !== undefined && !/^[0-9a-f]{64}:(?:0|[1-9][0-9]{0,6})$/u.test(input.cursor)) throw new SkillDispatchInputError('presentation', 'An exact presentation binding and bounded cursor are required');
-  } else if (input.presentationId !== undefined || input.targetId !== undefined || input.cursor !== undefined && !(operation === 'operation-contract' && input.contractModule === PRESENTATION_CATALOG_MODULE && new RegExp(cursorSchema.pattern, 'u').test(input.cursor) && typeof input.cursor === 'string' && input.cursor.length <= cursorSchema.maxLength)) {
+  } else if (input.presentationId !== undefined || input.cursor !== undefined && !((operation === 'authoring-inputs' || operation === 'doctor' && input.allActive === true || operation === 'operation-contract' && input.contractModule === PRESENTATION_CATALOG_MODULE) && new RegExp(cursorSchema.pattern, 'u').test(input.cursor) && typeof input.cursor === 'string' && input.cursor.length <= cursorSchema.maxLength)) {
     throw new SkillDispatchInputError('presentation', 'Document selectors require presentation-document');
   }
   if (input.allActive !== undefined && typeof input.allActive !== "boolean") throw new SkillDispatchInputError("all_active", "all_active is invalid");
@@ -231,11 +360,12 @@ export function normalizeControlInspectInput(input) {
   validateReadSelection({
     operation,
     allActive: input.allActive === true,
-    contractModule: input.contractModule,
+    contractModule: input.contractModule, allowContractIndex: true,
     variant: input.variant,
+    runId,
   });
   for (const [field, key] of Object.entries(selectorKeys)) {
-    if (input[key] !== undefined && !fieldModel[field].operations.includes(operation)) throw new SkillDispatchInputError(field, `Unsupported selector for ${operation}`);
+    if (input[key] !== undefined && !(fieldModel[field].operations ?? CONTROL_INSPECT_OPERATIONS).includes(operation)) throw new SkillDispatchInputError(field, `Unsupported selector for ${operation}`);
   }
   return Object.freeze({
     schema_version: CONTROL_INSPECT_SCHEMA_VERSION,
@@ -246,11 +376,12 @@ export function normalizeControlInspectInput(input) {
     target_source: targetSource,
     primary_target: primaryTarget,
     run_id: runId,
+    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,
     group: operation === 'operation-contract' ? input.contractModule.split('/')[0] : undefined,
-    kind: operation === 'operation-contract' ? input.contractModule.split('/')[1] : undefined, operation_id: operation === 'operation-status' ? input.contractModule : undefined,
+    kind: operation === 'operation-contract' ? input.contractModule.split('/')[1] : undefined, operation_id: operation === 'operation-status' ? input.contractModule.split('/').at(-1) : undefined,
     variant: input.variant,
     contract_module: input.contractModule,
     all_active: input.allActive === true,
@@ -263,8 +394,9 @@ export { ReadSelectionError };
 export const CONTROL_INSPECT_OUTPUT_TOO_LARGE_RECOVERY = "The inspect result exceeds the 1 MiB MCP output limit. Narrow the selection (one run_id instead of all_active) or use the CLI with --json.";
 
 // Preserve the result envelope when enforcing the shared 1 MiB output ceiling.
-export function serializeControlInspectResult(result) {
-  const output = JSON.stringify(result, null, 2);
+// space 0 is the compact transport form; the CLI keeps its indented output.
+export function serializeControlInspectResult(result, { space = 2 } = {}) {
+  const output = JSON.stringify(result, null, space);
   if (Buffer.byteLength(output, "utf8") <= SKILL_DISPATCH_MAX_OUTPUT_BYTES) return output;
   return JSON.stringify({
     schema_version: CONTROL_INSPECT_SCHEMA_VERSION,