ai-delivery-workflow 0.5.0 → 0.6.0

package/lib/delivery-state.mjs

@@ -1,13 +1,12 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import zlib from "node:zlib";
 import {
   historyAnchorId,
   readVerifiedHistoryAnchor,
   structuredDocumentChecksum,
 } from "./history-anchor.mjs";
-import { assertPathInside, atomicWrite } from "./fs-utils.mjs";
+import { atomicWrite } from "./fs-utils.mjs";
 
 const SEVEN_NODE_DEVELOPMENT_IDS = [
   "00-bootstrap",
@@ -18,27 +17,6 @@ const SEVEN_NODE_DEVELOPMENT_IDS = [
   "05-candidate-assurance",
   "06-version-closeout",
 ];
-const LEGACY_DEVELOPMENT_IDS = [
-  "01-product-discovery",
-  "02-product-definition",
-  "03-architecture-initial",
-  "04-experience-design",
-  "05-architecture-reconcile",
-  "06-platform-preparation",
-  "07-iteration-planning",
-  "08-test-design",
-  "09-development",
-  "10-change-review",
-  "11-candidate-verification",
-  "12-version-closeout",
-];
-const LEGACY_PRODUCTION_IDS = [
-  "12-release-preparation",
-  "13-production-approval",
-  "14-production-deployment",
-  "15-production-verification",
-  "16-version-archive",
-];
 const RELEASE_NODE_IDS = [
   "R00-release-request",
   "R01-version-selection",
@@ -54,12 +32,9 @@ const RELEASE_NODE_IDS = [
 ];
 const NODE_IDS = new Set([
   ...SEVEN_NODE_DEVELOPMENT_IDS,
-  ...LEGACY_DEVELOPMENT_IDS,
-  ...LEGACY_PRODUCTION_IDS,
   ...RELEASE_NODE_IDS,
 ]);
 const SEVEN_NODE_DEVELOPMENT_ID_SET = new Set(SEVEN_NODE_DEVELOPMENT_IDS);
-const LEGACY_DEVELOPMENT_ID_SET = new Set(LEGACY_DEVELOPMENT_IDS);
 const RELEASE_NODE_ID_SET = new Set(RELEASE_NODE_IDS);
 const ARTIFACT_STATUSES = new Set([
   "draft",
@@ -86,10 +61,9 @@ const ARTIFACT_STATUSES = new Set([
 ]);
 const WORKING_DRAFT_STATUSES = new Set(["draft", "review-draft"]);
 const GATE_DECISIONS = new Set(["approved", "rejected", "blocked", "not-required"]);
-const UX_GATE_IDS = new Set(["UX-LF", "UX-VS", "UX-UI"]);
-const RETIRED_GATE_IDS = new Set(["UX-LF"]);
-const UX_GATE_NODES = new Set(["02-solution-design", "04-experience-design"]);
-const PRODUCT_TERMINAL_NODES = new Set(["01-product-shaping", "02-product-definition"]);
+const UX_GATE_IDS = new Set(["UX-VS", "UX-UI"]);
+const UX_GATE_NODES = new Set(["02-solution-design"]);
+const PRODUCT_TERMINAL_NODES = new Set(["01-product-shaping"]);
 const SUCCESSFUL_ARTIFACT_STATUSES = new Set([
   "approved", "valid", "frozen", "immutable", "passed", "deployed", "released",
   "release-ready", "included-in-release", "archived",
@@ -102,18 +76,6 @@ const NODE_RULES = new Map([
   ["04-implementation", { scope: "development", prerequisites: ["03-delivery-readiness"], gates: [] }],
   ["05-candidate-assurance", { scope: "development", prerequisites: ["04-implementation"], gates: [] }],
   ["06-version-closeout", { scope: "development", prerequisites: ["05-candidate-assurance"], gates: [] }],
-  ["01-product-discovery", { scope: "development", prerequisites: ["00-bootstrap"], gates: ["GATE-A"] }],
-  ["02-product-definition", { scope: "development", prerequisites: ["01-product-discovery"], gates: ["GATE-B"] }],
-  ["03-architecture-initial", { scope: "development", prerequisites: ["02-product-definition"], gates: [] }],
-  ["04-experience-design", { scope: "development", prerequisites: ["03-architecture-initial"], gates: ["UX-LF", "UX-VS", "UX-UI"] }],
-  ["05-architecture-reconcile", { scope: "development", prerequisites: ["04-experience-design"], gates: [] }],
-  ["06-platform-preparation", { scope: "development", prerequisites: ["03-architecture-initial"], gates: [] }],
-  ["07-iteration-planning", { scope: "development", prerequisites: ["05-architecture-reconcile", "06-platform-preparation"], gates: [] }],
-  ["08-test-design", { scope: "development", prerequisites: ["07-iteration-planning"], gates: [] }],
-  ["09-development", { scope: "development", prerequisites: ["08-test-design"], gates: [] }],
-  ["10-change-review", { scope: "development", prerequisites: ["09-development"], gates: [] }],
-  ["11-candidate-verification", { scope: "development", prerequisites: ["10-change-review"], gates: [] }],
-  ["12-version-closeout", { scope: "development", prerequisites: ["11-candidate-verification"], gates: [] }],
   ["R00-release-request", { scope: "release", prerequisites: [], gates: [] }],
   ["R01-version-selection", { scope: "release", prerequisites: ["R00-release-request"], gates: [] }],
   ["R02-release-eligibility", { scope: "release", prerequisites: ["R01-version-selection"], gates: [] }],
@@ -129,15 +91,12 @@ const NODE_RULES = new Map([
 const WRITABLE_NODE_IDS = new Set([...SEVEN_NODE_DEVELOPMENT_IDS, ...RELEASE_NODE_IDS]);
 const SCOPED_COMPLETION_NODES = new Set([
   "03-delivery-readiness", "04-implementation", "05-candidate-assurance", "06-version-closeout",
-  "07-iteration-planning", "08-test-design", "09-development",
-  "10-change-review", "11-candidate-verification", "12-version-closeout",
 ]);
 const CANDIDATE_REQUIRED_NODES = new Set([
   "04-implementation", "05-candidate-assurance", "06-version-closeout",
-  "11-candidate-verification", "12-version-closeout",
 ]);
 const CANDIDATE_BOUND_NODES = new Set(["05-candidate-assurance", "06-version-closeout"]);
-const SCOPE_FREEZE_NODES = new Set(["03-delivery-readiness", "07-iteration-planning"]);
+const SCOPE_FREEZE_NODES = new Set(["03-delivery-readiness"]);
 const SLICE_BUDGET_LIMITS = new Map([
   ["logical-tasks", 8],
   ["active-hours", 8],
@@ -170,7 +129,7 @@ function parseArgs(argv) {
 }
 
 function lifecycleDescriptor(command, positional, flags) {
-  if (command === "artifact" && new Set(["register", "status"]).has(positional[1])) {
+  if (command === "artifact" && positional[1] === "register") {
     return {
       kind: "artifact",
       action: `artifact-${positional[1]}`,
@@ -202,26 +161,12 @@ function lifecycleDescriptor(command, positional, flags) {
   };
 }
 
-function assertNotLegacyDevelopmentNode(node) {
-  if (LEGACY_DEVELOPMENT_ID_SET.has(node)) {
-    throw new Error(`Legacy workflow node is read-only: ${node}`);
-  }
+function assertWritableNode(node) {
+  if (!WRITABLE_NODE_IDS.has(node)) throw new Error(`Unsupported workflow node: ${node}`);
   return node;
 }
 
-function assertGateContractWritable(gateId) {
-  if (RETIRED_GATE_IDS.has(gateId)) {
-    throw new Error(`${gateId} Gate contract is retired; historical records remain read-only.`);
-  }
-}
-
-function assertRetiredGateContract(gateId) {
-  if (!RETIRED_GATE_IDS.has(gateId)) {
-    throw new Error(`Gate contract is not retired: ${gateId}.`);
-  }
-}
-
-function assertNoLegacyDevelopmentWrite(files, command, positional, flags, options) {
+function assertCurrentNodeInputs(files, command, positional, flags, options) {
   let node = null;
   if ((command === "artifact" && positional[1] === "register")
     || (command === "gate" && positional[1] === "request")) {
@@ -250,7 +195,7 @@ function assertNoLegacyDevelopmentWrite(files, command, positional, flags, optio
       }
     }
   }
-  assertNotLegacyDevelopmentNode(node);
+  if (node) assertWritableNode(node);
 }
 
 function dispatchLifecycle(options, files, descriptor, phase, flags, result = null, error = null) {
@@ -484,9 +429,7 @@ function statePaths(projectRoot) {
     events: path.join(delivery, "state-events.jsonl"),
     eventShards: path.join(workflow, "control", "events"),
     historySnapshots: path.join(workflow, "control", "snapshots", "formal-state"),
-    artifactHistoryArchives: path.join(workflow, "control", "archives", "history", "artifact-registry"),
     artifactRetention: path.join(workflow, "control", "retention", "artifact-registry"),
-    compactRuntime: path.join(delivery, "runtime", "formal-state-compact"),
     pruneRuntime: path.join(delivery, "runtime", "formal-state-prune"),
     lockRoot: path.join(delivery, "runtime", "formal-state-locks"),
     transactionJournal: path.join(delivery, "runtime", "formal-state-locks", "formal-state-transaction.json"),
@@ -517,9 +460,6 @@ function normalizeScope(value, scopeId = null) {
     node_completion_receipts: Array.isArray(value?.node_completion_receipts)
       ? value.node_completion_receipts
       : [],
-    contract_retirement_receipts: Array.isArray(value?.contract_retirement_receipts)
-      ? value.contract_retirement_receipts
-      : [],
     latest_candidate_id: value?.latest_candidate_id ?? null,
     latest_release_id: value?.latest_release_id ?? null,
     updated_at: value?.updated_at ?? "",
@@ -545,67 +485,30 @@ export function findIncompatibleNodeStates(scope) {
     .map(([node, states]) => ({ node, states: [...states] }));
 }
 
-function exposeLegacyScopeAliases(state) {
-  const preferred = state.last_transition?.scope === "release"
-    ? state.release_state
-    : state.development_state.scope_id ? state.development_state : state.release_state;
-  const aliases = {
-    iteration_id: preferred.scope_id,
-    active_nodes: preferred.active_nodes,
-    blocked_nodes: preferred.blocked_nodes,
-    completed_nodes: preferred.completed_nodes,
-    pending_gates: preferred.pending_gates,
-    gate_decisions: preferred.gate_decisions,
-    latest_candidate_id: state.development_state.latest_candidate_id
-      || state.release_state.latest_candidate_id,
-    latest_release_id: state.release_state.latest_release_id,
-  };
-  for (const [key, alias] of Object.entries(aliases)) {
-    Object.defineProperty(state, key, { value: alias, enumerable: false, configurable: true });
-  }
-  return state;
-}
-
 function normalizeWorkflowState(value) {
-  const legacyNodes = [
-    ...(Array.isArray(value.active_nodes) ? value.active_nodes : []),
-    ...(Array.isArray(value.blocked_nodes) ? value.blocked_nodes : []),
-    ...(Array.isArray(value.completed_nodes) ? value.completed_nodes : []),
-  ];
-  const legacyRelease = legacyNodes.some((node) => String(node).startsWith("R"))
-    || String(value.iteration_id || "").startsWith("REL-");
-  const legacyScope = normalizeScope({
-    scope_id: value.iteration_id ?? null,
-    revision: value.revision ?? 0,
-    active_nodes: value.active_nodes,
-    blocked_nodes: value.blocked_nodes,
-    completed_nodes: value.completed_nodes,
-    pending_gates: value.pending_gates,
-    gate_decisions: value.gate_decisions,
-    latest_candidate_id: value.latest_candidate_id,
-    latest_release_id: value.latest_release_id,
-    updated_at: value.updated_at,
-    last_transition: value.last_transition,
-  });
+  if (value?.schema_version !== 2) {
+    throw new Error(`Formal workflow state schema ${value?.schema_version ?? "missing"} is unsupported; expected schema 2.`);
+  }
+  if (!value.development_state || !value.release_state
+    || Object.prototype.hasOwnProperty.call(value, "iteration_id")
+    || Object.prototype.hasOwnProperty.call(value, "active_nodes")
+    || Object.prototype.hasOwnProperty.call(value, "blocked_nodes")
+    || Object.prototype.hasOwnProperty.call(value, "completed_nodes")) {
+    throw new Error("Formal workflow state must use separate development_state and release_state scopes.");
+  }
   const state = {
-    schema_version: value.schema_version ?? 1,
-    revision: value.revision ?? 0,
+    schema_version: 2,
+    revision: value.revision,
     project_id: value.project_id ?? null,
-    development_state: normalizeScope(
-      value.development_state || (!legacyRelease ? legacyScope : null),
-      !legacyRelease ? value.iteration_id ?? null : null,
-    ),
-    release_state: normalizeScope(
-      value.release_state || (legacyRelease ? legacyScope : null),
-      legacyRelease ? value.iteration_id ?? null : null,
-    ),
+    development_state: normalizeScope(value.development_state),
+    release_state: normalizeScope(value.release_state),
     latest_line_version_id: value.latest_line_version_id ?? null,
     production_version_id: value.production_version_id ?? null,
     production_release_id: value.production_release_id ?? null,
     updated_at: value.updated_at ?? "",
     last_transition: value.last_transition ?? null,
   };
-  return exposeLegacyScopeAliases(state);
+  return state;
 }
 
 function scopeNameForNode(node) {
@@ -660,10 +563,6 @@ function completionReceiptChecksum(receipt) {
   return checksumWithoutField(receipt, "receipt_checksum");
 }
 
-function contractRetirementReceiptChecksum(receipt) {
-  return checksumWithoutField(receipt, "receipt_checksum");
-}
-
 function currentScopeManifest(scope) {
   if (!scope.current_scope_manifest_id) return null;
   return scope.scope_manifests.find((manifest) => manifest?.manifest_id === scope.current_scope_manifest_id) || null;
@@ -895,7 +794,7 @@ const FORMAL_STREAMS = new Map([
     viewFile: (files) => files.workflowState,
     normalize: normalizeWorkflowState,
     applyOperations: applyWorkflowStateOperations,
-    allowedSchemas: new Set([1, 2]),
+    allowedSchemas: new Set([2]),
   }],
   ["artifact-registry", {
     snapshotFile: "artifact-registry.yaml",
@@ -1225,14 +1124,15 @@ function prepareStreamMutation(files, mutation, options, transactionId) {
     ...event,
     after_checksum: sha256(serialized),
   };
-  const shardRecord = transaction
-    ? {
-      ...eventRecord,
-      transaction_id: transactionId,
-      ...transaction,
-      previous_checksum: previousStreamChecksum(files, stream, transaction.before_revision, options),
-    }
-    : { ...eventRecord, after_value: value };
+  if (!transaction || transaction.schema_version !== 2 || !Array.isArray(transaction.operations)) {
+    throw new Error(`Formal ${stream} mutations require a schema 2 delta transaction.`);
+  }
+  const shardRecord = {
+    ...eventRecord,
+    transaction_id: transactionId,
+    ...transaction,
+    previous_checksum: previousStreamChecksum(files, stream, transaction.before_revision, options),
+  };
   const record = {
     ...shardRecord,
     record_checksum: unsignedRecordChecksum(shardRecord, options.yaml),
@@ -1365,9 +1265,7 @@ function replayStreamRecords(stream, records, options, base = {}) {
     if (record.revision !== previousRevision + 1) {
       throw new Error(`Formal event shard revision gap: ${stream}/${record.revision}; expected ${previousRevision + 1}.`);
     }
-    if (record.after_value) {
-      value = record.after_value;
-    } else if (record.schema_version === 2 && Array.isArray(record.operations)) {
+    if (record.schema_version === 2 && Array.isArray(record.operations)) {
       if (record.before_revision !== record.revision - 1 || record.after_revision !== record.revision) {
         throw new Error(`Formal event shard revision metadata mismatch: ${stream}/${record.revision}.`);
       }
@@ -1398,7 +1296,7 @@ function replayStreamRecords(stream, records, options, base = {}) {
 function validateEventShardRecord(record, stream, name) {
   const expectedName = `${String(record.revision).padStart(6, "0")}-${record.event_id}.yaml`;
   if (record.stream !== stream || !Number.isInteger(record.revision) || !record.event_id
-    || name !== expectedName || (!record.after_value && !Array.isArray(record.operations))) {
+    || record.schema_version !== 2 || !Array.isArray(record.operations)) {
     throw new Error(`Formal event shard is invalid: ${stream}/${name}`);
   }
   return record;
@@ -1720,8 +1618,7 @@ function createFormalSnapshot(files, flags, options) {
 function rebuildFormalViews(files, options) {
   return withLock(files, "formal-state-rebuild", () => {
     const retentionReceipts = readArtifactRetentionReceipts(files, options);
-    const historyArchives = readArtifactHistoryArchives(files, options);
-    if (retentionReceipts.length || historyArchives.length) {
+    if (retentionReceipts.length) {
       const trusted = readLatestHistoryAnchor(files, options);
       if (!trusted) throw new Error("Retained history rebuild requires a trusted history anchor.");
       const errors = [];
@@ -1769,17 +1666,13 @@ function rebuildFormalViews(files, options) {
     }
     const records = readEventShards(files, options);
     if (!records.length) {
-      return { command: "rebuild", rebuilt: false, event_shard_count: 0, message: "No formal event shards exist; legacy views were left unchanged." };
+      return { command: "rebuild", rebuilt: false, event_shard_count: 0, message: "No formal event shards exist; current views were left unchanged." };
     }
     const workflowRecords = records.filter((record) => record.stream === "workflow-state");
     const registryRecords = records.filter((record) => record.stream === "artifact-registry");
     const workflow = workflowRecords.length ? replayStreamRecords("workflow-state", workflowRecords, options) : null;
     const registry = registryRecords.length ? replayStreamRecords("artifact-registry", registryRecords, options) : null;
-    const index = records.map((record) => {
-      const { after_value: ignored, ...indexed } = record;
-      if (record.after_value) delete indexed.record_checksum;
-      return JSON.stringify(indexed);
-    }).join("\n");
+    const index = records.map((record) => JSON.stringify(record)).join("\n");
     const writes = [{ file: files.events, content: `${index}\n` }];
     if (workflow) writes.unshift({ file: files.workflowState, content: options.yaml.stringify(workflow) });
     if (registry) writes.unshift({ file: files.artifactRegistry, content: options.yaml.stringify(registry) });
@@ -1848,7 +1741,7 @@ function registerArtifact(files, flags, options) {
       }
     }
     const node = requiredFlag(flags, "--node");
-    assertNotLegacyDevelopmentNode(node);
+    assertWritableNode(node);
     if (!NODE_IDS.has(node)) throw new Error(`Unknown workflow node: ${node}`);
     const artifactScope = scopeNameForNode(node);
     const artifactScopeState = scopeState(workflowState, artifactScope);
@@ -1921,63 +1814,6 @@ function registerArtifact(files, flags, options) {
   }, { waitForActive: true });
 }
 
-function changeArtifactStatus(files, flags, options) {
-  const expected = expectedRevision(flags);
-  return withLock(files, "artifact-registry", () => {
-    const registry = normalizeArtifactRegistry(
-      readYaml(files.artifactRegistry, options.yaml, "artifact-registry.yaml"),
-    );
-    if (registry.revision !== expected) {
-      throw new Error(`Artifact registry revision conflict: expected ${expected}, actual ${registry.revision}.`);
-    }
-    const artifactId = requiredFlag(flags, "--id");
-    const artifact = registry.artifacts.find((item) => (item.artifact_id || item.id) === artifactId);
-    if (!artifact) throw new Error(`Artifact is not registered: ${artifactId}`);
-    const status = artifactStatus(flags);
-    const evidence = repeatedFlag(flags, "--evidence");
-    if (!evidence.length) throw new Error("artifact status requires at least one --evidence reference.");
-    if (artifact.status === status) throw new Error(`Artifact already has status ${status}: ${artifactId}`);
-    if (!WORKING_DRAFT_STATUSES.has(artifact.status)) {
-      throw new Error(`Immutable artifact revision cannot change status: ${artifact.status}`);
-    }
-    if (WORKING_DRAFT_STATUSES.has(status)) {
-      throw new Error("Legacy draft migration must target an immutable semantic status.");
-    }
-
-    const timestamp = (options.now || (() => new Date().toISOString()))();
-    const previous = artifact.status || "unknown";
-    artifact.status = status;
-    artifact.status_history = [
-      ...(Array.isArray(artifact.status_history) ? artifact.status_history : []),
-      { from: previous, to: status, evidence, changed_at: timestamp },
-    ];
-    registry.schema_version = 1;
-    registry.revision += 1;
-    registry.updated_at = timestamp;
-    const event = {
-      type: "artifact-status-changed",
-      occurred_at: timestamp,
-      artifact_id: artifactId,
-      from: previous,
-      to: status,
-      evidence,
-    };
-    commitFormalTransaction(files, [{
-      stream: "artifact-registry",
-      file: files.artifactRegistry,
-      value: registry,
-      event,
-      transaction: artifactRegistryTransaction(event, registry, expected, [artifact]),
-    }], [], options);
-    return {
-      command: "artifact status",
-      revision: registry.revision,
-      artifact,
-      artifact_registry: registry,
-    };
-  }, { waitForActive: true });
-}
-
 function recoverArtifactPrune(files, apply, options) {
   if (!fs.existsSync(files.pruneRuntime)) return 0;
   const pending = fs.readdirSync(files.pruneRuntime, { withFileTypes: true })
@@ -2039,490 +1875,6 @@ function recoverArtifactPrune(files, apply, options) {
   return recovered;
 }
 
-function legacyArtifactHistoryArchive(files, trusted, options) {
-  verifyFormalState(files, options, { history: true });
-  const anchoredRevision = trusted.anchor.streams["artifact-registry"].revision;
-  const shardDirectory = path.join(files.eventShards, "artifact-registry");
-  const legacyShards = fs.existsSync(shardDirectory)
-    ? fs.readdirSync(shardDirectory)
-      .filter((name) => /\.ya?ml$/i.test(name))
-      .map((name) => ({
-        name,
-        file: path.join(shardDirectory, name),
-        record: readEventShardRecord(files, options, "artifact-registry", name),
-      }))
-      .filter(({ record }) => record.after_value && record.revision <= anchoredRevision)
-      .sort((left, right) => left.record.revision - right.record.revision)
-    : [];
-  if (!legacyShards.length) {
-    throw new Error("Legacy artifact history compact requires anchored full-snapshot shards.");
-  }
-  const replayed = replayStreamRecords(
-    "artifact-registry",
-    legacyShards.map(({ record }) => record),
-    options,
-  );
-  const anchoredRegistry = trusted.snapshots["artifact-registry"];
-  if (JSON.stringify(stableValue(normalizeArtifactRegistry(replayed)))
-    !== JSON.stringify(stableValue(normalizeArtifactRegistry(anchoredRegistry)))) {
-    throw new Error("Legacy artifact history replay does not reproduce the anchored registry.");
-  }
-  const finalRecord = legacyShards.at(-1).record;
-  const anchoredChecksum = trusted.anchor.streams["artifact-registry"].view_checksum;
-  if (finalRecord.revision !== anchoredRevision || finalRecord.after_checksum !== anchoredChecksum) {
-    throw new Error("Legacy artifact history replay does not reproduce the anchored registry checksum.");
-  }
-
-  const digest = crypto.createHash("sha256");
-  const entries = legacyShards.map(({ name, file, record }) => {
-    const content = fs.readFileSync(file);
-    digest.update(name);
-    digest.update("\0");
-    digest.update(content);
-    digest.update("\0");
-    return {
-      path: name,
-      revision: record.revision,
-      size_bytes: content.length,
-      sha256: sha256(content),
-      content_base64: content.toString("base64"),
-    };
-  });
-  const sourceHistoryRootDigest = digest.digest("hex");
-  const coverage = {
-    first_revision: legacyShards[0].record.revision,
-    last_revision: finalRecord.revision,
-    event_count: legacyShards.length,
-  };
-  const archiveId = trusted.anchor.anchor_id;
-  const bundle = stableValue({
-    schema_version: 1,
-    archive_id: archiveId,
-    stream: "artifact-registry",
-    source_root: portableReference(files, shardDirectory),
-    source_history_root_digest: sourceHistoryRootDigest,
-    source_history_root_digest_algorithm: "sha256-path-null-bytes-null-v1",
-    coverage,
-    anchor: {
-      anchor_id: trusted.anchor.anchor_id,
-      anchor_checksum: trusted.anchor.anchor_checksum,
-      registry_revision: anchoredRevision,
-      registry_checksum: anchoredChecksum,
-    },
-    entries,
-  });
-  const archiveBytes = zlib.gzipSync(Buffer.from(`${JSON.stringify(bundle, null, 2)}\n`), {
-    level: 9,
-    mtime: 0,
-  });
-  const archiveFile = path.join(files.artifactHistoryArchives, `${archiveId}.json.gz`);
-  const manifestFile = path.join(files.artifactHistoryArchives, `${archiveId}.yaml`);
-  const looseBytes = entries.reduce((total, entry) => total + entry.size_bytes, 0);
-  const compactedAt = (options.now || (() => new Date().toISOString()))();
-  const manifestBase = stableValue({
-    schema_version: 1,
-    archive_id: archiveId,
-    stream: "artifact-registry",
-    anchor_id: trusted.anchor.anchor_id,
-    anchor_checksum: trusted.anchor.anchor_checksum,
-    registry_revision: anchoredRevision,
-    registry_checksum: anchoredChecksum,
-    source_root: bundle.source_root,
-    source_history_root_digest: sourceHistoryRootDigest,
-    source_history_root_digest_algorithm: bundle.source_history_root_digest_algorithm,
-    coverage,
-    loose_file_count: entries.length,
-    loose_bytes: looseBytes,
-    archive_format: "gzip-json-v1",
-    archive_path: portableReference(files, archiveFile),
-    archive_checksum: sha256(archiveBytes),
-    compressed_bundle_bytes: archiveBytes.length,
-    compacted_at: compactedAt,
-  });
-  const manifest = {
-    ...manifestBase,
-    manifest_checksum: sha256(options.yaml.stringify(manifestBase)),
-  };
-  const manifestContent = options.yaml.stringify(stableValue(manifest));
-  const archiveStorageBytes = archiveBytes.length + Buffer.byteLength(manifestContent);
-  return {
-    bundle,
-    archiveBytes,
-    archiveFile,
-    entries,
-    manifest,
-    manifestContent,
-    manifestFile,
-    report: {
-      command: "compact",
-      anchor_id: trusted.anchor.anchor_id,
-      anchor_checksum: trusted.anchor.anchor_checksum,
-      source_history_root_digest: sourceHistoryRootDigest,
-      coverage,
-      loose_file_count: entries.length,
-      loose_bytes: looseBytes,
-      compressed_bundle_bytes: archiveBytes.length,
-      manifest_bytes: Buffer.byteLength(manifestContent),
-      archive_bytes: archiveStorageBytes,
-      expected_freed_bytes: looseBytes - archiveStorageBytes,
-      archive_path: portableReference(files, archiveFile),
-      manifest_path: portableReference(files, manifestFile),
-    },
-  };
-}
-
-function readArtifactHistoryArchives(files, options) {
-  assertPathInside(files.root, files.artifactHistoryArchives);
-  if (!fs.existsSync(files.artifactHistoryArchives)) return [];
-  return fs.readdirSync(files.artifactHistoryArchives)
-    .filter((name) => /\.ya?ml$/i.test(name))
-    .sort()
-    .map((name) => {
-      const manifestFile = path.join(files.artifactHistoryArchives, name);
-      const manifest = readYaml(manifestFile, options.yaml, `artifact history archive manifest ${name}`);
-      const archiveId = historyAnchorId(manifest.archive_id);
-      const expectedManifestName = `${archiveId}.yaml`;
-      const archiveFile = path.join(files.artifactHistoryArchives, `${archiveId}.json.gz`);
-      const coverage = manifest.coverage;
-      if (name !== expectedManifestName
-        || manifest.schema_version !== 1
-        || manifest.stream !== "artifact-registry"
-        || manifest.anchor_id !== archiveId
-        || manifest.archive_format !== "gzip-json-v1"
-        || manifest.archive_path !== portableReference(files, archiveFile)
-        || !/^[a-f0-9]{64}$/.test(manifest.anchor_checksum || "")
-        || !/^[a-f0-9]{64}$/.test(manifest.registry_checksum || "")
-        || !/^[a-f0-9]{64}$/.test(manifest.source_history_root_digest || "")
-        || manifest.source_history_root_digest_algorithm !== "sha256-path-null-bytes-null-v1"
-        || !/^[a-f0-9]{64}$/.test(manifest.archive_checksum || "")
-        || !Number.isSafeInteger(manifest.registry_revision)
-        || manifest.registry_revision < 1
-        || !Number.isSafeInteger(coverage?.first_revision)
-        || !Number.isSafeInteger(coverage?.last_revision)
-        || !Number.isSafeInteger(coverage?.event_count)
-        || coverage.first_revision < 1
-        || coverage.last_revision < coverage.first_revision
-        || coverage.event_count !== coverage.last_revision - coverage.first_revision + 1
-        || coverage.last_revision !== manifest.registry_revision
-        || !Number.isSafeInteger(manifest.loose_file_count)
-        || manifest.loose_file_count !== coverage.event_count
-        || !Number.isSafeInteger(manifest.loose_bytes)
-        || manifest.loose_bytes < 0
-        || !Number.isSafeInteger(manifest.compressed_bundle_bytes)
-        || manifest.compressed_bundle_bytes < 1
-        || structuredDocumentChecksum(manifest, "manifest_checksum", options.yaml.stringify)
-          !== manifest.manifest_checksum
-        || !fs.existsSync(archiveFile)
-        || fs.statSync(archiveFile).size !== manifest.compressed_bundle_bytes
-        || sha256(fs.readFileSync(archiveFile)) !== manifest.archive_checksum) {
-        throw new Error(`Artifact history archive manifest is invalid: ${name}.`);
-      }
-      let bundle;
-      try {
-        bundle = JSON.parse(zlib.gunzipSync(fs.readFileSync(archiveFile)).toString("utf8"));
-      } catch {
-        throw new Error(`Artifact history archive bundle is invalid: ${archiveId}.`);
-      }
-      if (bundle?.schema_version !== 1
-        || bundle.archive_id !== archiveId
-        || bundle.stream !== "artifact-registry"
-        || bundle.source_root !== manifest.source_root
-        || bundle.source_history_root_digest !== manifest.source_history_root_digest
-        || bundle.source_history_root_digest_algorithm !== manifest.source_history_root_digest_algorithm
-        || JSON.stringify(bundle.coverage) !== JSON.stringify(manifest.coverage)
-        || bundle.anchor?.anchor_id !== manifest.anchor_id
-        || bundle.anchor?.anchor_checksum !== manifest.anchor_checksum
-        || bundle.anchor?.registry_revision !== manifest.registry_revision
-        || bundle.anchor?.registry_checksum !== manifest.registry_checksum
-        || !Array.isArray(bundle.entries)
-        || bundle.entries.length !== manifest.loose_file_count) {
-        throw new Error(`Artifact history archive bundle metadata is invalid: ${archiveId}.`);
-      }
-      const digest = crypto.createHash("sha256");
-      const names = new Set();
-      let entryBytes = 0;
-      const records = bundle.entries.map((entry, index) => {
-        if (!/^[^/\\]+\.ya?ml$/i.test(entry?.path || "") || names.has(entry.path)) {
-          throw new Error(`Artifact history archive entry path is invalid: ${archiveId}.`);
-        }
-        names.add(entry.path);
-        if (!Number.isSafeInteger(entry.size_bytes) || entry.size_bytes < 0
-          || !Number.isSafeInteger(entry.revision)
-          || entry.revision !== coverage.first_revision + index) {
-          throw new Error(`Artifact history archive entry metadata is invalid: ${archiveId}/${entry.path}.`);
-        }
-        const content = Buffer.from(String(entry.content_base64 || ""), "base64");
-        if (content.length !== entry.size_bytes || sha256(content) !== entry.sha256) {
-          throw new Error(`Artifact history archive entry checksum is invalid: ${archiveId}/${entry.path}.`);
-        }
-        entryBytes += entry.size_bytes;
-        digest.update(entry.path);
-        digest.update("\0");
-        digest.update(content);
-        digest.update("\0");
-        let record;
-        try {
-          record = options.yaml.parse(content.toString("utf8"));
-        } catch {
-          throw new Error(`Artifact history archive entry is unreadable: ${archiveId}/${entry.path}.`);
-        }
-        const validated = validateEventShardRecord(record, "artifact-registry", entry.path);
-        if (validated.revision !== entry.revision) {
-          throw new Error(`Artifact history archive entry revision is invalid: ${archiveId}/${entry.path}.`);
-        }
-        return validated;
-      });
-      if (digest.digest("hex") !== manifest.source_history_root_digest
-        || entryBytes !== manifest.loose_bytes
-        || records.length !== manifest.coverage?.event_count
-        || records[0]?.revision !== manifest.coverage?.first_revision
-        || records.at(-1)?.revision !== manifest.coverage?.last_revision
-        || records.some((record, index) => record.revision !== coverage.first_revision + index)) {
-        throw new Error(`Artifact history archive coverage is invalid: ${archiveId}.`);
-      }
-      const replayed = replayStreamRecords("artifact-registry", records, options);
-      const anchorFile = path.join(files.historySnapshots, archiveId, "anchor.yaml");
-      const snapshotFile = path.join(files.historySnapshots, archiveId, "artifact-registry.yaml");
-      const anchor = readYaml(anchorFile, options.yaml, `artifact history archive anchor ${archiveId}`);
-      const snapshot = normalizeArtifactRegistry(readYaml(
-        snapshotFile,
-        options.yaml,
-        `artifact history archive snapshot ${archiveId}`,
-      ));
-      if (anchor.anchor_checksum !== manifest.anchor_checksum
-        || structuredDocumentChecksum(anchor, "anchor_checksum", options.yaml.stringify)
-          !== anchor.anchor_checksum
-        || anchor.streams?.["artifact-registry"]?.revision !== manifest.registry_revision
-        || anchor.streams?.["artifact-registry"]?.view_checksum !== manifest.registry_checksum
-        || sha256(fs.readFileSync(snapshotFile)) !== manifest.registry_checksum
-        || JSON.stringify(stableValue(normalizeArtifactRegistry(replayed)))
-          !== JSON.stringify(stableValue(snapshot))) {
-        throw new Error(`Artifact history archive replay does not match its anchor: ${archiveId}.`);
-      }
-      return { manifest, manifestFile, archiveFile, bundle };
-    });
-}
-
-function restoreCompactionStaging(files, directory, plan) {
-  const shardDirectory = path.join(files.eventShards, "artifact-registry");
-  fs.mkdirSync(shardDirectory, { recursive: true });
-  for (const entry of plan.entries) {
-    const staged = path.join(directory, entry.path);
-    if (!fs.existsSync(staged)) continue;
-    if (sha256(fs.readFileSync(staged)) !== entry.sha256) {
-      throw new Error(`Artifact history compact staged shard checksum mismatch: ${entry.path}.`);
-    }
-    const destination = path.join(shardDirectory, entry.path);
-    if (fs.existsSync(destination)) {
-      if (sha256(fs.readFileSync(destination)) !== entry.sha256) {
-        throw new Error(`Artifact history compact recovery destination conflicts: ${entry.path}.`);
-      }
-      fs.rmSync(staged, { force: true });
-    } else {
-      fs.renameSync(staged, destination);
-    }
-  }
-}
-
-function recoverArtifactHistoryCompaction(files, apply, options) {
-  if (!fs.existsSync(files.compactRuntime)) return 0;
-  const pending = fs.readdirSync(files.compactRuntime, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => path.join(files.compactRuntime, entry.name));
-  if (pending.length && !apply) {
-    throw new Error("An interrupted artifact history compact requires explicit apply recovery.");
-  }
-  let recovered = 0;
-  for (const directory of pending) {
-    const planFile = path.join(directory, "plan.json");
-    if (!fs.existsSync(planFile)) {
-      const interruptedPlanWrites = fs.readdirSync(directory, { withFileTypes: true });
-      if (interruptedPlanWrites.every((entry) =>
-        entry.isFile() && /^plan\.json\.\d+\.\d+\.tmp$/.test(entry.name))) {
-        fs.rmSync(directory, { recursive: true, force: true });
-        recovered += 1;
-        continue;
-      }
-      throw new Error(`Artifact history compact recovery plan is invalid: ${directory}.`);
-    }
-    let plan;
-    try {
-      plan = JSON.parse(fs.readFileSync(planFile, "utf8"));
-    } catch {
-      throw new Error(`Artifact history compact recovery plan is invalid: ${directory}.`);
-    }
-    if (plan?.schema_version !== 1 || !plan.archive_id
-      || !/^[a-f0-9]{64}$/.test(plan.archive_checksum || "")
-      || !Array.isArray(plan.entries) || !plan.entries.length
-      || plan.entries.some((entry) => !/^[^/\\]+\.ya?ml$/i.test(entry?.path || "")
-        || !/^[a-f0-9]{64}$/.test(entry?.sha256 || ""))) {
-      throw new Error(`Artifact history compact recovery plan is invalid: ${directory}.`);
-    }
-    const plannedEntries = new Map(plan.entries.map((entry) => [entry.path, entry.sha256]));
-    const stagedEntries = fs.readdirSync(directory, { withFileTypes: true })
-      .filter((entry) => entry.name !== "plan.json");
-    if (plannedEntries.size !== plan.entries.length
-      || stagedEntries.some((entry) => !entry.isFile() || !plannedEntries.has(entry.name))) {
-      throw new Error(`Artifact history compact recovery plan is invalid: ${directory}.`);
-    }
-    const changedStagedEntry = stagedEntries.find((entry) =>
-      sha256(fs.readFileSync(path.join(directory, entry.name))) !== plannedEntries.get(entry.name));
-    if (changedStagedEntry) {
-      throw new Error(`Artifact history compact staged shard checksum mismatch: ${changedStagedEntry.name}.`);
-    }
-    let archive = null;
-    try {
-      archive = readArtifactHistoryArchives(files, options)
-        .find(({ manifest }) => manifest.archive_id === plan.archive_id) || null;
-    } catch {
-      archive = null;
-    }
-    const archivedEntries = new Map(
-      (archive?.bundle.entries || []).map((entry) => [entry.path, entry.sha256]),
-    );
-    const archiveMatches = archive?.manifest.archive_checksum === plan.archive_checksum
-      && plan.entries.every((entry) => archivedEntries.get(entry.path) === entry.sha256);
-    if (!archiveMatches) {
-      restoreCompactionStaging(files, directory, plan);
-      fs.rmSync(directory, { recursive: true, force: true });
-      throw new Error(`Artifact history compact recovery plan does not match its verified archive: ${plan.archive_id}.`);
-    }
-    fs.rmSync(directory, { recursive: true, force: true });
-    recovered += 1;
-  }
-  return recovered;
-}
-
-function removeCompactedLooseEntries(files, archiveId, archiveChecksum, entries) {
-  if (!entries.length) return;
-  const stagingDirectory = path.join(files.compactRuntime, crypto.randomUUID());
-  fs.mkdirSync(stagingDirectory, { recursive: true });
-  atomicWrite(path.join(stagingDirectory, "plan.json"), `${JSON.stringify({
-    schema_version: 1,
-    archive_id: archiveId,
-    archive_checksum: archiveChecksum,
-    entries: entries.map((entry) => ({ path: entry.path, sha256: entry.sha256 })),
-  }, null, 2)}\n`);
-  const shardDirectory = path.join(files.eventShards, "artifact-registry");
-  try {
-    for (const entry of entries) {
-      const source = path.join(shardDirectory, entry.path);
-      if (sha256(fs.readFileSync(source)) !== entry.sha256) {
-        throw new Error(`Artifact history shard changed during compact: ${entry.path}.`);
-      }
-      fs.renameSync(source, path.join(stagingDirectory, entry.path));
-    }
-    fs.rmSync(stagingDirectory, { recursive: true, force: true });
-  } catch (error) {
-    restoreCompactionStaging(files, stagingDirectory, { entries });
-    fs.rmSync(stagingDirectory, { recursive: true, force: true });
-    throw error;
-  }
-}
-
-function compactArtifactHistory(files, flags, options) {
-  const apply = flags.has("--apply");
-  const action = () => {
-    assertPathInside(files.root, files.artifactHistoryArchives);
-    assertPathInside(files.root, files.compactRuntime);
-    assertPathInside(files.root, path.join(files.eventShards, "artifact-registry"));
-    const recoveredCompactionCount = recoverArtifactHistoryCompaction(files, apply, options);
-    const trusted = readLatestHistoryAnchor(files, options);
-    if (!trusted) throw new Error("Legacy artifact history compact requires a trusted history anchor.");
-    const existingArchive = readArtifactHistoryArchives(files, options)
-      .find(({ manifest }) => manifest.archive_id === trusted.anchor.anchor_id);
-    if (existingArchive) {
-      verifyFormalState(files, options, { history: true });
-      const shardDirectory = path.join(files.eventShards, "artifact-registry");
-      const looseEntries = existingArchive.bundle.entries.filter((entry) => {
-        const looseFile = path.join(shardDirectory, entry.path);
-        if (!fs.existsSync(looseFile)) return false;
-        if (sha256(fs.readFileSync(looseFile)) !== entry.sha256) {
-          throw new Error(`Artifact history loose shard conflicts with verified archive: ${entry.path}.`);
-        }
-        return true;
-      });
-      const looseBytes = looseEntries.reduce((total, entry) => total + entry.size_bytes, 0);
-      const manifestBytes = fs.statSync(existingArchive.manifestFile).size;
-      const result = {
-        command: "compact",
-        anchor_id: existingArchive.manifest.anchor_id,
-        anchor_checksum: existingArchive.manifest.anchor_checksum,
-        source_history_root_digest: existingArchive.manifest.source_history_root_digest,
-        coverage: existingArchive.manifest.coverage,
-        loose_file_count: looseEntries.length,
-        loose_bytes: looseBytes,
-        compressed_bundle_bytes: existingArchive.manifest.compressed_bundle_bytes,
-        manifest_bytes: manifestBytes,
-        archive_bytes: existingArchive.manifest.compressed_bundle_bytes + manifestBytes,
-        expected_freed_bytes: looseBytes,
-        archive_path: existingArchive.manifest.archive_path,
-        manifest_path: portableReference(files, existingArchive.manifestFile),
-        mode: apply ? "apply" : "dry-run",
-        applied: false,
-        deduplicated: true,
-        recovered_compaction_count: recoveredCompactionCount,
-      };
-      if (!apply || !looseEntries.length) return result;
-      removeCompactedLooseEntries(
-        files,
-        trusted.anchor.anchor_id,
-        existingArchive.manifest.archive_checksum,
-        looseEntries,
-      );
-      return { ...result, applied: true };
-    }
-    const plan = legacyArtifactHistoryArchive(files, trusted, options);
-    const result = {
-      ...plan.report,
-      mode: apply ? "apply" : "dry-run",
-      applied: false,
-      deduplicated: false,
-      recovered_compaction_count: recoveredCompactionCount,
-    };
-    if (!apply) return result;
-    if (fs.existsSync(plan.manifestFile)) {
-      throw new Error(`Artifact history archive already exists: ${trusted.anchor.anchor_id}.`);
-    }
-    fs.mkdirSync(files.artifactHistoryArchives, { recursive: true });
-    const orphanArchiveExists = fs.existsSync(plan.archiveFile);
-    if (orphanArchiveExists
-      && (fs.statSync(plan.archiveFile).size !== plan.archiveBytes.length
-        || sha256(fs.readFileSync(plan.archiveFile)) !== plan.manifest.archive_checksum)) {
-      throw new Error(`Artifact history archive conflicts with the compact plan: ${trusted.anchor.anchor_id}.`);
-    }
-    let archiveWritten = false;
-    let manifestWritten = false;
-    try {
-      if (!orphanArchiveExists) {
-        atomicWrite(plan.archiveFile, plan.archiveBytes);
-        archiveWritten = true;
-      }
-      atomicWrite(plan.manifestFile, plan.manifestContent);
-      manifestWritten = true;
-      const verified = readArtifactHistoryArchives(files, options);
-      if (!verified.some(({ manifest }) => manifest.archive_id === trusted.anchor.anchor_id)) {
-        throw new Error(`Artifact history archive verification failed: ${trusted.anchor.anchor_id}.`);
-      }
-    } catch (error) {
-      if (manifestWritten) fs.rmSync(plan.manifestFile, { force: true });
-      if (archiveWritten) fs.rmSync(plan.archiveFile, { force: true });
-      throw error;
-    }
-
-    removeCompactedLooseEntries(
-      files,
-      trusted.anchor.anchor_id,
-      plan.manifest.archive_checksum,
-      plan.entries,
-    );
-    return { ...result, applied: true };
-  };
-  return apply
-    ? withLock(files, "artifact-history-compact", action)
-    : withZeroWriteFormalState(files, action);
-}
-
 function pruneArtifactHistory(files, flags, options) {
   const apply = flags.has("--apply");
   const action = () => {
@@ -2621,7 +1973,7 @@ function pruneArtifactHistory(files, flags, options) {
 }
 
 function allowedCompletionStatuses(node) {
-  if (node === "06-version-closeout" || node === "12-version-closeout") {
+  if (node === "06-version-closeout") {
     return new Set(["release-ready"]);
   }
   if (node === "R08-production-deployment") return new Set(["deployed"]);
@@ -2632,9 +1984,8 @@ function allowedCompletionStatuses(node) {
 
 function nodeModel(node) {
   if (SEVEN_NODE_DEVELOPMENT_ID_SET.has(node)) return "development-seven-node";
-  if (LEGACY_DEVELOPMENT_ID_SET.has(node)) return "development-legacy-13";
   if (RELEASE_NODE_ID_SET.has(node)) return "release-r00-r10";
-  return "legacy-production-read-only";
+  return "unknown";
 }
 
 function nodeContractCatalog() {
@@ -2730,7 +2081,6 @@ function persistScopeMutation(files, context, options) {
   const handoffMutation = artifactHandoffMutation(files, transition, timestamp, options);
   if (handoffMutation) mutations.push(handoffMutation);
   commitFormalTransaction(files, mutations, extraWrites, options);
-  exposeLegacyScopeAliases(state);
 }
 
 function scopeManifestFromFlags(flags, scope, timestamp, amendment) {
@@ -2782,7 +2132,7 @@ function mutateScopeManifest(files, flags, options, amendment = false) {
       && ![...SCOPE_FREEZE_NODES].some((node) =>
         scope.active_nodes.includes(node) || scope.completed_nodes.includes(node))) {
       throw new Error(
-        "scope freeze requires Delivery Readiness (03-delivery-readiness or legacy 07-iteration-planning) to be active or completed.",
+        "scope freeze requires Delivery Readiness (03-delivery-readiness) to be active or completed.",
       );
     }
     const timestamp = (options.now || (() => new Date().toISOString()))();
@@ -2881,7 +2231,7 @@ function recordScopeWarning(files, flags, options) {
 function completionReceiptFromProjection(scope, node, projection, evidence, timestamp) {
   const manifest = currentScopeManifest(scope);
   const receipt = stableValue({
-    receipt_id: `RECEIPT-${sha256(`${scope.scope_id}:${node}:${projection.node_attempt}:${manifest?.manifest_id || "legacy"}`).slice(0, 24)}`,
+    receipt_id: `RECEIPT-${sha256(`${scope.scope_id}:${node}:${projection.node_attempt}:${manifest?.manifest_id || "none"}`).slice(0, 24)}`,
     iteration_id: scope.scope_id,
     node,
     node_attempt: projection.node_attempt,
@@ -2958,13 +2308,13 @@ function transitionWorkflow(files, flags, options) {
       const registry = normalizeArtifactRegistry(readYaml(files.artifactRegistry, options.yaml, "artifact-registry.yaml"));
       const artifact = registry.artifacts.find((item) => (item.artifact_id || item.id) === artifactId);
       if (!artifact) throw new Error(`Selected artifact is not registered: ${artifactId}`);
-      assertNotLegacyDevelopmentNode(artifact.node);
+      assertWritableNode(artifact.node);
       if (artifactSuperseder(registry, artifact)) {
         throw new Error(`Selected artifact is superseded: ${artifactId}`);
       }
       const expectedNodes = event === "candidate-selected"
-        ? new Set(["04-implementation", "09-development", "R04-release-candidate"])
-        : new Set(["12-release-preparation", "R06-release-preparation"]);
+        ? new Set(["04-implementation", "R04-release-candidate"])
+        : new Set(["R06-release-preparation"]);
       if (!expectedNodes.has(artifact.node)) {
         throw new Error(`Selected artifact ${artifactId} belongs to ${artifact.node}, not ${[...expectedNodes].join(" or ")}.`);
       }
@@ -2975,8 +2325,7 @@ function transitionWorkflow(files, flags, options) {
       if (scope.scope_id !== iterationId) {
         throw new Error(`Iteration mismatch for ${scopeName} scope: state is ${scope.scope_id}, command is ${iterationId}.`);
       }
-      if (artifact.iteration_id && artifact.iteration_id !== iterationId
-        && !(event === "release-selected" && artifact.node === "12-release-preparation")) {
+      if (artifact.iteration_id && artifact.iteration_id !== iterationId) {
         throw new Error(`Selected artifact ${artifactId} belongs to iteration ${artifact.iteration_id}, not ${iterationId}.`);
       }
       const allowed = event === "candidate-selected" ? new Set(["immutable"]) : new Set(["immutable", "approved"]);
@@ -2997,7 +2346,7 @@ function transitionWorkflow(files, flags, options) {
       const registry = normalizeArtifactRegistry(readYaml(files.artifactRegistry, options.yaml, "artifact-registry.yaml"));
       const artifact = registry.artifacts.find((item) => (item.artifact_id || item.id) === artifactId);
       if (!artifact) throw new Error(`Milestone artifact is not registered: ${artifactId}`);
-      assertNotLegacyDevelopmentNode(artifact.node);
+      assertWritableNode(artifact.node);
       const expectedNodes = event === "version-closed"
         ? ["06-version-closeout"]
         : ["R10-release-archive"];
@@ -3033,10 +2382,7 @@ function transitionWorkflow(files, flags, options) {
     }
 
     const node = requiredFlag(flags, "--node");
-    if (!WRITABLE_NODE_IDS.has(node)) {
-      if (NODE_IDS.has(node)) throw new Error(`Legacy workflow node is read-only: ${node}`);
-      throw new Error(`Unknown workflow node: ${node}`);
-    }
+    assertWritableNode(node);
     const scopeName = scopeNameForNode(node);
     assertWorkflowRevision(flags, state, scopeName);
     const scope = scopeState(state, scopeName);
@@ -3208,166 +2554,15 @@ function registeredEvidence(files, evidence, options, node = null) {
   });
 }
 
-function retiredGateContractPlan(state, gateId) {
-  assertRetiredGateContract(gateId);
-  const affectedIterations = [];
-  const expectedScopeRevisions = {};
-  for (const [scopeName, scope] of [
-    ["development", state.development_state],
-    ["release", state.release_state],
-  ]) {
-    const requests = scope.pending_gates
-      .map((gate) => typeof gate === "string" ? { gate_id: gate, node: null } : gate)
-      .filter((gate) => gate?.gate_id === gateId);
-    if (!requests.length) continue;
-    expectedScopeRevisions[scopeName] = scope.revision;
-    for (const request of requests) {
-      affectedIterations.push({
-        iteration_id: request.iteration_id || scope.scope_id,
-        scope: scopeName,
-        node: request.node || null,
-        node_attempt: Number(request.node_attempt || scope.node_attempts[request.node] || 1),
-        scope_revision: scope.revision,
-      });
-    }
-  }
-  return {
-    command: "contract retire",
-    dry_run: true,
-    applied: false,
-    gate_id: gateId,
-    replacement_gate_id: gateId === "UX-LF" ? "UX-UI" : null,
-    fresh_approval_required: gateId === "UX-LF",
-    affected_iterations: affectedIterations,
-    expected_scope_revisions: expectedScopeRevisions,
-  };
-}
-
-function retireGateContract(files, flags, options) {
-  const gateId = requiredFlag(flags, "--gate-id");
-  if (flags.has("--dry-run")) return withReadableFormalState(files, () => {
-    const state = normalizeWorkflowState(
-      readYaml(files.workflowState, options.yaml, "workflow-state.yaml"),
-    );
-    return retiredGateContractPlan(state, gateId);
-  });
-  return withLock(files, "workflow-state", () => {
-    const state = normalizeWorkflowState(
-      readYaml(files.workflowState, options.yaml, "workflow-state.yaml"),
-    );
-    const plan = retiredGateContractPlan(state, gateId);
-    if (!plan.affected_iterations.length) {
-      return { ...plan, dry_run: false, applied: false, receipts: [], workflow_state: state };
-    }
-    const affectedScopes = Object.keys(plan.expected_scope_revisions);
-    if (affectedScopes.length !== 1) {
-      throw new Error(`${gateId} retirement must affect exactly one formal scope per transaction.`);
-    }
-    const scopeName = affectedScopes[0];
-    assertWorkflowRevision(flags, state, scopeName);
-    const actor = requiredFlag(flags, "--actor");
-    if (actor !== "system:package-upgrade") {
-      throw new Error("Contract retirement must be executed by system:package-upgrade.");
-    }
-    const reason = requiredFlag(flags, "--reason");
-    const contractVersion = requiredFlag(flags, "--contract-version");
-    const scope = scopeState(state, scopeName);
-    const pending = scope.pending_gates
-      .map((gate) => typeof gate === "string" ? { gate_id: gate, node: null } : gate);
-    const retiredRequests = pending.filter((gate) => gate?.gate_id === gateId);
-    const timestamp = (options.now || (() => new Date().toISOString()))();
-    const receipts = retiredRequests.map((request) => {
-      const requestChecksum = sha256(JSON.stringify(stableValue(request)));
-      const receipt = stableValue({
-        receipt_id: `RETIRE-${gateId}-${requestChecksum.slice(0, 20).toUpperCase()}`,
-        gate_id: gateId,
-        iteration_id: request.iteration_id || scope.scope_id,
-        scope: scopeName,
-        node: request.node || null,
-        node_attempt: Number(request.node_attempt || scope.node_attempts[request.node] || 1),
-        request_checksum: requestChecksum,
-        request_evidence: [...new Set(request.evidence || [])].sort(),
-        contract_version: contractVersion,
-        disposition: "contract-retired",
-        human_approval_created: false,
-        renewed_gate_id: gateId === "UX-LF" ? "UX-UI" : null,
-        retired_by: actor,
-        reason,
-        retired_at: timestamp,
-      });
-      receipt.receipt_checksum = contractRetirementReceiptChecksum(receipt);
-      return receipt;
-    });
-    const remaining = pending.filter((gate) => gate?.gate_id !== gateId);
-    const existingUxUiRequests = remaining.filter((gate) => gate?.gate_id === "UX-UI");
-    const renewalSources = existingUxUiRequests.length ? existingUxUiRequests : retiredRequests;
-    const renewedRequests = gateId === "UX-LF"
-      ? renewalSources.map((request, index) => {
-        const retiredIndex = Math.max(0, retiredRequests.findIndex((candidate) =>
-          (candidate.iteration_id || scope.scope_id) === (request.iteration_id || scope.scope_id)));
-        const retiredRequest = retiredRequests[retiredIndex] || retiredRequests[index] || request;
-        const receipt = receipts[retiredIndex] || receipts[index];
-        return {
-          ...request,
-          gate_id: "UX-UI",
-          renewed_from_gate_id: gateId,
-          iteration_id: request.iteration_id || scope.scope_id,
-          scope: scopeName,
-          node: "02-solution-design",
-          node_attempt: Number(retiredRequest.node_attempt || request.node_attempt
-            || scope.node_attempts[retiredRequest.node] || 1),
-          evidence: [],
-          prototype_revision_required: true,
-          required_evidence_type: "prototype-revision",
-          retirement_receipt_checksum: receipt.receipt_checksum,
-          requested_at: request.requested_at || timestamp,
-        };
-      })
-      : [];
-    scope.pending_gates = [
-      ...remaining.filter((gate) => gate?.gate_id !== "UX-UI"),
-      ...renewedRequests,
-    ];
-    scope.contract_retirement_receipts = [
-      ...scope.contract_retirement_receipts,
-      ...receipts,
-    ];
-    const transition = {
-      event: "gate-contract-retired",
-      scope: scopeName,
-      gate_id: gateId,
-      iteration_id: scope.scope_id,
-      retirement_receipt_ids: receipts.map((receipt) => receipt.receipt_id),
-      renewed_gate_ids: renewedRequests.map((request) => request.gate_id),
-      occurred_at: timestamp,
-    };
-    persistScopeMutation(files, { state, scope, timestamp, transition }, options);
-    return {
-      ...plan,
-      dry_run: false,
-      applied: true,
-      receipts,
-      renewed_requests: renewedRequests,
-      revision: state.revision,
-      scope_revision: scope.revision,
-      workflow_state: state,
-    };
-  }, { waitForActive: flags.has("--expected-scope-revision") });
-}
-
 function requestGate(files, flags, options) {
   return withLock(files, "workflow-state", () => {
     const state = normalizeWorkflowState(
       readYaml(files.workflowState, options.yaml, "workflow-state.yaml"),
     );
     const gateId = requiredFlag(flags, "--gate-id");
-    assertGateContractWritable(gateId);
     const iterationId = requiredFlag(flags, "--iteration-id");
     const node = requiredFlag(flags, "--node");
-    if (!WRITABLE_NODE_IDS.has(node)) {
-      if (NODE_IDS.has(node)) throw new Error(`Legacy workflow node is read-only: ${node}`);
-      throw new Error(`Unknown workflow node: ${node}`);
-    }
+    assertWritableNode(node);
     const scopeName = scopeNameForNode(node);
     assertWorkflowRevision(flags, state, scopeName);
     const scope = scopeState(state, scopeName);
@@ -3418,7 +2613,6 @@ function decideGate(files, flags, options) {
       readYaml(files.workflowState, options.yaml, "workflow-state.yaml"),
     );
     const gateId = requiredFlag(flags, "--gate-id");
-    assertGateContractWritable(gateId);
     const scopes = [state.development_state, state.release_state];
     let owningScope = null;
     let pending = [];
@@ -3435,7 +2629,7 @@ function decideGate(files, flags, options) {
       }
     }
     if (!request) throw new Error(`Gate is not pending: ${gateId}`);
-    assertNotLegacyDevelopmentNode(request.node);
+    assertWritableNode(request.node);
     const scopeName = request.scope || scopeNameForNode(request.node);
     assertWorkflowRevision(flags, state, scopeName);
     const decision = requiredFlag(flags, "--decision").toLowerCase().replaceAll("_", "-");
@@ -3749,27 +2943,6 @@ function verifyScopeContracts(scope, scopeName, errors) {
       errors.push(`Node completion receipt ${receipt.receipt_id} retains blocking defects.`);
     }
   }
-  const retirementReceiptIds = new Set();
-  for (const receipt of scope.contract_retirement_receipts) {
-    if (!receipt?.receipt_id || retirementReceiptIds.has(receipt.receipt_id)) {
-      errors.push(`Workflow ${scopeName} contract retirement receipt ID is missing or duplicated.`);
-      continue;
-    }
-    retirementReceiptIds.add(receipt.receipt_id);
-    if (receipt.receipt_checksum !== contractRetirementReceiptChecksum(receipt)) {
-      errors.push(`Contract retirement receipt checksum mismatch: ${receipt.receipt_id}.`);
-    }
-    if (!RETIRED_GATE_IDS.has(receipt.gate_id)
-      || receipt.iteration_id !== scope.scope_id
-      || receipt.scope !== scopeName
-      || receipt.disposition !== "contract-retired"
-      || receipt.human_approval_created !== false
-      || receipt.retired_by !== "system:package-upgrade"
-      || !receipt.contract_version
-      || !/^[a-f0-9]{64}$/.test(receipt.request_checksum || "")) {
-      errors.push(`Contract retirement receipt is invalid: ${receipt.receipt_id}.`);
-    }
-  }
   if (scope.scope_contract_version === 1 && scope.current_scope_manifest_id) {
     const current = manifestsById.get(scope.current_scope_manifest_id);
     for (const node of scope.completed_nodes.filter((item) => SCOPED_COMPLETION_NODES.has(item))) {
@@ -3801,31 +2974,17 @@ function verifyFormalState(files, options, verification = {}) {
   const registry = views.get("artifact-registry").value;
   const errors = [];
   let retentionReceipts = [];
-  let historyArchives = [];
   try {
     retentionReceipts = readArtifactRetentionReceipts(files, options);
   } catch (error) {
     errors.push(error.message);
   }
-  if (verifyHistory) {
-    try {
-      historyArchives = readArtifactHistoryArchives(files, options);
-    } catch (error) {
-      errors.push(error.message);
-    }
-  }
-  const compactedHistory = verifyHistory && !sinceAnchor
-    && historyArchives.length > 0 && retentionReceipts.length === 0;
   const retainedHistory = verifyHistory && !sinceAnchor
-    && (retentionReceipts.length > 0 || compactedHistory);
+    && retentionReceipts.length > 0;
   const verificationMode = verifyHistory
     ? (sinceAnchor
       ? "incremental-history"
-      : compactedHistory
-        ? "compacted-history"
-        : retainedHistory
-          ? "retained-history"
-          : "full-history")
+      : retainedHistory ? "retained-history" : "full-history")
     : "routine";
   let trustedAnchor = null;
   if (sinceAnchor || !verifyHistory || retainedHistory) {
@@ -3897,7 +3056,7 @@ function verifyFormalState(files, options, verification = {}) {
           continue;
         }
         const indexedEvent = streamEvents.find((event) => event.revision === revision);
-        const { after_value: ignored, ...shardEvent } = revisionShards[0];
+        const shardEvent = revisionShards[0];
         if (!indexedEvent?.record_checksum) delete shardEvent.record_checksum;
         if (!indexedEvent
           || JSON.stringify(stableValue(shardEvent)) !== JSON.stringify(stableValue(indexedEvent))) {
@@ -4007,7 +3166,6 @@ function verifyFormalState(files, options, verification = {}) {
     event_shard_count: shards.length,
     history_verified: verifyHistory,
     retention_receipt_count: retentionReceipts.length,
-    history_archive_count: historyArchives.length,
   };
 }
 
@@ -4017,10 +3175,7 @@ export function executeDeliveryStateCommand(argv, options = {}) {
   const command = positional[0];
   const projectRoot = path.resolve(String(flags.get("--project") || options.projectRoot || process.cwd()));
   const files = statePaths(projectRoot);
-  assertNoLegacyDevelopmentWrite(files, command, positional, flags, options);
-  if (command === "gate" && ["request", "decide"].includes(positional[1])) {
-    assertGateContractWritable(requiredFlag(flags, "--gate-id"));
-  }
+  assertCurrentNodeInputs(files, command, positional, flags, options);
   const descriptor = lifecycleDescriptor(command, positional, flags);
   const before = dispatchLifecycle(options, files, descriptor, "before", flags);
   if (before.decision === "block") {
@@ -4032,18 +3187,12 @@ export function executeDeliveryStateCommand(argv, options = {}) {
     let result;
     if (command === "artifact" && positional[1] === "register") {
       result = registerArtifact(files, flags, options);
-    } else if (command === "artifact" && positional[1] === "status") {
-      result = changeArtifactStatus(files, flags, options);
     } else if (command === "artifact" && positional[1] === "prune") {
       result = pruneArtifactHistory(files, flags, options);
-    } else if (command === "artifact" && positional[1] === "compact") {
-      result = compactArtifactHistory(files, flags, options);
     } else if (command === "gate" && positional[1] === "request") {
       result = requestGate(files, flags, options);
     } else if (command === "gate" && positional[1] === "decide") {
       result = decideGate(files, flags, options);
-    } else if (command === "contract" && positional[1] === "retire") {
-      result = retireGateContract(files, flags, options);
     } else if (command === "scope" && positional[1] === "freeze") {
       result = mutateScopeManifest(files, flags, options, false);
     } else if (command === "scope" && positional[1] === "amend") {
@@ -4088,8 +3237,8 @@ export function executeDeliveryStateCommand(argv, options = {}) {
       });
     } else {
       throw new Error(
-        "Use inspect, verify, rebuild, snapshot create, artifact register/status/prune/compact, scope freeze/amend/warn, "
-        + "transition, gate request/decide, or contract retire.",
+        "Use inspect, verify, rebuild, snapshot create, artifact register/prune, scope freeze/amend/warn, "
+        + "transition, or gate request/decide.",
       );
     }
     dispatchLifecycle(options, files, descriptor, "after", flags, result);