create-agdf 0.20.2 → 0.31.0

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");
 }
 

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/authoring-text-handoff.js

@@ -0,0 +1,3 @@
+// Shared guidance for passing authored bytes; never an additional file reader,
+// an authoring result or authority to record an artefact.
+export const AUTHORING_TEXT_HANDOFF = 'Pass Markdown as UTF-8 string data, never executable code. Prefer structured tool input. If the host uses JavaScript, author with its file-editing tool and pass a UTF-8 file read as content; never embed the document in backtick literals.';