create-agdf 0.20.1 → 0.30.0

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-read/doctor-reader.js

@@ -0,0 +1,92 @@
+import { captureControlScope, ControlReadError } from './snapshot.js';
+import { resolveRuns } from '../control-state/run-state-resolver.js';
+import { evaluateDoctor, doctorInventoryFindings } from '../control-evaluation/doctor.js';
+import { aggregate } from '../control-state/aggregate.js';
+import { allowNoActiveRuns } from '../control-evaluation/shared.js';
+import { existsSync } from './fs.js';
+import { join } from 'node:path';
+
+const bytes = value => Buffer.byteLength(JSON.stringify(value));
+const error = code => { throw new ControlReadError(code); };
+const git = value => ({ gitValue: () => value?.head ?? null, gitPathList: (_root, args) => args[0] === 'diff' ? value?.tracked ?? null : value?.untracked ?? null });
+const summary = findings => ({ findings: findings.length, block: findings.filter(f => f.severity === 'block').length,
+  revise: findings.filter(f => f.severity === 'revise').length, warn: findings.filter(f => f.severity === 'warn').length });
+
+// Exactly one bounded observation per read worker. Core owns checks/aggregation;
+// the retained dependency scope owns consistency, not permission or persistence.
+export function createDoctorReader(root, { limits = {} } = {}) {
+  let scope, current, items, originalGit, allowEmpty, next = 0, invalidCount = 0, cacheBytes = 0;
+  const pages = new Map(), statuses = [], totals = { findings: 0, block: 0, revise: 0, warn: 0 };
+  let failed = false, unevaluated = 0, controlPresent = true;
+  function page(offset, snapshot, started = performance.now()) {
+    if (failed || !scope || JSON.stringify(originalGit) !== JSON.stringify(snapshot)) error('source_changed');
+    current.view.revalidate();
+    if (pages.has(offset)) return pages.get(offset);
+    if (offset !== next || pages.size >= 64) error(offset !== next ? 'diagnostic_cursor_invalid' : 'resource_limit');
+    let wanted = null;
+    const captured = scope.extend(() => {
+      const rows = [], start = performance.now(); let size = 0;
+      for (let index = offset; index < items.length && rows.length < (wanted ?? 20); index++) {
+        if (wanted === null && rows.length && performance.now() - start >= 2500) break;
+        const item = items[index];
+        const row = item.invalid ? { run_id: item.run_id, invalid: true, findings: doctorInventoryFindings(item.findings) }
+          : { run_id: item.run_id, report: evaluateDoctor(root, { runId: item.run_id, ignoreRunIdEnv: true }, git(originalGit)) };
+        if (bytes(row) > 500 * 1024) {
+          rows.push({ run_id: item.run_id, unevaluated: true, reason: 'resource_limit', findings: [] });
+        } else {
+          if (wanted === null && rows.length && size + bytes(row) > 500 * 1024) break;
+          rows.push(row); size += bytes(row);
+        }
+      }
+      if (wanted === null) wanted = rows.length;
+      return rows;
+    });
+    current = captured;
+    const rows = captured.data;
+    if (items.length && !rows.length) error('resource_limit');
+    const findings = rows.flatMap(row => row.invalid ? row.findings : row.report?.findings.map(f => ({ ...f, run_id: row.run_id })) ?? []);
+    const counts = summary(findings), nextTotals = Object.fromEntries(Object.keys(totals).map(k => [k, totals[k] + counts[k]]));
+    const end = offset + rows.length, nextUnevaluated = unevaluated + rows.filter(r => r.unevaluated).length;
+    const nextInvalid = invalidCount + rows.filter(r => r.invalid).length;
+    const nextStatuses = [...statuses, ...rows.filter(r => r.report).map(r => ({ run_id: r.run_id, status: r.report.status }))];
+    const complete = end === items.length && !nextUnevaluated;
+    const aggregated = aggregate(nextStatuses, { allowNoActiveRuns: allowEmpty });
+    const result = { schema_version: '1', available: true, status: complete ? nextInvalid ? 'block' : aggregated.status : 'partial',
+      target_dir: root, checked_at: current.view.observed_as_of, observed_as_of: scope.view.observed_as_of,
+      ...(complete && !nextInvalid && controlPresent && aggregated.empty_inventory ? { empty_inventory: aggregated.empty_inventory } : {}),
+      source_digest: current.view.digest, completeness: complete ? 'complete' : 'partial',
+      inventory: { state: !controlPresent ? 'absent' : nextInvalid ? 'incomplete' : end === items.length ? 'complete' : 'partial', active_count: items.filter(r => !r.invalid).length,
+        total_entries: items.length, accounted_count: end, evaluated_count: end - nextUnevaluated,
+        unevaluated_count: nextUnevaluated, remaining_count: items.length - end },
+      summary: complete ? nextTotals : counts, cumulative_summary: nextTotals, findings,
+      runs: rows.filter(r => r.report), invalid_entries: rows.filter(r => r.invalid), unevaluated_entries: rows.filter(r => r.unevaluated),
+      next_offset: end < items.length ? end : null, authorizes: false,
+      timing: { capture_and_evaluation_ms: performance.now() - started } };
+    if (bytes(result) > 512 * 1024 || cacheBytes + bytes(result) > 8 * 1024 * 1024) error('resource_limit');
+    next = end; unevaluated = nextUnevaluated; invalidCount = nextInvalid;
+    statuses.splice(0, statuses.length, ...nextStatuses); Object.assign(totals, nextTotals);
+    pages.set(offset, result); cacheBytes += bytes(result);
+    return result;
+  }
+  return Object.freeze({
+    open(input) {
+      if (scope) error('resource_denied');
+      const started = performance.now(); originalGit = input.git_snapshot;
+      if (!input.all_active) {
+        const selected = captureControlScope(root, () => evaluateDoctor(root, { ...(input.run_id ? { runId: input.run_id } : {}), ignoreRunIdEnv: true }, git(originalGit)), { limits });
+        return { ...selected.data, available: true, completeness: 'complete', source_digest: selected.view.digest,
+          observed_as_of: selected.view.observed_as_of, authorizes: false, next_offset: null,
+          timing: { capture_and_evaluation_ms: performance.now() - started } };
+      }
+      scope = captureControlScope(root, () => {
+        const resolved = resolveRuns(root, { allActive: true }), invalid = new Map();
+        for (const finding of resolved.findings) invalid.set(finding.run_id, [...(invalid.get(finding.run_id) ?? []), finding]);
+        return { items: [...resolved.runs.map(r => ({ run_id: r.run_id })), ...[...invalid].map(([run_id, findings]) => ({ run_id, invalid: true, findings }))]
+          .sort((a, b) => a.run_id.localeCompare(b.run_id)), allowEmpty: allowNoActiveRuns(root), controlPresent: existsSync(join(root, '.agdf/control')) };
+      }, { limits, retain: true });
+      current = scope; items = scope.data.items; allowEmpty = scope.data.allowEmpty; controlPresent = scope.data.controlPresent;
+      return page(0, originalGit, started);
+    },
+    page(input) { try { return page(input.offset, input.git_snapshot); } catch (e) { if (e.code !== 'diagnostic_cursor_invalid') failed = true; throw e; } },
+  });
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-read/doctor-worker.js

@@ -0,0 +1,11 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { createDoctorReader } from './doctor-reader.js';
+const reader = createDoctorReader(workerData.root, { limits: workerData.limits });
+parentPort.postMessage({ phase: 'read_worker_ready' });
+parentPort.on('message', ({ id, operation, input }) => {
+  try {
+    const result = operation === 'doctor_open' ? reader.open(input) : operation === 'doctor_page' ? reader.page(input)
+      : (() => { throw Object.assign(Error('resource_denied'), { code: 'resource_denied' }); })();
+    parentPort.postMessage({ id, result });
+  } catch (e) { parentPort.postMessage({ id, error: e.code ?? 'read_failed' }); }
+});

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-read/fs.js

@@ -4,6 +4,24 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 // Only read owners import this seam. No global fs patch and no writer API.
 const context = new AsyncLocalStorage();
 const memo = new WeakMap();
+// Only a retained observation owner may inherit memoized facts after revalidation.
+export function inheritControlReadMemo(from, to) {
+  let cache = memo.get(from);
+  if (!cache) { cache = new Map(); memo.set(from, cache); }
+  memo.set(to, cache);
+}
+export const hasControlReadView = () => Boolean(context.getStore()?.view);
+export const currentControlReadView = () => context.getStore()?.view ?? null;
+// CLI readers retain their existing file scope; memoized work never survives a call.
+// MCP readers install a contained captured view before entering the same evaluators.
+export function withControlReadMemo(work) {
+  if (hasControlReadView()) return work();
+  const view = { ...native, lstatKindSync(path) {
+    const s = native.lstatSync(path);
+    return s.isSymbolicLink() ? 'symlink' : s.isDirectory() ? 'directory' : s.isFile() ? 'file' : 'other';
+  } };
+  return withControlReadView(view, work);
+}
 export function memoizeControlRead(key, work) {
   const view = context.getStore()?.view;
   if (!view) return work();

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-read/snapshot.js

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import { resolve, join, dirname, relative, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createHash, randomUUID } from 'node:crypto';
-import { withControlReadView } from './fs.js';
+import { withControlReadView, inheritControlReadMemo, hasControlReadView, currentControlReadView, statSync as viewStat, readFileSync as viewRead } from './fs.js';
 
 export const READ_LIMITS = Object.freeze({ files: 20_000, total: 256 * 1024 ** 2, file: 32 * 1024 ** 2,
   preview: 2 * 1024 ** 2, response: 8 * 1024 ** 2, timeout: 10_000 });
@@ -182,7 +182,8 @@ export function captureControlScope(rootInput, project, options = {}) {
   const input = resolve(rootInput), root = fs.realpathSync(input);
   if (!fs.lstatSync(input).isDirectory() || fs.lstatSync(input).isSymbolicLink()) fail('resource_denied');
   const control = join(root, '.agdf', 'control'), limits = { ...READ_LIMITS, ...options.limits };
-  const deadline = Date.now() + limits.timeout, entries = new Map();
+  let deadline = Date.now() + limits.timeout;
+  const entries = new Map();
   let total = 0, files = 0, frozen = false, building = true, fatal = null, sourceDigest = null;
   const absentError = code => Object.assign(Error('Observed entry absent'), { code });
   const guard = work => {
@@ -199,7 +200,10 @@ export function captureControlScope(rootInput, project, options = {}) {
   };
   function check() { if (building && Date.now() > deadline) fail('timeout'); }
   function pathOf(value) {
-    check(); const path = keyOf(value);
+    check(); let path = keyOf(value);
+    // The verified input root may use an OS alias (macOS /var -> /private/var).
+    // Normalize that root prefix only; never resolve arbitrary descendant symlinks.
+    if (path === input || path.startsWith(input + sep)) path = join(root, relative(input, path));
     if (path !== root && path !== join(root, '.agdf') && path !== control && !path.startsWith(control + sep)) fail('resource_denied');
     if (relative(control, path).split(sep).length > 128) fail('resource_limit');
     return path;
@@ -361,18 +365,65 @@ export function captureControlScope(rootInput, project, options = {}) {
     for (const [name, method] of Object.entries(methods)) view[name] = (...args) => guard(() => method(...args));
     return Object.freeze(view);
   }
-  const recording = makeView();
-  const recorded = withControlReadView(recording, () => project(recording));
-  if (recorded?.then) fail('read_failed');
-  recording.assertBoundary(); options.checkpoint?.('captured', root);
-  frozen = true; revalidate(deadline);
-  sourceDigest = hash(JSON.stringify([...entries].sort(([a], [b]) => a.localeCompare(b))
-    .map(([path, entry]) => [relative(root, path), entry.kind, entry.signature ?? entry.code, entry.digest ?? null, entry.children ?? null])));
-  // New view identity also gives the replay a fresh memo cache in the FS seam.
-  const view = makeView(); options.checkpoint?.('replay', root);
-  const data = withControlReadView(view, () => project(view));
-  if (data?.then) fail('read_failed');
-  view.assertBoundary(); options.checkpoint?.('published', root); revalidate(deadline);
-  building = false;
-  return Object.freeze({ view, data });
+  let previousView = null;
+  function capture(project) {
+    if (previousView) {
+      deadline = Date.now() + limits.timeout;
+      revalidate(deadline);
+    }
+    building = true; frozen = false;
+    const recording = makeView();
+    if (options.retain && previousView) inheritControlReadMemo(previousView, recording);
+    const recorded = withControlReadView(recording, () => project(recording));
+    if (recorded?.then) fail('read_failed');
+    recording.assertBoundary(); options.checkpoint?.('captured', root);
+    frozen = true; revalidate(deadline);
+    sourceDigest = hash(JSON.stringify([...entries].sort(([a], [b]) => a.localeCompare(b))
+      .map(([path, entry]) => [relative(root, path), entry.kind, entry.signature ?? entry.code, entry.digest ?? null, entry.children ?? null])));
+    const view = makeView(); options.checkpoint?.('replay', root);
+    if (options.retain) inheritControlReadMemo(recording, view);
+    const data = withControlReadView(view, () => project(view));
+    if (data?.then) fail('read_failed');
+    view.assertBoundary(); options.checkpoint?.('published', root); revalidate(deadline);
+    building = false; previousView = view;
+    return Object.freeze({ view, data });
+  }
+  const initial = capture(project);
+  return options.retain ? Object.freeze({ ...initial, extend: capture }) : initial;
+}
+
+// Single contained control source using the same descriptor/ancestor/race checks
+// as dependency capture. Mutation owners can inspect exact old bytes without
+// introducing another filesystem reader or capturing unrelated Run resources.
+function validateSingleControlPath(relativePath) {
+  if (typeof relativePath !== 'string' || !relativePath.startsWith('.agdf/control/')
+    || relativePath.includes('\\') || relativePath.includes(':') || relativePath.split('/').some(part => !part || part === '.' || part === '..')) fail('resource_denied');
+}
+export function readContainedControlText(root, relativePath, maximum = 131072) {
+  validateSingleControlPath(relativePath);
+  if (hasControlReadView()) {
+    const view = currentControlReadView();
+    if (view.readOptionalFileSync) {
+      const observed = view.readOptionalFileSync(join(root, relativePath), maximum);
+      if (observed.code) fail(observed.code);
+      return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(observed.bytes);
+    }
+    const path = join(root, relativePath), stats = viewStat(path);
+    if (!stats.isFile() || stats.size > maximum) fail('resource_limit');
+    const bytes = viewRead(path);
+    if (bytes.length > maximum) fail('resource_limit');
+    return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+  }
+  return captureControlScope(root, view => {
+    const observed = view.readOptionalFileSync(join(root, relativePath), maximum);
+    if (observed.code) fail(observed.code);
+    return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(observed.bytes);
+  }).data;
+}
+
+export function controlPathPresent(root, relativePath) {
+  validateSingleControlPath(relativePath);
+  const path = join(root, relativePath), view = currentControlReadView();
+  if (view?.readOptionalFileSync) return view.readOptionalFileSync(path, 0).code !== 'document_missing';
+  return captureControlScope(root, observed => observed.readOptionalFileSync(path, 0).code !== 'document_missing').data;
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/aggregate.js

@@ -14,5 +14,7 @@ export function aggregate(results, { allowNoActiveRuns = false } = {}) {
       ? "pass"
       : "revise";
 
-  return { status, runs };
+  return { status, runs, ...(!runs.length ? { empty_inventory: {
+    reason: 'no_active_runs', allow_no_active_runs: allowNoActiveRuns,
+  } } : {}) };
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/approval-command.js

@@ -1,18 +1,19 @@
+import { APPROVAL_OPERATION_VERSION } from './approval-operations.js';
+import { bindInputResolution } from './input-resolution.js';
 import { assertRunOperationIdentity } from "./run-operation-identity.js";
 import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { prepareGateApproval } from "./run-recording.js";
 import { validateRunPresentationRecord } from './run-presentation.js';
-import { readRun } from "./run-state-edits.js";
+import { readRun, endedRunRejection } from "./run-state-edits.js";
 import { parseControlState, parseRunState } from "./run-state-parser.js";
 import { runSealState } from "./run-seal.js";
 import { containedRegularFile, hasSymlinkComponent } from "./contained-file.js";
 import { appendApprovalOperation, readApprovalOperations } from "./approval-operations.js";
 import { approvalRequestDigest, commandBinding, COOPERATIVE_ASSURANCE, ownDataValue, resolveControlCommandTarget, validateApprovalCommand } from "./approval-command-contract.js";
 import { flushRunCommit } from "./run-state-writer.js";
-import { withRunBacklogLock, writeRunWithBacklogLocked } from "./run-backlog-writer.js";
-import { backlogSkip } from "./run-backlog.js";
+import { withRunMutationLock, writeRunMutationLocked } from "./run-mutation.js";
 
 function sealIsValid(root, content) {
   try { return runSealState(root, content).status === "valid"; } catch { return false; }
@@ -66,7 +67,7 @@ export function executeApprovalCommand(root, command, { evaluateGateCheck, packa
     return result("rejected", "run_path_invalid");
   }
   try {
-    return withRunBacklogLock(target.root, path, () => {
+    return withRunMutationLock(target.root, path, () => {
       const run = readRun(target.root, command.run_id);
       if (run.rejection) return result("recovery_required", run.rejection.reason);
       assertRunOperationIdentity(target.root, run, command.operation_id, "approval.record");
@@ -80,6 +81,8 @@ export function executeApprovalCommand(root, command, { evaluateGateCheck, packa
         flush(path);
         return result("already_applied", null, existing);
       }
+      const ended = endedRunRejection(command.run_id, run.content);
+      if (ended) return result("rejected", ended.reason, null, { closure: ended.closure, message: ended.message, next_action: ended.next_action });
       const prepared = prepareGateApproval(target.root, {
         runId: command.run_id, gate: command.gate, revisionId: command.expected_revision_id,
         presentationId: command.presentation_id, response: command.response,
@@ -87,8 +90,8 @@ export function executeApprovalCommand(root, command, { evaluateGateCheck, packa
       if (prepared.outcome === "rejected") return result("rejected", prepared.reason, null, {
         recovery: prepared.recovery ?? "Follow current.next_allowed_action. For a changed binding, prepare the current presentation and obtain a NEW deliberate reply; never rebind an earlier reply.",
       });
-      const receipt = {
-        schema_version: prepared.qaAcceptance ? "3" : "2", action: command.action, operation_id: command.operation_id,
+      const receipt = bindInputResolution({
+        schema_version: APPROVAL_OPERATION_VERSION, action: command.action, operation_id: command.operation_id,
         request_digest: requestDigest, command_digest: commandContext?.request_digest ?? null, binding: commandBinding(command), assurance: COOPERATIVE_ASSURANCE,
         created_at: new Date().toISOString(), producer: { contract: "approval-service/1", package_version: packageVersion },
         effect: { previous_revision_id: command.expected_revision_id, resulting_revision_id: randomUUID(),
@@ -97,16 +100,16 @@ export function executeApprovalCommand(root, command, { evaluateGateCheck, packa
           artefact_digest: prepared.digest, presentation_digest: prepared.presentation.digest,
           ...(prepared.qaAcceptance ? { qa_acceptance: prepared.qaAcceptance } : {}),
           next_gate_after_approval: prepared.after.current_gate, allowed_after_approval: prepared.after.next_allowed_action },
-      };
+      });
       checkpoint("before_final_validation");
-      const written = writeRunWithBacklogLocked(target.root, path, appendApprovalOperation(prepared.next, receipt), command.expected_revision_id, {
+      const written = writeRunMutationLocked(target.root, path, appendApprovalOperation(prepared.next, receipt), command.expected_revision_id, {
         allowApprovalChange: true, expectedContent: run.content, appendedReceipt: receipt,
         nextRevisionId: receipt.effect.resulting_revision_id, validateBeforeWrite: prepared.validateBeforeWrite,
         validateDuringTransaction: prepared.validateDuringTransaction, checkpoint, afterWrite,
         operationContext,
       });
       checkpoint("before_response");
-      return result("accepted", null, receipt, backlogSkip({ status: written.backlog, reason: written.backlog_reason }));
+      return result("accepted", null, receipt);
     }, { checkpoint, operationContext });
   } catch (error) {
     if (error.message === 'AGDF_OPERATION_PAYLOAD_CONFLICT') return result('rejected', 'operation_payload_conflict');
@@ -116,7 +119,7 @@ export function executeApprovalCommand(root, command, { evaluateGateCheck, packa
       { recovery: "Prepare the current presentation and obtain a NEW deliberate reply; never rebind an earlier reply." });
     // Rename can succeed before sync or lock release fails. Never infer absence from an exception.
     let current = readRun(target.root, command.run_id);
-    // A committed receipt remains observable while its Backlog journal is pending.
+    // A committed receipt remains observable while its Run-local journal is pending.
     // This acknowledgement is recovery-required, never a readiness/approval claim.
     if (current.rejection?.reason === "run_step_recovery_required") {
       try {

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/approval-operations.js

@@ -1,3 +1,4 @@
+import { resolutionRecord } from './input-resolution.js';
 import { validDecisionMaterial, decisionMaterialVersion } from './decision-material-contract.js';
 import { TextDecoder } from "node:util";
 import { APPROVAL_GATES, REVISION_ID_PATTERN, RUN_ID_PATTERN } from "./run-identity.js";
@@ -7,15 +8,17 @@ const RECEIPT_FIELDS = ["schema_version", "action", "operation_id", "request_dig
 const BINDING_FIELDS = ["target_id", "run_id", "gate", "expected_revision_id", "presentation_id"];
 const EFFECT_FIELDS = ["previous_revision_id", "resulting_revision_id", "revision", "gate", "approval", "artefact_digest", "presentation_digest", "next_gate_after_approval", "allowed_after_approval"];
 
+export const APPROVAL_OPERATION_VERSION = '4';
 export function validApprovalReceipt(receipt) {
-  const modern = ['2', '3'].includes(receipt.schema_version);
-  if (!exactObject(receipt, modern ? [...RECEIPT_FIELDS, "command_digest"] : RECEIPT_FIELDS) || !["1", "2", "3"].includes(receipt.schema_version) || receipt.action !== "record_gate_approval"
-      || !REVISION_ID_PATTERN.test(receipt.operation_id ?? "") || !DIGEST_PATTERN.test(receipt.request_digest ?? "")
-      || !exactObject(receipt.binding, BINDING_FIELDS) || !exactObject(receipt.effect, modern ? [...EFFECT_FIELDS, "material_version", "material_sources", ...(receipt.schema_version === '3' ? ['qa_acceptance'] : [])] : EFFECT_FIELDS)
-      || !exactObject(receipt.producer, ["contract", "package_version"])) return false;
+  receipt = resolutionRecord(receipt);
+  if (!receipt) return false;
+  if (!exactObject(receipt, [...RECEIPT_FIELDS, 'command_digest']) || receipt.schema_version !== '4' || receipt.action !== 'record_gate_approval'
+      || !REVISION_ID_PATTERN.test(receipt.operation_id ?? '') || !DIGEST_PATTERN.test(receipt.request_digest ?? '')
+      || !exactObject(receipt.binding, BINDING_FIELDS) || !exactObject(receipt.effect, [...EFFECT_FIELDS, 'material_version', 'material_sources', ...(receipt.effect?.qa_acceptance ? ['qa_acceptance'] : [])])
+      || !exactObject(receipt.producer, ['contract', 'package_version'])) return false;
   const binding = receipt.binding, effect = receipt.effect;
-  if (modern && (!DIGEST_PATTERN.test(effect.material_version ?? "") || !validDecisionMaterial(effect.material_sources, binding.run_id) || effect.material_version !== decisionMaterialVersion(binding.run_id, binding.gate, effect.material_sources) || receipt.command_digest !== null && !DIGEST_PATTERN.test(receipt.command_digest ?? ""))) return false;
-  if (receipt.schema_version === '3') {
+  if ((!DIGEST_PATTERN.test(effect.material_version ?? "") || !validDecisionMaterial(effect.material_sources, binding.run_id) || effect.material_version !== decisionMaterialVersion(binding.run_id, binding.gate, effect.material_sources) || receipt.command_digest !== null && !DIGEST_PATTERN.test(receipt.command_digest ?? ""))) return false;
+  if (effect.qa_acceptance) {
     const acceptance = effect.qa_acceptance;
     if (binding.gate !== 'QA' || !exactObject(acceptance, ['kind', 'digest', 'deviation_ids', 'qa_outcome'])
       || acceptance.kind !== 'accepted_with_deviations' || acceptance.qa_outcome !== 'revise' || !DIGEST_PATTERN.test(acceptance.digest ?? '')

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/artefact-binding-proof.js

@@ -1,12 +1,13 @@
+import { runControlPath } from './run-identity.js';
+import { resolutionRecordVersion } from './input-resolution.js';
 import { readFileSync, statSync } from "../control-read/fs.js";
 import { canonicalJson, digest, exactObject } from "./approval-command-contract.js";
 import { readApprovalOperations } from "./approval-operations.js";
 import { artefactFileDigest, APPROVAL_GATES } from "./run-seal-compute.js";
 import { containedRegularFile, hasSymlinkComponent } from "./contained-file.js";
-import { readArtefactBindings } from "./artefact-bindings.js";
+import { readArtefactBindings, validArtefactBinding } from "./artefact-bindings.js";
 import { readSourceRevisions } from "./run-source-revisions.js";
 import { validateRunPresentationEnvelope } from './run-presentation-envelope.js';
-import { REVIEW_PROOF_FIELDS } from './recording-formats.js';
 import { previewProof } from './preview-snapshot.js';
 import { reviewCorrections } from './presentation-decision.js';
 
@@ -53,38 +54,29 @@ export function inspectApprovedArtefact(root, control, gate, { fileDigest = path
       // A review corrected at OR (receipt-proven, presentation-decision.js) counts as the version the approval saw.
       const corrections = reviewCorrections(control), seen = source => fileDigest(source.path) === source.digest
         || corrections.get(source.type)?.seen_digest === source.digest && fileDigest(source.path) === corrections.get(source.type).current_digest;
-      if (['2', '3'].includes(receipt[0].schema_version) && !receipt[0].effect.material_sources.every(seen)) return unconfirmed();
+      if (!receipt[0].effect.material_sources.every(seen)) return unconfirmed();
       // The row identifies the exact prepared record, not a historical superseded approval.
     }
     let observedRaw;
     try {
-      const envelope = readJson(`.agdf/control/runs/${control.meta.run_id}/presentations/${presentation[1]}.json`);
+      const envelope = readJson(`${runControlPath(control.meta.run_id, 'presentations')}/${presentation[1]}.json`);
       const record = envelope.record;
       // Preserve the existing aggregate's v1 proof checks. New v2/v3/v4 envelopes have the
       // complete command grammar; older minimal proofs are not retroactively v2.
-      if (!record || ![1, 2, 3, 4, 5].includes(record.schema_version)
-          || record.schema_version >= 2 && validateRunPresentationEnvelope(envelope, { runId: control.meta.run_id, gate, revisionId: record.revision_id, presentationId: presentation[1] }).reason
+      if (!record || resolutionRecordVersion(record) !== 7
+          || validateRunPresentationEnvelope(envelope, { runId: control.meta.run_id, gate, revisionId: record.revision_id, presentationId: presentation[1] }).reason
           || record.presentation_id !== presentation[1] || record.run_id !== control.meta.run_id
           || record.gate !== gate || record.artefact_digest !== (observedRaw = rawFileDigest(row.path)) || envelope.digest !== presentation[2]
           || receipt.length === 1 && record.revision_id !== receipt[0].binding.expected_revision_id
           || digest(JSON.stringify(record)) !== envelope.digest) return unconfirmed();
-      if ([3, 4, 5].includes(record.schema_version) && rawFileDigest(`.agdf/control/runs/${control.meta.run_id}/presentations/${presentation[1]}.document`) !== record.document_digest) return unconfirmed();
-      if (record.schema_version === 5 && !previewProof(record, { rawFileDigest, fileDigest })) return unconfirmed();
+      if (rawFileDigest(`${runControlPath(control.meta.run_id, 'presentations')}/${presentation[1]}.document`) !== record.document_digest) return unconfirmed();
+      if (record.preview_review && !previewProof(record, { rawFileDigest, fileDigest })) return unconfirmed();
     } catch { return unconfirmed(); }
   return { confirmed: true, reason: null, path: row.path, artefact_digest: actual, raw_digest: observedRaw };
 }
 
 // Local reviewed attestation: explicit exact mapping, never prose or inferred gate order.
-export function validateBindingProof(root, receipt, { fileDigest = path => artefactFileDigest(root, path), readJson = path => readContainedJson(root, path), historical = false } = {}) {
-  if ([receipt.destination, receipt.source, receipt.review].some(file => !historical && hasSymlinkComponent(root, file.path)
-        || fileDigest(file.path) !== file.digest)) return false;
-  try {
-    const proof = readJson(receipt.review.path);
-    return exactObject(proof, REVIEW_PROOF_FIELDS)
-      && proof.schema_version === "1" && proof.reviewed === true && proof.target_id === receipt.target_id && proof.run_id === receipt.run_id
-      && proof.reviewer === receipt.review.reviewer
-      && canonicalJson(proof.relationship) === canonicalJson(receipt.relationship)
-      && canonicalJson(proof.destination) === canonicalJson(receipt.destination)
-      && canonicalJson(proof.source) === canonicalJson(receipt.source);
-  } catch { return false; }
+export function validateBindingProof(root, receipt, { fileDigest = path => artefactFileDigest(root, path), historical = false } = {}) {
+  return validArtefactBinding(receipt) && receipt.review.reviewed === true
+    && [receipt.destination, receipt.source].every(file => (historical || !hasSymlinkComponent(root, file.path)) && fileDigest(file.path) === file.digest);
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/artefact-bindings.js

@@ -1,3 +1,5 @@
+import { runDocumentPath } from './run-identity.js';
+import { resolutionRecord } from './input-resolution.js';
 import { TextDecoder } from "node:util";
 import { canonicalJson, digest, DIGEST_PATTERN, exactObject } from "./approval-command-contract.js";
 import { REVISION_ID_PATTERN, RUN_ID_PATTERN } from "./run-identity.js";
@@ -14,25 +16,26 @@ export const artefactBindingDigest = receipt => digest(`agdf-artefact-binding/1\
 // One current binding per run relationship, whichever checkout recorded it.
 export const artefactBindingKey = receipt => canonicalJson([receipt.run_id, receipt.relationship]);
 
+export const ARTEFACT_BINDING_VERSION = '3';
 export function validArtefactBinding(receipt) {
-  if (!exactObject(receipt, fields) || !["1", "2"].includes(receipt.schema_version) || !uuid(receipt.binding_id)
+  receipt = resolutionRecord(receipt);
+  if (!receipt) return false;
+  if (!exactObject(receipt, fields) || receipt.schema_version !== ARTEFACT_BINDING_VERSION || !uuid(receipt.binding_id)
       || !DIGEST_PATTERN.test(receipt.target_id ?? "") || !RUN_ID_PATTERN.test(receipt.run_id ?? "")
       || !exactObject(receipt.relationship, ["from", "relationship", "to"])
       || !file(receipt.destination, ["type", "path", "digest", "status"])
       || !file(receipt.source, ["type", "path", "digest"])
-      || !exactObject(receipt.review, ["reviewer", "path", "digest"]) || !text(receipt.review.reviewer)
-      || !isSafeControlRelativePath(receipt.review.path) || !DIGEST_PATTERN.test(receipt.review.digest ?? "")
-      || receipt.origin !== "reviewed_mapping" || !exactObject(receipt.operation, ["id", "previous_revision_id", "resulting_revision_id", "revision", ...(receipt.schema_version === "2" ? ["request_digest"] : [])])
-      || receipt.schema_version === "2" && !DIGEST_PATTERN.test(receipt.operation.request_digest ?? "")
+      || !exactObject(receipt.review, ["reviewer", "reviewed"]) || !text(receipt.review.reviewer) || receipt.review.reviewed !== true
+      || receipt.origin !== "reviewed_mapping" || !exactObject(receipt.operation, ["id", "previous_revision_id", "resulting_revision_id", "revision", "request_digest"])
+      || !DIGEST_PATTERN.test(receipt.operation.request_digest ?? "")
       || ![receipt.operation.id, receipt.operation.previous_revision_id, receipt.operation.resulting_revision_id].every(uuid)
       || receipt.operation.previous_revision_id === receipt.operation.resulting_revision_id
       || !Number.isSafeInteger(receipt.operation.revision) || receipt.operation.revision < 2
       || !(receipt.supersedes === null || uuid(receipt.supersedes))) return false;
   const expected = deliveryRelationships.find(row => row.requiredBy !== "UR" && sameRelationship(receipt.relationship, row));
   if (!expected || receipt.destination.type !== expected.from || receipt.source.type !== expected.to) return false;
-  const prefix = `.agdf/control/artefacts/${receipt.run_id}/`;
+  const prefix = `${runDocumentPath(receipt.run_id, '')}/`;
   return receipt.destination.path === `${prefix}${expected.from}.md` && receipt.source.path === `${prefix}${expected.to}.md`
-    && receipt.review.path.startsWith(prefix) && receipt.review.path !== receipt.destination.path && receipt.review.path !== receipt.source.path
     && (expected.requiredBy === "QA" ? ["pass", "revise", "block"].includes(receipt.destination.status) : receipt.destination.status === "draft");
 }