create-agdf 0.20.2 → 0.30.0

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/shared-value.js

@@ -0,0 +1,7 @@
+export function isPlaceholderValue(value) {
+  return !value || (value.startsWith("`") && value.includes("|"));
+}
+
+export function filled(value) {
+  return Boolean(value && !isPlaceholderValue(value) && value.trim() !== "");
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/shared.js

@@ -1,6 +1,7 @@
+export { filled, isPlaceholderValue } from "./shared-value.js";
+import { filled, isPlaceholderValue } from "./shared-value.js";
 import { existsSync, readFileSync } from "../control-read/fs.js";
-import { join, posix } from "node:path";
-import { SUMMARY_LABELS } from "./backlog-vocabulary.js";
+import { join } from "node:path";
 
 export function cleanStatusCell(value) {
   return (value ?? "").replace(/\x60/g, "").trim();
@@ -42,261 +43,13 @@ export function tableRows(content) {
     });
 }
 
-const compactBacklogHeaders = ["priority", "key", "work item", "status", "artefacts", "current spec", "next step"];
-const legacyBacklogHeaders = ["prio", "key", "title", "status", "ur", "brownfield review", "prd", "sd", "tp", "qa", "or", "current spec", "notes"];
-const backlogStatusLabels = new Map([
-  ...Object.entries(SUMMARY_LABELS).map(([code, labels]) => [labels[0].toLowerCase(), code]),
-  ...["Brownfield Analysis", "CD+Tests", "CR", "Quick Task Execution", "Verified Change Execution", "Mode/Slice Decision"]
-    .map(phase => [`${phase.toLowerCase()} work pending`, "work_pending"]),
-  ["needs ur", "needs_ur"],
-  ["awaiting brownfield review", "awaiting_brownfield_review"],
-  ["awaiting prd", "awaiting_prd"],
-  ["awaiting prd approval", "awaiting_prd_approval"],
-  ["awaiting sd", "awaiting_sd"],
-  ["awaiting sd approval", "awaiting_sd_approval"],
-  ["awaiting tp", "awaiting_tp"],
-  ["awaiting tp approval", "awaiting_tp_approval"],
-  ["in progress", "in_progress"],
-  ["blocked", "blocked"],
-  ["awaiting qa", "awaiting_qa"],
-  ["awaiting uat", "awaiting_uat"],
-  ["awaiting or", "awaiting_or"],
-  ["completed", "completed"],
-  ["superseded", "superseded"],
-  ["abandoned", "abandoned"],
-]);
-const backlogArtefactLabels = new Map([
-  ["ur", "ur"],
-  ["brownfield", "brownfield_review"],
-  ["prd", "prd"],
-  ["sd", "sd"],
-  ["tp", "tp"],
-  ["qa", "qa"],
-  ["or", "or"],
-]);
-const backlogScopeLabels = new Map([
-  ["framework-maintenance", "framework_maintenance"],
-  ["external-delivery", "external_delivery"],
-]);
-
-export function normalizeBacklogHeader(value) {
-  return value.replace(/`/g, "").trim().toLowerCase();
-}
-
-export function markdownLink(value) {
-  const match = value.trim().match(/^\[([^\]]+)\]\(([^)]+)\)$/);
-  return match ? { label: match[1].trim(), target: match[2].trim() } : null;
-}
-
-export function resolvedBacklogLinkTarget(target) {
-  if (!target
-    || target.startsWith("/")
-    || target.includes("\\")
-    || /^[a-z][a-z0-9+.-]*:/i.test(target)) {
-    return null;
-  }
-  const resolved = posix.normalize(posix.join(".agdf/control", target));
-  if (resolved === ".." || resolved.startsWith("../")) return null;
-  return resolved;
-}
-
-export function normalizedBacklogLinkTarget(value, findings, backlogPath, label) {
-  const link = markdownLink(value);
-  if (!link) return value.trim();
-  const resolved = resolvedBacklogLinkTarget(link.target);
-  if (!resolved) {
-    if (findings) {
-      addFinding(
-        findings,
-        "revise",
-        "AGDF_BACKLOG_LINK_TARGET_INVALID",
-        `Backlog ${label} link must be relative to MASTER_BACKLOG.md: ${link.target || "<empty>"}.`,
-        backlogPath,
-        "Use a document-relative artefact target such as artefacts/<key>/UR.md.",
-      );
-    }
-    return link.target;
-  }
-  return resolved;
-}
-
-export function normalizeBacklogStatus(value, findings, backlogPath) {
-  const cleaned = cleanStatusCell(value ?? "");
-  const lookup = cleaned.replaceAll("_", " ").toLowerCase();
-  const normalized = backlogStatusLabels.get(lookup);
-  if (normalized) return normalized;
-  if (/^[a-z][a-z0-9_]*$/.test(cleaned)) return cleaned;
-  if (findings && filled(cleaned)) {
-    addFinding(
-      findings,
-      "revise",
-      "AGDF_BACKLOG_STATUS_UNKNOWN",
-      `MASTER_BACKLOG.md uses an unknown human status label: ${cleaned}.`,
-      backlogPath,
-      "Use a documented human status label or a supported legacy snake_case value.",
-    );
-  }
-  return cleaned;
-}
-
-export function normalizeBacklogScope(workItem, findings, backlogPath) {
-  const match = (workItem ?? "").match(/^\[([^\]]+)\]/);
-  if (!match) return undefined;
-  const cleaned = match[1].trim();
-  const lookup = cleaned.replaceAll("_", " ").toLowerCase().replaceAll(" ", "-");
-  const normalized = backlogScopeLabels.get(lookup);
-  if (normalized) return normalized;
-  if (findings) {
-    addFinding(
-      findings,
-      "revise",
-      "AGDF_BACKLOG_SCOPE_LABEL_UNKNOWN",
-      `MASTER_BACKLOG.md uses an unknown Work item scope tag: [${cleaned}].`,
-      backlogPath,
-      "Use [framework-maintenance] or [external-delivery], or remove the bracketed tag.",
-    );
-  }
-  return cleaned;
-}
-
-export function emptyBacklogPointer() {
-  return {
-    prio: "",
-    key: "",
-    title: "",
-    scope: "",
-    status: "",
-    ur: "",
-    brownfield_review: "",
-    prd: "",
-    sd: "",
-    tp: "",
-    qa: "",
-    or: "",
-    current_spec: "",
-    notes: "",
-  };
-}
-
-export function parseCompactArtefacts(value, pointer, findings, backlogPath) {
-  if (!filled(value)) return;
-  const seen = new Set();
-  for (const entry of value.split(/\s+·\s+/)) {
-    const link = markdownLink(entry);
-    if (!link) {
-      if (findings) {
-        addFinding(
-          findings,
-          "revise",
-          "AGDF_BACKLOG_ARTEFACT_LINK_INVALID",
-          `Compact Artefacts entry is not a Markdown link: ${entry}.`,
-          backlogPath,
-          "Use [UR](artefacts/<key>/UR.md) style links separated by a middle dot.",
-        );
-      }
-      continue;
-    }
-    const field = backlogArtefactLabels.get(link.label.toLowerCase());
-    if (!field) {
-      if (findings) {
-        addFinding(
-          findings,
-          "revise",
-          "AGDF_BACKLOG_ARTEFACT_LABEL_UNKNOWN",
-          `Compact Artefacts uses an unknown label: ${link.label}.`,
-          backlogPath,
-          "Use UR, Brownfield, PRD, SD, TP, QA or OR.",
-        );
-      }
-      continue;
-    }
-    if (seen.has(field)) {
-      if (findings) {
-        addFinding(
-          findings,
-          "revise",
-          "AGDF_BACKLOG_ARTEFACT_LABEL_DUPLICATE",
-          `Compact Artefacts repeats the ${link.label} link.`,
-          backlogPath,
-          "Keep exactly one link per artefact type.",
-        );
-      }
-      continue;
-    }
-    seen.add(field);
-    pointer[field] = normalizedBacklogLinkTarget(entry, findings, backlogPath, link.label);
-  }
-}
-
-export function parseBacklogSection(section, findings = null, backlogPath = ".agdf/control/MASTER_BACKLOG.md") {
-  const rows = tableRows(section);
-  if (rows.length === 0) return [];
-  const headers = rows[0].map(normalizeBacklogHeader);
-  const layout = headers.join("|") === compactBacklogHeaders.join("|")
-    ? "compact"
-    : headers.join("|") === legacyBacklogHeaders.join("|")
-      ? "legacy"
-      : "unknown";
-
-  if (layout === "unknown") {
-    if (findings) {
-      addFinding(
-        findings,
-        "revise",
-        "AGDF_BACKLOG_LAYOUT_UNKNOWN",
-        `MASTER_BACKLOG.md uses an unsupported table layout: ${headers.join(", ")}.`,
-        backlogPath,
-        "Use the canonical compact layout or the supported legacy 13-column layout.",
-      );
-    }
-    return [];
-  }
-
-  return rows.slice(1)
-    .filter((cells) => cells.some((cell) => filled(cell)))
-    .map((cells) => {
-      const pointer = emptyBacklogPointer();
-      if (layout === "legacy") {
-        [
-          pointer.prio,
-          pointer.key,
-          pointer.title,
-          pointer.status,
-          pointer.ur,
-          pointer.brownfield_review,
-          pointer.prd,
-          pointer.sd,
-          pointer.tp,
-          pointer.qa,
-          pointer.or,
-          pointer.current_spec,
-          pointer.notes,
-        ] = cells.map((cell) => cell ?? "");
-        pointer.status = normalizeBacklogStatus(pointer.status, findings, backlogPath);
-        return pointer;
-      }
-
-      pointer.prio = cells[0] ?? "";
-      pointer.key = cleanStatusCell(cells[1] ?? "");
-      pointer.title = cells[2] ?? "";
-      pointer.scope = normalizeBacklogScope(cells[2], findings, backlogPath) ?? "";
-      pointer.status = normalizeBacklogStatus(cells[3], findings, backlogPath);
-      parseCompactArtefacts(cells[4] ?? "", pointer, findings, backlogPath);
-      pointer.current_spec = normalizedBacklogLinkTarget(cells[5] ?? "", findings, backlogPath, "Current spec");
-      pointer.notes = cells[6] ?? "";
-      return pointer;
-    });
-}
-
 export function hasFilledTableRow(content, firstCellPattern) {
   return tableRows(content)
     .filter((cells) => firstCellPattern.test(cells[0] ?? ""))
     .some((cells) => cells.slice(1).some((cell) => cell && !cell.startsWith("`")));
 }
 
-export function isPlaceholderValue(value) {
-  return !value || (value.startsWith("`") && value.includes("|"));
-}
+
 
 export function hasFilledEvidenceRow(content) {
   const evidenceSection = content.match(/## Evidence([\s\S]*?)(?:\n## |\n# |$)/)?.[1] ?? "";
@@ -323,9 +76,7 @@ export function markdownSection(content, heading) {
   return content.match(new RegExp(`(?:^|\\n)## ${escaped}\\s*\\n([\\s\\S]*?)(?:\\n## |\\n# |$)`))?.[1] ?? "";
 }
 
-export function filled(value) {
-  return Boolean(value && !isPlaceholderValue(value) && value.trim() !== "");
-}
+
 
 export function runSelectionRecovery(target) {
   const directSelection = "Pass --run <run_id> or set AGDF_RUN_ID to select the intended run";

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/tp-planning.js

@@ -1,3 +1,4 @@
+import { runDocumentPath } from '../control-state/run-identity.js';
 import { readFileSync } from '../control-read/fs.js';
 import { section } from './markdown-table.js';
 import { readSdDecisionRows } from './sd-readiness.js';
@@ -53,8 +54,8 @@ function sourceValid(root, state, reference) {
     && artefactFileDigest(root, source.path) === digest && readFileSync(file.path, 'utf8').includes(statement);
 }
 function resolutionValid(root, state, id, reference) {
-  const match = reference.match(/^(\.agdf\/control\/artefacts\/[^ ]+) @ (sha256:[0-9a-f]{64})$/u);
-  if (!match || !match[1].startsWith(`.agdf/control/artefacts/${state.run_id}/`) || hasSymlinkComponent(root, match[1])) return false;
+  const match = reference.match(/^(\.agdf\/control\/runs\/[^ ]+) @ (sha256:[0-9a-f]{64})$/u);
+  if (!match || !match[1].startsWith(`${runDocumentPath(state.run_id, '')}/`) || hasSymlinkComponent(root, match[1])) return false;
   const file = containedRegularFile(root, match[1]);
   if (file.status !== 'valid' || artefactFileDigest(root, match[1]) !== match[2] || !readFileSync(file.path, 'utf8').includes(id)) return false;
   const evidence = readEvidenceBindings(state.content);

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/ur-readiness.js

@@ -23,9 +23,15 @@ export function evaluateUrReadiness(targetDir, runState, { presentationLanguage
   const path = resolvedArtefactFile(targetDir, runState.artefacts.get("UR")?.path);
   if (!path) return null;
   const content = readFileSync(path, "utf8");
+  return evaluateUrContentReadiness(content, { languages: resolveArtifactPresentationLanguages(targetDir, presentationLanguage), path });
+}
+
+// Shared authoring semantics for Run and pre-Run planning; planning explicitly
+// requires the current clarification contract rather than legacy marker absence.
+export function evaluateUrContentReadiness(content, { languages, path = 'UR.md', requireClarification = false } = {}) {
   try { previewRequirement(content); } catch (error) { return { ready: false, legacy: false, open_items: [error.message] }; }
   const markers = content.match(/^Requirements clarification:[^\r\n]*$/gmu) ?? [];
-  if (!markers.length) return { ready: true, legacy: true, open_items: [] };
+  if (!markers.length && !requireClarification) return { ready: true, legacy: true, open_items: [] };
   const open = markers.length === 1 && markers[0].trim() === UR_AUTHORING_FORMAT.readiness_contract ? [] : ["Requirements clarification"];
   const blocks = content.split(/^##[ \t]+/mu).slice(1).map(block => {
     const [heading, ...body] = block.split(/\r?\n/u);
@@ -36,7 +42,6 @@ export function evaluateUrReadiness(targetDir, runState, { presentationLanguage
     const body = matches[0]?.body ?? "";
     if (matches.length !== 1 || !body || templatePrompts.has(body) || /<[^>]+>|^(?:tbd|todo|to confirm)[ \t]*$/imu.test(body)) open.push(section);
   }
-  const languages = resolveArtifactPresentationLanguages(targetDir, presentationLanguage);
   const summary = evaluateApprovalSummaryReadiness("UR", content, languages);
   if (!summary.ready) open.push(summary.required_heading);
   // Name the unreadable field and its expected line, not only the section heading.

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/verified-change.js

@@ -1,14 +1,12 @@
+import { runDocumentPath } from '../control-state/run-identity.js';
 import { readFileSync } from "../control-read/fs.js";
 import { containedRegularFile, isSafeControlRelativePath } from "../control-state/contained-file.js";
 import { cleanStatusCell, isPlaceholderValue } from "./shared.js";
 
-export function extractField(content, field) {
-  const pattern = new RegExp(`^- ${field}:[^\\S\\r\\n]*(.*)$`, "m");
-  return content.match(pattern)?.[1]?.trim() ?? "";
-}
+export { extractField, verifiedChangeEscalationTargets } from "./gate-policy-inputs.js";
+import { extractField, verifiedChangeEscalationTargets } from "./gate-policy-inputs.js";
 
 export const verifiedChangeStatuses = new Set(["draft", "eligible", "executed", "escalated"]);
-export const verifiedChangeEscalationTargets = new Set(["structured_slice", "structured_delivery"]);
 
 export function parseVerifiedChangePathList(value) {
   const cleaned = cleanStatusCell(value ?? "");
@@ -20,10 +18,12 @@ export function isSafeRepoRelativePath(value) {
   return isSafeControlRelativePath(value);
 }
 
-export function readVerifiedChangeRecord(targetDir, runState) {
+export function readVerifiedChangeRecord(targetDir, runState, proposedArtefacts) {
   const artefact = runState.artefacts.get("Verified Change");
   if (!artefact?.path || isPlaceholderValue(artefact.path)) return { status: "missing", path: "", content: "" };
   if (!isSafeRepoRelativePath(artefact.path)) return { status: "invalid", path: artefact.path, content: "", error: "record_path_invalid" };
+  const proposed = proposedArtefacts?.get(artefact.path);
+  if (proposed) return { status: 'present', path: artefact.path, content: proposed.content };
   const result = containedRegularFile(targetDir, artefact.path);
   if (result.status !== "valid") {
     if (result.status === "invalid") return { status: "invalid", path: artefact.path, content: "", error: "record_path_invalid" };
@@ -35,7 +35,7 @@ export function readVerifiedChangeRecord(targetDir, runState) {
 export function evaluateVerifiedChange(targetDir, runState, dependencies = {}) {
   const gitPathList = dependencies.gitPathList ?? (() => null);
   const gitValue = dependencies.gitValue ?? (() => null);
-  const record = readVerifiedChangeRecord(targetDir, runState);
+  const record = readVerifiedChangeRecord(targetDir, runState, dependencies.proposedArtefacts);
   const findings = [];
   const add = (code, message, nextStep, severity = "revise") => findings.push({
     severity,
@@ -99,8 +99,8 @@ export function evaluateVerifiedChange(targetDir, runState, dependencies = {}) {
   const dirtyCandidate = [...allowedPaths].find((path) => baselinePaths.has(path));
   if (dirtyCandidate) add("AGDF_VERIFIED_CHANGE_BASELINE_CANDIDATE_DIRTY", `Declared candidate path is already dirty at baseline: ${dirtyCandidate}.`, "Escalate or start from a clean candidate path; do not adopt pre-existing edits.", "block");
 
-  const permittedControlPaths = new Set([record.path, runState.path, ".agdf/control/MASTER_BACKLOG.md"]);
-  const runArtefactPrefix = `.agdf/control/artefacts/${runId}/`;
+  const permittedControlPaths = new Set([record.path, runState.path]);
+  const runArtefactPrefix = `${runDocumentPath(runId, '')}/`;
   for (const artefact of runState.artefacts.values()) {
     if (artefact.path_format === "invalid") continue;
     if (isSafeRepoRelativePath(artefact.path) && artefact.path.startsWith(runArtefactPrefix)) permittedControlPaths.add(artefact.path);
@@ -120,6 +120,8 @@ export function evaluateVerifiedChange(targetDir, runState, dependencies = {}) {
       }
     }
   } else {
+    // Completed pre-cutover records may legitimately retain the old projection
+    // in their immutable execution snapshot. Active work has no such exemption.
     const unsafeExecutionPath = executionChangedPaths.find((path) => !isSafeRepoRelativePath(path) || (!allowedPaths.has(path) && !permittedControlPaths.has(path)));
     if (unsafeExecutionPath) add("AGDF_VERIFIED_CHANGE_EXECUTION_SCOPE_INVALID", `Recorded execution path is outside the eligible scope: ${unsafeExecutionPath}.`, "Correct the historical execution snapshot or escalate.", "block");
   }

package/{runtime/core/lib/control-evaluation/backlog-vocabulary.js → generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/work-vocabulary.js}

@@ -1,7 +1,7 @@
 // Descriptive saved labels only. Gate policy and QA remain the decision owners.
 export const SUMMARY_KINDS = Object.freeze(['work_pending', 'approval_pending', 'qa_report_pending',
   'qa_evidence_open', 'qa_correction_open', 'qa_source_decision', 'qa_blocked', 'source_unconfirmed',
-  'closeout_pending', 'completed', 'unconfirmed']);
+  'closeout_pending', 'completed', 'unconfirmed', 'run_ended']);
 export const SUMMARY_LABELS = Object.freeze({
   work_pending: ['Work pending', 'Arbeit offen'], approval_pending: ['Approval pending', 'Freigabe ausstehend'],
   qa_report_pending: ['QA report pending', 'QA-Bericht ausstehend'],
@@ -10,6 +10,6 @@ export const SUMMARY_LABELS = Object.freeze({
   qa_source_decision: ['QA source decision required', 'QA: vorgelagerte Entscheidung erforderlich'],
   qa_blocked: ['QA blocked', 'QA blockiert'], source_unconfirmed: ['Source unconfirmed', 'Quelle nicht bestätigt'],
   closeout_pending: ['Closeout pending', 'Abschluss offen'], completed: ['Completed', 'Abgeschlossen'],
-  unconfirmed: ['Unconfirmed', 'Nicht bestätigt'],
+  unconfirmed: ['Unconfirmed', 'Nicht bestätigt'], run_ended: ['Run ended', 'Run beendet'],
 });
 export const summaryLabel = (kind, language = 'en') => SUMMARY_LABELS[kind]?.[language === 'de' ? 1 : 0] ?? SUMMARY_LABELS.unconfirmed[language === 'de' ? 1 : 0];

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

@@ -1,3 +1,4 @@
+import { runDocumentPath } from '../control-state/run-identity.js';
 import { readFileSync } from '../control-read/fs.js';
 import { join } from 'node:path';
 import { captureControlScope } from '../control-read/snapshot.js';
@@ -13,7 +14,8 @@ import { artefactFileDigest, runSealState } from '../control-state/run-seal.js';
 import { containedRegularFile, hasSymlinkComponent } from '../control-state/contained-file.js';
 import { extractField } from '../control-evaluation/verified-change.js';
 
-export const ARTIFACT_READINESS_GATES = Object.freeze(['UR', 'PRD', 'SD', 'TP']);
+import { ARTIFACT_READINESS_GATES } from './selection.js';
+export { ARTIFACT_READINESS_GATES };
 
 // Describes the original author's findings; it does not validate or change gate policy.
 export function describeArtifactReadiness(result) {
@@ -42,7 +44,7 @@ export function describeArtifactReadiness(result) {
 
 // Runs only inside the caller's bounded captured view. Both consumers use these same validators.
 export function projectArtifactReadiness(root, { runId, gate, expectedRevisionId, presentationLanguage }) {
-  const path = `.agdf/control/artefacts/${runId}/${gate}.md`;
+  const path = `${runDocumentPath(runId, '')}/${gate}.md`;
   const targetRoot = root;
   const diagnostics = [], checks = [];
   let state, revision = null, digest = null;
@@ -108,7 +110,7 @@ export function projectArtifactReadiness(root, { runId, gate, expectedRevisionId
 // Standalone authoring preflight retains its original captured/read-only report contract.
 export function inspectArtifactReadiness(root, input) {
   const { runId, gate, expectedRevisionId } = input;
-  const path = `.agdf/control/artefacts/${runId}/${gate}.md`;
+  const path = `${runDocumentPath(runId, '')}/${gate}.md`;
   try {
     return captureControlScope(root, view => projectArtifactReadiness(view.root, input)).data;
   } catch (error) {

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

@@ -0,0 +1,110 @@
+import { runDocumentPath } from '../control-state/run-identity.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';
+import { readRunState } from '../control-evaluation/run-state.js';
+import { runSealState, artefactFileDigest, canonicalRunText } from '../control-state/run-seal.js';
+import { containedRegularFile, hasSymlinkComponent } from '../control-state/contained-file.js';
+import { operationContract } from '../control-state/run-command-contract.js';
+import { resolveArtefactTemplatePath } from '../resources/artefact-templates.js';
+import { digest, resolveControlCommandTarget } from '../control-state/approval-command-contract.js';
+import { inspectDefinitionSources } from '../control-evaluation/definition-sources.js';
+import { prdDefinitionEligible } from '../skill-dispatch/prd-definition.js';
+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';
+
+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',
+  'UX Intent Definition': 'UX_INTENT_DEFINITION', 'Verified Change Execution': 'VERIFIED_CHANGE' })[gate];
+
+// One contained source projection plus the existing version-bound template owner.
+// Its paged text is input, never a presentation, edit permission or review attestation.
+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']),
+      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;
+    const captured = captureControlScope(root, () => {
+      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 },
+          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 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 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);
+        if (file.status !== 'valid' || statSync(file.path).size > 131072) throw Error('authoring_source_unavailable');
+        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 };
+      });
+      // 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,
+        blocking_reason: evaluated.blocking_reason, sources };
+    });
+    const data = captured.data, ids = [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);
+      if (statSync(path).size > 131072) throw Error('authoring_template_limit');
+      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 }))];
+    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);
+    const chunks = [];
+    for (const document of documents) {
+      const { content, ...metadata } = document, bytes = Buffer.from(content);
+      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 });
+        start = end;
+      }
+    }
+    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');
+    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')
+      : 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,
+      ...(input.planning ? { planning: input.planning, canonical_skill: 'ur-definition' } : {}),
+      authoring_owner: data.authoring_owner, recording: data.recording,
+      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,
+      // 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,
+        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 };
+  } catch (e) { return unavailable(e.code ?? e.message); }
+}

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

@@ -0,0 +1,53 @@
+// Cockpit reads only this current archive format. Old control parsers stay offline.
+import { createHash } from 'node:crypto';
+import { join, posix } from 'node:path';
+import { existsSync, readFileSync } from '../control-read/fs.js';
+import { fail, READ_LIMITS } from '../control-read/snapshot.js';
+export const ARCHIVE_INDEX = '.agdf/control/archive/INDEX.json';
+export const ARCHIVE_SCHEMA = 'cockpit-archive/1';
+const hash = bytes => 'sha256:' + createHash('sha256').update(bytes).digest('hex');
+const safe = path => typeof path === 'string' && path.length < 4096 && !/[\\\u0000-\u001f:]/u.test(path)
+  && !path.startsWith('/') && path.split('/').every(p => p && p !== '.' && p !== '..');
+const plain = value => value && typeof value === 'object' && !Array.isArray(value);
+const text = value => typeof value === 'string' && value.length <= 8192;
+export function readCockpitArchive(root) {
+  if (!existsSync(join(root, ARCHIVE_INDEX))) return null;
+  const bytes = readFileSync(join(root, ARCHIVE_INDEX));
+  let index; try { index = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes)); } catch { fail('archive_invalid'); }
+  validateCockpitArchive(index);
+  return { ...index, digest: hash(bytes) };
+}
+export function validateCockpitArchive(index) {
+  if (!plain(index) || index.schema !== ARCHIVE_SCHEMA || index.authorizes !== false || !/^sha256:[a-f0-9]{64}$/u.test(index.source_digest)
+    || !Array.isArray(index.entries) || index.entries.length > 4096) fail('archive_invalid');
+  if (Buffer.byteLength(JSON.stringify(index)) > READ_LIMITS.file) fail('resource_limit');
+  const keys = new Set(), paths = new Set(); let files = 0;
+  for (const run of index.entries) {
+    if (!plain(run) || !text(run.id) || keys.has(run.id) || !text(run.title) || !['run', 'artefacts', 'project'].includes(run.entry_kind) || ![run.recorded_lifecycle, run.recorded_gate, run.source_control_version].every(v => v === null || text(v))
+      || !Array.isArray(run.recorded_approvals) || run.recorded_approvals.length > 64 || !run.recorded_approvals.every(a => plain(a) && ['gate', 'status', 'evidence'].every(k => text(a[k])))
+      || !Array.isArray(run.documents) || run.documents.length > READ_LIMITS.files) fail('archive_invalid');
+    keys.add(run.id);
+    for (const doc of run.documents) {
+      if (!plain(doc) || !safe(doc.path) || !doc.path.startsWith('.agdf/control/archive/source/') || (!text(doc.original_path) || !doc.original_path.startsWith('.agdf/control/'))
+        || paths.has(doc.path) || !/^sha256:[a-f0-9]{64}$/u.test(doc.digest) || !Number.isSafeInteger(doc.bytes) || doc.bytes < 0) fail('archive_invalid');
+      paths.add(doc.path); if (++files > READ_LIMITS.files) fail('resource_limit');
+    }
+  }
+  return index;
+}
+export function archiveRows(index) {
+  return index ? index.entries.map(run => ({ kind: 'archive', identity: `archive/${run.id}`, section: 'archive', key: run.id,
+    original_key: run.id, title: run.title, stored_status: `Archiviert · damaliger Stand: ${run.recorded_lifecycle ?? 'Unbekannt'}`,
+    scope: 'Altbestandsarchiv · nur lesen', priority: null, stored_next_step: 'Archiv ansehen',
+    source_links: ARCHIVE_INDEX, current_spec: null, source: { path: ARCHIVE_INDEX, digest: index.digest },
+    coverage: 'archived', actions: ['read_archive'], handoff_ready: false, selectable: true, authorizes: false })) : [];
+}
+export function readArchiveDocument(root, doc) {
+  const bytes = readFileSync(join(root, doc.path));
+  if (bytes.length !== doc.bytes || hash(bytes) !== doc.digest) fail('source_changed');
+  if (bytes.length > READ_LIMITS.preview || !['md', 'json', 'txt', 'log', 'patch'].includes(posix.extname(doc.path).slice(1).toLowerCase()))
+    return { available: false, reason: 'document_unsupported', path: doc.original_path, digest: doc.digest, bytes: doc.bytes };
+  let content; try { content = new TextDecoder('utf-8', { fatal: true }).decode(bytes); if (content.includes('\0')) throw Error(); }
+  catch { return { available: false, reason: 'document_unsupported', path: doc.original_path, digest: doc.digest, bytes: doc.bytes }; }
+  return { available: true, path: doc.original_path, digest: doc.digest, bytes: doc.bytes, content };
+}

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

@@ -85,7 +85,8 @@ export function composeCockpitPacket(metadata, document, context, input) {
   const selected = input.graph_ids.map(id => registrations.get(id));
   if (selected.some(ref => ref.state !== 'available')) fail('resource_denied');
   if (context.references.some(ref => ref.state !== 'available' && !input.excluded_ids.includes(ref.resource_id))) fail('context_exclusion_required');
-  const packet = { ...metadata, context_id: randomUUID(), generation: input.generation,
+  // Context packets keep their independent published format when the reader envelope evolves.
+  const packet = { ...metadata, schema_version: '1', context_id: randomUUID(), generation: input.generation,
     prepared_at: new Date().toISOString(), artefact: document,
     graph_nodes: selected,
     included: [{ resource_id: document.resource.resource_id, path: document.resource.path }, ...selected.map(ref => ({ resource_id: ref.resource_id, node_id: ref.node_id, origin: ref.origin }))],