@mstar-harness/engine 3.9.4 → 3.10.1

package/dist/engine.js

@@ -171,21 +171,21 @@ function isAtOrBelow(dir, root) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
 // src/path.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync5, readFileSync as readFileSync8, realpathSync as realpathSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync6, readFileSync as readFileSync8, realpathSync as realpathSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute6, join as join10, relative as relative2, resolve as resolve8 } from "node:path";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute6, join as join10, relative as relative2, resolve as resolve9 } from "node:path";
 
 // src/project.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
-import { basename as basename4, join as join9, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync as readdirSync5 } from "node:fs";
+import { basename as basename4, join as join9, resolve as resolve8 } from "node:path";
 
 // src/iteration.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "node:fs";
 import { join as join8 } from "node:path";
 
 // src/status.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync2, realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname5, join as join7, resolve as resolve6, sep as sep2 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, realpathSync as realpathSync2 } from "node:fs";
+import { dirname as dirname5, join as join7, resolve as resolve7, sep as sep2 } from "node:path";
 
 // src/lease.ts
 import { mkdirSync as mkdirSync2, rmdirSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -1041,6 +1041,7 @@ var REQUIRED_FIELDS = [
 var REVIEW_SEAT_ROLES = ["qc-specialist", "qc-specialist-2", "qc-specialist-3", "code-reviewer", "qa-engineer"];
 var BUDGET_LABELS = ["Budget (review / QC seats)", "Budget"];
 var RETURN_SHAPE_LABELS = ["Return shape (review / QC seats)", "Return shape"];
+var TASK_BUDGET_LABELS = ["Task budget (implement / ops rounds)", "Task budget"];
 function violation2(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -1068,6 +1069,8 @@ function parseAssignmentFields(assignmentText) {
       fields.budget = value;
     else if (RETURN_SHAPE_LABELS.includes(label))
       fields.returnShape = value;
+    else if (TASK_BUDGET_LABELS.includes(label))
+      fields.taskBudget = value;
   }
   return fields;
 }
@@ -1182,6 +1185,12 @@ function validateAssignmentFields(assignmentText, opts = {}) {
       violations.push(violation2("high", field.code, `${subject} must declare a round ${field.label} — ${missing}`, field.fix));
     }
   }
+  if (!reviewSeat && !auditRound) {
+    const missing = describeAbsence(fields.taskBudget);
+    if (missing !== undefined) {
+      violations.push(violation2("high", "assignment.field.task-budget-missing", `implement/ops round "${role}" must declare a Task budget — ${missing}`, `add "**Task budget (implement / ops rounds)**: <one implementer round closing the task's declared Files list and verification gates> — capacity contract spec § A1/A2"`));
+    }
+  }
   if (writable) {
     const workingPresent = fields.workingBranch !== undefined && fields.workingBranch !== "";
     const policyPresent = fields.branchPolicy !== undefined && fields.branchPolicy !== "";
@@ -1314,12 +1323,14 @@ function antiRecursionPrecheck(subagentType, executeAs) {
 }
 
 // src/workflow.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join6 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, rmdirSync as rmdirSync2 } from "node:fs";
+import { isAbsolute as isAbsolute5, join as join6, resolve as resolve6 } from "node:path";
 var WORKFLOW_SNAPSHOT_FILE = "snapshot.json";
 var WORKFLOW_LIFECYCLE_STATUSES = ["running", "paused", "completed", "failed", "stopped"];
 var WORKFLOW_TERMINAL_STATUSES = ["completed", "failed", "stopped"];
 var WORKFLOW_LIFECYCLE_TYPES = ["plan", "iteration"];
+var WORKFLOW_DELIVERY_KINDS = ["development", "verification/report-only"];
+var WORKFLOW_COMPOUND_OUTCOMES = ["created", "updated", "skipped"];
 function stableJson(value) {
   if (Array.isArray(value))
     return `[${value.map(stableJson).join(",")}]`;
@@ -1344,6 +1355,61 @@ function validateWorktreePathValue(violations, value, field) {
     violations.push(violation3("high", "workflow.snapshot.invalid-integration-worktree-path", `${field} must be a non-empty absolute path — got ${JSON.stringify(value)}`, "record the absolute integration checkout path (integration_worktree_path)"));
   }
 }
+function deliveryEvidenceViolations(value, what) {
+  const violations = [];
+  const invalid2 = (message) => {
+    violations.push(violation3("medium", "workflow.snapshot.invalid-delivery-evidence", `${what}: ${message}`));
+  };
+  if (!isPlainObject2(value)) {
+    invalid2("must be an object");
+    return violations;
+  }
+  const members = ["compound", "pr", "merge", "completion"];
+  const unknownMembers = Object.keys(value).filter((key) => !members.includes(key));
+  if (unknownMembers.length > 0)
+    invalid2(`unknown member(s) ${unknownMembers.join(", ")} — expected ${members.join(" | ")}`);
+  const compound = value.compound;
+  if (compound !== undefined) {
+    if (!isPlainObject2(compound))
+      invalid2("compound must be an object");
+    else {
+      const unknown = Object.keys(compound).filter((key) => key !== "outcome" && key !== "reason");
+      if (unknown.length > 0)
+        invalid2(`compound has unknown key(s) ${unknown.join(", ")}`);
+      if (typeof compound.outcome !== "string" || !WORKFLOW_COMPOUND_OUTCOMES.includes(compound.outcome)) {
+        invalid2(`compound.outcome must be one of ${WORKFLOW_COMPOUND_OUTCOMES.join(" | ")} — got ${JSON.stringify(compound.outcome)}`);
+      } else if (compound.outcome === "skipped" && (typeof compound.reason !== "string" || compound.reason.trim() === "")) {
+        invalid2("compound reason is required when the disposition outcome is 'skipped' (contract §4c)");
+      } else if (compound.reason !== undefined && (typeof compound.reason !== "string" || compound.reason.trim() === "")) {
+        invalid2("compound.reason must be a non-empty string when given");
+      }
+    }
+  }
+  const stringMembers = {
+    pr: ["repo", "head", "target"],
+    merge: ["provider", "evidence"],
+    completion: ["policy", "evidence"]
+  };
+  for (const member of ["pr", "merge", "completion"]) {
+    const block = value[member];
+    if (block === undefined)
+      continue;
+    if (!isPlainObject2(block)) {
+      invalid2(`${member} must be an object`);
+      continue;
+    }
+    const fields = stringMembers[member];
+    const unknown = Object.keys(block).filter((key) => !fields.includes(key));
+    if (unknown.length > 0)
+      invalid2(`${member} has unknown key(s) ${unknown.join(", ")}`);
+    for (const field of fields) {
+      if (typeof block[field] !== "string" || block[field].trim() === "") {
+        invalid2(`${member}.${field} must be a non-empty string`);
+      }
+    }
+  }
+  return violations;
+}
 function validateWorkflowSnapshot(doc) {
   const violations = [];
   if (!isPlainObject2(doc)) {
@@ -1409,7 +1475,7 @@ function validateWorkflowSnapshot(doc) {
     if (!isPlainObject2(doc.branch)) {
       violations.push(violation3("medium", "workflow.snapshot.invalid-branch", "branch must be an object"));
     } else {
-      for (const key of ["base", "integration", "target"]) {
+      for (const key of ["base", "source", "integration", "target"]) {
         if (doc.branch[key] !== undefined && (typeof doc.branch[key] !== "string" || doc.branch[key].trim() === "")) {
           violations.push(violation3("medium", "workflow.snapshot.invalid-branch", `branch.${key} must be a non-empty string`));
         }
@@ -1435,6 +1501,20 @@ function validateWorkflowSnapshot(doc) {
   if (doc.compass_ref !== undefined) {
     validateNonEmptyString2(violations, doc.compass_ref, "compass_ref", "workflow.snapshot.missing-compass-ref", "workflow.snapshot.invalid-compass-ref");
   }
+  if (doc.delivery_kind !== undefined) {
+    if (typeof doc.delivery_kind !== "string" || !WORKFLOW_DELIVERY_KINDS.includes(doc.delivery_kind)) {
+      violations.push(violation3("medium", "workflow.snapshot.invalid-delivery-kind", `delivery_kind must be one of ${WORKFLOW_DELIVERY_KINDS.join(" | ")} — got ${JSON.stringify(doc.delivery_kind)}`));
+    }
+  }
+  if (doc.project !== undefined) {
+    validateNonEmptyString2(violations, doc.project, "project", "workflow.snapshot.missing-project", "workflow.snapshot.invalid-project");
+  }
+  if (doc.completion_policy !== undefined) {
+    validateNonEmptyString2(violations, doc.completion_policy, "completion_policy", "workflow.snapshot.missing-completion-policy", "workflow.snapshot.invalid-completion-policy");
+  }
+  if (doc.delivery !== undefined) {
+    violations.push(...deliveryEvidenceViolations(doc.delivery, "delivery"));
+  }
   const terminal = typeof doc.status === "string" && WORKFLOW_TERMINAL_STATUSES.includes(doc.status);
   if (terminal) {
     if (doc.ended_at === undefined) {
@@ -1565,6 +1645,74 @@ async function validateAndPutWorkflowSnapshot(store, snapshot, snapshotPath) {
 function isTerminalSnapshot(doc) {
   return WORKFLOW_TERMINAL_STATUSES.includes(doc.status);
 }
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function assertDeliveryRegistrationCoherence(kind, evidence, what) {
+  if (kind === "development" && (!nonEmptyString(evidence.branchSource) || !nonEmptyString(evidence.branchTarget))) {
+    throw new Error(`${what}: a development workflow requires its delivery source and target branches (--branch-source/--branch-target) — missing branch fields are incomplete registration, not an exempt workflow (contract §1/§4a)`);
+  }
+  if (kind === "verification/report-only" && !nonEmptyString(evidence.completionPolicy)) {
+    throw new Error(`${what}: a verification/report-only workflow requires the completion policy (--completion-policy) naming the evidence that completes it (contract §1)`);
+  }
+  for (const [field, value] of Object.entries({ branchSource: evidence.branchSource, branchTarget: evidence.branchTarget, completionPolicy: evidence.completionPolicy })) {
+    if (value !== undefined && !nonEmptyString(value)) {
+      throw new Error(`${what}: ${field} must be a non-empty string when given`);
+    }
+  }
+}
+function consultDeliveryEvidence(snapshot) {
+  if (snapshot.type !== "plan")
+    return [];
+  const workflowId = nonEmptyString(snapshot.id) ? snapshot.id : "<unknown>";
+  const kind = snapshot.delivery_kind;
+  if (typeof kind !== "string" || !WORKFLOW_DELIVERY_KINDS.includes(kind)) {
+    return [
+      violation3("high", "PHASE6_DELIVERY_KIND_UNREGISTERED", `Workflow '${workflowId}' is type 'plan' but carries no registered delivery_kind — a plan workflow declares its delivery kind at registration (mstar-artifacts/references/plan-workflow-lifecycle-contract.md §1), so this snapshot's delivery evidence cannot be consulted`, "Delivery evidence is declared at registration, before execution. A still-ACTIVE kind-less workflow is repaired by the authorized one-time declaration 'mstar workflow evidence --workflow <id> --declare-kind <development|verification/report-only> [--branch-source <b> --branch-target <b> | --completion-policy <text>] [--session <envelope>]' (declared once, never re-declared); a TERMINAL legacy snapshot cannot be backfilled — 'mstar workflow register' is create-only and its registration identity can never match a terminal snapshot — so repair requires an explicit owner snapshot amendment recording the declared kind (the known affected population — audit-promotion's grandfathered type: plan snapshots — is disclosed as a residual by plan QC), then re-run the close / 'mstar iteration gate --phase 6 --workflow <id>'")
+    ];
+  }
+  const branch = isPlainObject2(snapshot.branch) ? snapshot.branch : undefined;
+  const delivery = isPlainObject2(snapshot.delivery) ? snapshot.delivery : undefined;
+  const missing = [];
+  if (kind === "development") {
+    if (!nonEmptyString(branch?.source))
+      missing.push("branch.source");
+    if (!nonEmptyString(branch?.target))
+      missing.push("branch.target");
+    if (!isPlainObject2(delivery?.compound))
+      missing.push("delivery.compound (compound disposition, §4c)");
+    const pr = isPlainObject2(delivery?.pr) ? delivery.pr : undefined;
+    if (pr === undefined) {
+      missing.push("delivery.pr (PR repo/head/target identity, §4d)");
+    } else {
+      if (nonEmptyString(branch?.source) && pr.head !== branch.source) {
+        missing.push(`delivery.pr.head (recorded ${JSON.stringify(pr.head)}, registered branch.source ${JSON.stringify(branch.source)} — §4d: the recorded PR identity must be the registered delivery)`);
+      }
+      if (nonEmptyString(branch?.target) && pr.target !== branch.target) {
+        missing.push(`delivery.pr.target (recorded ${JSON.stringify(pr.target)}, registered branch.target ${JSON.stringify(branch.target)} — §4d: the recorded PR identity must be the registered delivery)`);
+      }
+    }
+    if (!isPlainObject2(delivery?.merge))
+      missing.push("delivery.merge (PM-recorded verified-merge evidence, §4f)");
+  } else {
+    const policy = snapshot.completion_policy;
+    if (!nonEmptyString(policy))
+      missing.push("completion_policy (the recorded alternative completion policy, §1)");
+    const completion = isPlainObject2(delivery?.completion) ? delivery.completion : undefined;
+    if (completion === undefined) {
+      missing.push("delivery.completion (the fulfilment record of the registered policy, §1)");
+    } else if (nonEmptyString(policy) && completion.policy !== policy) {
+      missing.push(`delivery.completion.policy (§1 — recorded ${JSON.stringify(completion.policy)}, registered completion_policy ${JSON.stringify(policy)})`);
+    }
+  }
+  if (missing.length === 0)
+    return [];
+  const incomplete = (fix) => violation3("high", "PHASE6_DELIVERY_EVIDENCE_INCOMPLETE", `Workflow '${workflowId}' declares delivery_kind '${kind}' but its delivery evidence is incomplete — missing: ${missing.join(", ")} (mstar-artifacts/references/plan-workflow-lifecycle-contract.md §3 lifecycle stages + §4c/§4d/§4f)`, fix);
+  const record = `Record the missing evidence with 'mstar workflow evidence --workflow ${workflowId} --file <payload.json>' (add --session <coordinator envelope> for a coordinated workflow)`;
+  return [
+    kind === "development" ? incomplete(`${record}: the compound disposition (§4c, before the PR head is finalized), the PR identity (§4d, at submission) and the verified-merge record (§4f, the PM's own check — the engine never verifies the remote merge). Done rows alone are not delivery evidence`) : incomplete(`${record}: the fulfilment record must name the registered completion policy and its evidence (§1)`)
+  ];
+}
 function isCloseTimestamp(value) {
   if (typeof value !== "string")
     return false;
@@ -1597,11 +1745,275 @@ async function closeWorkflow(workflowId, dir, opts) {
     if (snapshot.plans.some((row) => row.status !== "Done")) {
       throw new Error("refusing to close workflow: every plan row must be Done");
     }
+    const deliveryViolations = consultDeliveryEvidence(snapshot);
+    if (deliveryViolations.length > 0) {
+      const detail = deliveryViolations.map((v) => `${v.code}: ${v.message}${v.fix !== undefined ? ` (fix: ${v.fix})` : ""}`).join("; ");
+      throw new Error(`refusing to close workflow: ${detail}`);
+    }
     const completed = { ...snapshot, status: "completed", ended_at: opts.endedAt, updated_at: opts.endedAt };
     await validateAndPutWorkflowSnapshot(store, completed, snapshotPath);
     return completed;
   });
 }
+async function recordWorkflowDelivery(workflowId, dir, opts) {
+  const evidence = opts.evidence;
+  if (!isPlainObject2(evidence)) {
+    throw new Error("recordWorkflowDelivery: options.evidence must be an object naming at least one delivery-evidence member");
+  }
+  const members = Object.keys(evidence);
+  if (members.length === 0) {
+    throw new Error("recordWorkflowDelivery: options.evidence must name at least one of compound | pr | merge | completion");
+  }
+  const nonObject = members.filter((member) => !isPlainObject2(evidence[member]));
+  if (nonObject.length > 0) {
+    throw new Error(`refusing to record delivery evidence: member(s) ${nonObject.join(", ")} must be objects — omit a member to leave it untouched`);
+  }
+  const shapeViolations = deliveryEvidenceViolations(evidence, "evidence");
+  if (shapeViolations.length > 0) {
+    throw new Error(`refusing to record invalid delivery evidence: ${shapeViolations.map((v) => v.message).join("; ")}`);
+  }
+  const at = opts.at ?? new Date().toISOString();
+  if (!isCloseTimestamp(at)) {
+    throw new Error("recordWorkflowDelivery: options.at must be a valid YYYY-MM-DD date or RFC3339 timestamp");
+  }
+  const snapshotPath = join6(dir, WORKFLOW_SNAPSHOT_FILE);
+  const store = getArtifactStore();
+  const ref = { kind: "snapshot", key: workflowId };
+  assertFsStorePath(store, ref, snapshotPath);
+  mkdirSync3(dir, { recursive: true });
+  return withStatusWriteLock(snapshotPath, async () => {
+    const doc = await store.get(ref);
+    if (doc === undefined)
+      throw new Error(`workflow snapshot not found: ${snapshotPath}`);
+    const { snapshot } = normalizeWorkflowSnapshot(doc, snapshotPath);
+    if (snapshot.id !== workflowId) {
+      throw new Error(`workflow snapshot identity mismatch: expected ${workflowId}, got ${snapshot.id}`);
+    }
+    if (isTerminalSnapshot(snapshot)) {
+      throw new Error(`refusing to record delivery evidence for workflow ${JSON.stringify(workflowId)}: the lifecycle is terminal (${snapshot.status}) — delivery evidence is recorded before the close and a closed lifecycle is never amended`);
+    }
+    assertCoordinatedSnapshotWriter(doc, snapshotPath, opts.sessionPath, "delivery-evidence write");
+    const kind = snapshot.delivery_kind;
+    if (snapshot.type !== "plan" || kind !== "development" && kind !== "verification/report-only") {
+      throw new Error(`refusing to record delivery evidence for workflow ${JSON.stringify(workflowId)}: only a type: plan lifecycle with a registered delivery_kind carries delivery evidence (got type ${JSON.stringify(snapshot.type)} / delivery_kind ${JSON.stringify(kind)}) — the kind is declared at registration and never inferred (§1)`);
+    }
+    const allowed = kind === "development" ? ["compound", "pr", "merge"] : ["completion"];
+    const unused = members.filter((member) => !allowed.includes(member));
+    if (unused.length > 0) {
+      throw new Error(`refusing to record delivery evidence for workflow ${JSON.stringify(workflowId)}: member(s) ${unused.join(", ")} do not belong to the declared delivery_kind '${kind}' (expected ${allowed.join(" | ")})`);
+    }
+    const stored = isPlainObject2(snapshot.delivery) ? snapshot.delivery : {};
+    const recordedPr = isPlainObject2(stored.pr) ? stored.pr : undefined;
+    const incomingPr = isPlainObject2(evidence.pr) ? evidence.pr : undefined;
+    if (recordedPr !== undefined && incomingPr !== undefined && stableJson(recordedPr) !== stableJson(incomingPr)) {
+      throw new Error(`refusing to rewrite the recorded PR identity of workflow ${JSON.stringify(workflowId)}: §4d records it once at submission — recorded ${JSON.stringify(recordedPr)}, refused ${JSON.stringify(incomingPr)} (a different PR is a different delivery, not an evidence update)`);
+    }
+    const merged = { ...stored, ...evidence };
+    if (stableJson(snapshot.delivery ?? null) === stableJson(merged)) {
+      return { snapshot, written: false };
+    }
+    const next = { ...snapshot, delivery: merged, updated_at: at };
+    await validateAndPutWorkflowSnapshot(store, next, snapshotPath);
+    return { snapshot: next, written: true };
+  });
+}
+async function declareWorkflowDeliveryKind(workflowId, dir, opts) {
+  const kind = opts.deliveryKind;
+  if (typeof kind !== "string" || !WORKFLOW_DELIVERY_KINDS.includes(kind)) {
+    throw new Error(`declareWorkflowDeliveryKind: deliveryKind must be one of ${WORKFLOW_DELIVERY_KINDS.join(" | ")} — got ${JSON.stringify(kind)}`);
+  }
+  assertDeliveryRegistrationCoherence(kind, opts, "declareWorkflowDeliveryKind");
+  const at = opts.at ?? new Date().toISOString();
+  if (!isCloseTimestamp(at)) {
+    throw new Error("declareWorkflowDeliveryKind: options.at must be a valid YYYY-MM-DD date or RFC3339 timestamp");
+  }
+  const snapshotPath = join6(dir, WORKFLOW_SNAPSHOT_FILE);
+  const store = getArtifactStore();
+  const ref = { kind: "snapshot", key: workflowId };
+  assertFsStorePath(store, ref, snapshotPath);
+  mkdirSync3(dir, { recursive: true });
+  return withStatusWriteLock(snapshotPath, async () => {
+    const doc = await store.get(ref);
+    if (doc === undefined)
+      throw new Error(`workflow snapshot not found: ${snapshotPath}`);
+    const { snapshot } = normalizeWorkflowSnapshot(doc, snapshotPath);
+    if (snapshot.id !== workflowId) {
+      throw new Error(`workflow snapshot identity mismatch: expected ${workflowId}, got ${snapshot.id}`);
+    }
+    if (isTerminalSnapshot(snapshot)) {
+      throw new Error(`refusing to declare a delivery kind for workflow ${JSON.stringify(workflowId)}: the lifecycle is terminal (${snapshot.status}) — a closed lifecycle is never amended (§5); a terminal snapshot without a registered kind stays on the documented owner-amendment path`);
+    }
+    assertCoordinatedSnapshotWriter(doc, snapshotPath, opts.sessionPath, "delivery-kind declaration");
+    if (snapshot.type !== "plan") {
+      throw new Error(`refusing to declare a delivery kind for workflow ${JSON.stringify(workflowId)}: only a type: plan lifecycle declares one (got type ${JSON.stringify(snapshot.type)})`);
+    }
+    if (snapshot.delivery_kind !== undefined) {
+      throw new Error(`refusing to declare a delivery kind for workflow ${JSON.stringify(workflowId)}: it already declares ${JSON.stringify(snapshot.delivery_kind)} — the kind is registration evidence, declared once and never re-inferred (§1)`);
+    }
+    const branch = isPlainObject2(snapshot.branch) ? { ...snapshot.branch } : {};
+    for (const [anchor, supplied] of [
+      ["source", opts.branchSource],
+      ["target", opts.branchTarget]
+    ]) {
+      if (supplied === undefined)
+        continue;
+      const registered = branch[anchor];
+      if (registered !== undefined && registered !== supplied) {
+        throw new Error(`refusing to declare a delivery kind for workflow ${JSON.stringify(workflowId)}: branch.${anchor} is already ` + `${JSON.stringify(registered)} — the supplied ${JSON.stringify(supplied)} conflicts with the anchor the snapshot ` + `registers, and the registered delivery anchor is never overwritten (§1)`);
+      }
+      branch[anchor] = supplied;
+    }
+    const next = { ...snapshot, delivery_kind: kind, updated_at: at };
+    if (Object.keys(branch).length > 0)
+      next.branch = branch;
+    if (opts.completionPolicy !== undefined)
+      next.completion_policy = opts.completionPolicy;
+    await validateAndPutWorkflowSnapshot(store, next, snapshotPath);
+    return next;
+  });
+}
+function planWorkflowRegistrationIdentity(snapshot) {
+  const coordinator = snapshot.coordination?.coordinator;
+  return stableJson({
+    type: snapshot.type,
+    status: snapshot.status,
+    delivery_kind: snapshot.delivery_kind ?? null,
+    project: snapshot.project ?? null,
+    completion_policy: snapshot.completion_policy ?? null,
+    branch: snapshot.branch ?? null,
+    plans: snapshot.plans,
+    coordinator: coordinator ? { session_id: coordinator.session_id, session_file: coordinator.session_file } : null
+  });
+}
+async function registerPlanWorkflow(workflowId, options) {
+  if (typeof options.harnessDir !== "string" || options.harnessDir.trim() === "") {
+    throw new Error("registerPlanWorkflow: options.harnessDir is required (must contain status.json + workflows/)");
+  }
+  assertSafePathComponent(workflowId, "workflow id");
+  const { plan, deliveryKind } = options;
+  if (!isPlainObject2(plan)) {
+    throw new Error("registerPlanWorkflow: options.plan is required (the owned plan: id, title, file)");
+  }
+  for (const field of ["id", "title", "file"]) {
+    if (typeof plan[field] !== "string" || plan[field].trim() === "") {
+      throw new Error(`registerPlanWorkflow: options.plan.${field} must be a non-empty string`);
+    }
+  }
+  if (typeof deliveryKind !== "string" || !WORKFLOW_DELIVERY_KINDS.includes(deliveryKind)) {
+    throw new Error(`registerPlanWorkflow: options.deliveryKind must be one of ${WORKFLOW_DELIVERY_KINDS.join(" | ")} — got ${JSON.stringify(deliveryKind)}`);
+  }
+  assertDeliveryRegistrationCoherence(deliveryKind, options, "registerPlanWorkflow");
+  for (const field of ["project", "branchSource", "branchTarget"]) {
+    const value = options[field];
+    if (value !== undefined && (typeof value !== "string" || value.trim() === "")) {
+      throw new Error(`registerPlanWorkflow: options.${field} must be a non-empty string when given`);
+    }
+  }
+  if (options.coordinator !== undefined) {
+    const { coordinator } = options;
+    if (typeof coordinator.session_id !== "string" || coordinator.session_id.trim() === "") {
+      throw new Error("registerPlanWorkflow: options.coordinator.session_id must be a non-empty string");
+    }
+    if (typeof coordinator.session_file !== "string" || !isAbsolute5(coordinator.session_file)) {
+      throw new Error("registerPlanWorkflow: options.coordinator.session_file must be an absolute path");
+    }
+  }
+  const startedAt = options.startedAt ?? new Date().toISOString();
+  if (!isCloseTimestamp(startedAt)) {
+    throw new Error("registerPlanWorkflow: options.startedAt must be a valid YYYY-MM-DD date or RFC3339 timestamp");
+  }
+  const harnessDir = resolve6(options.harnessDir);
+  const statusPath = join6(harnessDir, "status.json");
+  const workflowDir = join6(harnessDir, "workflows", workflowId);
+  const snapshotPath = join6(workflowDir, WORKFLOW_SNAPSHOT_FILE);
+  const store = getArtifactStore();
+  const planRow = { id: plan.id, title: plan.title, file: plan.file, status: "Todo" };
+  const snapshot = {
+    schema_version: 1,
+    id: workflowId,
+    type: "plan",
+    status: "running",
+    started_at: startedAt,
+    updated_at: startedAt.slice(0, 10),
+    plans: [planRow],
+    delivery_kind: deliveryKind
+  };
+  if (options.project !== undefined)
+    snapshot.project = options.project;
+  if (options.completionPolicy !== undefined)
+    snapshot.completion_policy = options.completionPolicy;
+  if (options.branchSource !== undefined || options.branchTarget !== undefined) {
+    snapshot.branch = {
+      ...options.branchSource !== undefined ? { source: options.branchSource } : {},
+      ...options.branchTarget !== undefined ? { target: options.branchTarget } : {}
+    };
+  }
+  if (options.coordinator !== undefined) {
+    snapshot.coordination = {
+      coordinator: { session_id: options.coordinator.session_id, session_file: options.coordinator.session_file, bound_at: startedAt }
+    };
+  }
+  const entry = {
+    id: workflowId,
+    type: "plan",
+    started_at: snapshot.started_at,
+    dir: `workflows/${workflowId}`
+  };
+  const entryGate = validateWorkflowEntry(entry);
+  if (!entryGate.ok) {
+    throw new Error(`refusing to register invalid workflow entry: ${entryGate.violations.map((v) => v.message).join("; ")}`);
+  }
+  return withStatusWriteLock(statusPath, async () => {
+    if (existsSync4(snapshotPath)) {
+      const rootDoc = readJson(statusPath);
+      const workflows = Array.isArray(rootDoc.workflows) ? rootDoc.workflows : [];
+      if (workflows.some((candidate) => isPlainObject2(candidate) && candidate.id === workflowId)) {
+        throw new Error(`refusing to register workflow ${JSON.stringify(workflowId)}: it is already registered ` + `(snapshot at ${snapshotPath}, root entry in ${statusPath}) — registration is create-only; ` + `remove that workflow before registering again`);
+      }
+      const existing = readWorkflowSnapshot(workflowDir);
+      if (planWorkflowRegistrationIdentity(existing.snapshot) !== planWorkflowRegistrationIdentity(snapshot)) {
+        throw new Error(`refusing to register workflow ${JSON.stringify(workflowId)}: snapshot ${snapshotPath} already exists ` + `with a different registration identity — remove that workflow or register under a different id`);
+      }
+      const recoveryEntry = {
+        id: workflowId,
+        type: "plan",
+        started_at: existing.snapshot.started_at,
+        dir: `workflows/${workflowId}`
+      };
+      const recoveryGate = validateWorkflowEntry(recoveryEntry);
+      if (!recoveryGate.ok) {
+        throw new Error(`refusing to register invalid workflow entry: ${recoveryGate.violations.map((v) => v.message).join("; ")}`);
+      }
+      await registerWorkflowEntryLocked(statusPath, recoveryEntry);
+      return { workflowId, snapshotPath, recovered: true };
+    }
+    let createdVersion;
+    try {
+      await writeWorkflowSnapshot(snapshot, workflowDir, { createOnly: true });
+      createdVersion = readArtifactBytes(snapshotPath)?.version;
+      await registerWorkflowEntryLocked(statusPath, entry);
+    } catch (error) {
+      if (createdVersion !== undefined) {
+        await withStatusWriteLock(snapshotPath, async () => {
+          const current = readArtifactBytes(snapshotPath);
+          if (current === undefined || current.version !== createdVersion)
+            return;
+          const remove = store.delete?.bind(store);
+          if (remove !== undefined) {
+            await withProtectedWrite(snapshotPath, "delete", () => remove({ kind: "snapshot", key: workflowId }));
+          }
+        });
+      }
+      try {
+        if (readdirSync2(workflowDir).length === 0) {
+          rmdirSync2(workflowDir);
+        }
+      } catch {}
+      throw error;
+    }
+    return { workflowId, snapshotPath, recovered: false };
+  });
+}
 
 // src/status.ts
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -1773,7 +2185,7 @@ function validateStatusV2(docOrPath, opts = {}) {
   if (typeof docOrPath === "string") {
     try {
       doc = readJson(docOrPath);
-      harnessDir = dirname5(resolve6(docOrPath));
+      harnessDir = dirname5(resolve7(docOrPath));
     } catch (error) {
       return {
         ok: false,
@@ -1935,14 +2347,14 @@ async function registerWorkflow(root, entry) {
   if (!entryGate.ok) {
     throw new Error(`refusing to register invalid workflow entry: ${entryGate.violations.map((v) => v.message).join("; ")}`);
   }
-  const statusPath = resolve6(root);
+  const statusPath = resolve7(root);
   return withStatusWriteLock(statusPath, () => registerWorkflowEntryLocked(statusPath, entry));
 }
 async function unregisterWorkflow(root, id) {
   if (typeof id !== "string" || id.trim() === "") {
     throw new Error("refusing to unregister workflow: id must be a non-empty string");
   }
-  const statusPath = resolve6(root);
+  const statusPath = resolve7(root);
   const store = getArtifactStore();
   assertFsStorePath(store, { kind: "status", key: "root" }, statusPath);
   const harnessDir = dirname5(statusPath);
@@ -1980,7 +2392,7 @@ function resolveCompassEnforcement(harnessDir) {
     return { hard: false, source: "none" };
   let entries;
   try {
-    entries = readdirSync2(iterationsDir, { withFileTypes: true });
+    entries = readdirSync3(iterationsDir, { withFileTypes: true });
   } catch {
     return { hard: false, source: "none" };
   }
@@ -2007,7 +2419,7 @@ function resolveCompassEnforcement(harnessDir) {
   return { hard: false, source: "none" };
 }
 function resolveMstarcEnforcement(harnessDir) {
-  const dir = resolve6(harnessDir);
+  const dir = resolve7(harnessDir);
   const rc = loadMstarc(dir, dirname5(dir));
   const value = rc?.config.enforcement;
   if (value === "hard")
@@ -2264,6 +2676,16 @@ function evaluatePostMergeClose(snapshotDoc, rootDoc) {
     violations.push(violation5("high", "PHASE6_DANGLING_LEASE", "Terminal snapshot still carries a lease (plans[].execution_lease or integration_merge_lease) — close never releases leases", "Release the lease(s) with the owner action, then re-run 'mstar iteration gate --phase 6 --workflow <id>'"));
   }
   const workflowId = isPlainObject3(snapshotDoc) && typeof snapshotDoc.id === "string" ? snapshotDoc.id : null;
+  if (shapeOk && terminal && isPlainObject3(snapshotDoc) && snapshotDoc.type === "plan" && snapshotDoc.status === "completed") {
+    violations.push(...consultDeliveryEvidence(snapshotDoc));
+    if (Array.isArray(snapshotDoc.plans)) {
+      for (const row of snapshotDoc.plans) {
+        if (isPlainObject3(row) && row.status !== PLAN_STATUS_DONE) {
+          violations.push(violation5("high", "PHASE6_PLAN_ROW_NOT_DONE", `Workflow '${String(workflowId)}' is completed but owned plan row '${String(row.id)}' is ${JSON.stringify(row.status)} — a completed close requires every plan row Done (mstar-artifacts/references/plan-workflow-lifecycle-contract.md §3 terminal stage)`, "Bring the owned plan row to Done (or close the lifecycle as failed/stopped with a recorded reason), then re-run 'mstar iteration gate --phase 6 --workflow <id>'"));
+        }
+      }
+    }
+  }
   const rootGate = validateStatusV2(rootDoc);
   if (!rootGate.ok) {
     violations.push(violation5("high", "PHASE6_INVALID_ROOT", "Root status.json is not a readable v2 workflow registry (workflows[] missing or not an array) — an invalid/unreadable root is not proof that the entry is gone", "Repair or migrate {HARNESS_DIR}/status.json to the v2 shape, then re-run the gate"));
@@ -2291,7 +2713,7 @@ function assertIndexRowObligations(iterationsDir) {
       ]
     };
   }
-  const iterationIds = readdirSync3(iterationsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => existsSync6(join8(iterationsDir, entry.name, COMPASS_FILE))).map((entry) => entry.name).sort();
+  const iterationIds = readdirSync4(iterationsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => existsSync6(join8(iterationsDir, entry.name, COMPASS_FILE))).map((entry) => entry.name).sort();
   const readmePath = join8(iterationsDir, INDEX_README);
   if (!existsSync6(readmePath)) {
     return {
@@ -2552,8 +2974,8 @@ async function appendProjectRegisterEntries(opts) {
   if (opts.entries.length === 0) {
     throw new Error("refusing to append residual entries: entries must not be empty");
   }
-  const registerPath = resolve7(join9(opts.projectDir, PROJECT_REGISTER_FILE));
-  const projectKey = basename4(resolve7(opts.projectDir));
+  const registerPath = resolve8(join9(opts.projectDir, PROJECT_REGISTER_FILE));
+  const projectKey = basename4(resolve8(opts.projectDir));
   const store = getArtifactStore();
   assertFsStorePath(store, { kind: "residuals", key: projectKey }, registerPath);
   mkdirSync4(opts.projectDir, { recursive: true });
@@ -2597,8 +3019,8 @@ async function appendProjectRegisterEntries(opts) {
   });
 }
 async function closeProjectRegisterEntry(opts) {
-  const registerPath = resolve7(join9(opts.projectDir, PROJECT_REGISTER_FILE));
-  const projectKey = basename4(resolve7(opts.projectDir));
+  const registerPath = resolve8(join9(opts.projectDir, PROJECT_REGISTER_FILE));
+  const projectKey = basename4(resolve8(opts.projectDir));
   const store = getArtifactStore();
   assertFsStorePath(store, { kind: "residuals", key: projectKey }, registerPath);
   mkdirSync4(opts.projectDir, { recursive: true });
@@ -2677,7 +3099,7 @@ function techDebtRollup(projectDir) {
   const items = [];
   let entries;
   try {
-    entries = readdirSync4(projectDir, { withFileTypes: true });
+    entries = readdirSync5(projectDir, { withFileTypes: true });
   } catch {
     entries = [];
   }
@@ -2724,7 +3146,7 @@ function listProjectReferenceFiles(projectDir) {
   const root = join9(projectDir, PROJECT_REFERENCES_DIR);
   let entries;
   try {
-    entries = readdirSync4(root, { withFileTypes: true });
+    entries = readdirSync5(root, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -2737,7 +3159,7 @@ function listProjectReferenceFiles(projectDir) {
     } else if (entry.isDirectory()) {
       let nested;
       try {
-        nested = readdirSync4(join9(root, entry.name), { withFileTypes: true });
+        nested = readdirSync5(join9(root, entry.name), { withFileTypes: true });
       } catch {
         continue;
       }
@@ -2752,14 +3174,14 @@ function listProjectReferenceFiles(projectDir) {
 
 // src/path.ts
 function resolveHarnessDir(startDir = process.cwd(), opts = {}) {
-  const start = resolve8(startDir);
+  const start = resolve9(startDir);
   const explicit = opts.harnessDir ?? process.env.MSTAR_HARNESS_DIR;
   if (explicit)
-    return resolve8(start, explicit);
-  const boundary = resolve8(start, opts.workspaceRoot ?? defaultWorkspaceRoot(start));
+    return resolve9(start, explicit);
+  const boundary = resolve9(start, opts.workspaceRoot ?? defaultWorkspaceRoot(start));
   const rc = loadMstarc(start, boundary);
   if (rc !== null && rc.config.harnessDir)
-    return resolve8(rc.dir, rc.config.harnessDir);
+    return resolve9(rc.dir, rc.config.harnessDir);
   let dir = start;
   for (;; ) {
     if (!isAtOrBelow2(dir, boundary))
@@ -2790,7 +3212,7 @@ function defaultWorkspaceRoot(startDir) {
       if (segment && segment !== ".")
         boundary = dirname6(boundary);
     }
-    return resolve8(boundary);
+    return resolve9(boundary);
   } catch {}
   return startDir;
 }
@@ -2799,10 +3221,10 @@ function isAtOrBelow2(dir, root) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute6(rel);
 }
 function mstarcDirOverride(harnessDir, key) {
-  const dir = resolve8(harnessDir);
+  const dir = resolve9(harnessDir);
   const rc = loadMstarc(dir, dirname6(dir));
   const declared = rc?.config[key];
-  return declared ? resolve8(rc.dir, declared) : null;
+  return declared ? resolve9(rc.dir, declared) : null;
 }
 function resolveSpecsDir(harnessDir, opts = {}) {
   const declared = mstarcDirOverride(harnessDir, "specsDir");
@@ -2811,7 +3233,7 @@ function resolveSpecsDir(harnessDir, opts = {}) {
       mkdirSync5(declared, { recursive: true });
     return declared;
   }
-  const harness = resolve8(harnessDir);
+  const harness = resolve9(harnessDir);
   const repoRoot = dirname6(harness);
   const candidates = [
     join10(harness, "specs"),
@@ -2833,7 +3255,7 @@ function resolvePlanDir(harnessDir) {
   const declared = mstarcDirOverride(harnessDir, "planDir");
   if (declared !== null)
     return declared;
-  const dir = resolve8(harnessDir);
+  const dir = resolve9(harnessDir);
   const name = basename5(dir);
   if (name === ".plans" || name === "plans")
     return dir;
@@ -2845,7 +3267,7 @@ function assertSafePathComponent(value, what) {
   }
 }
 function canonicalizeNearestExisting(path) {
-  const abs = resolve8(path);
+  const abs = resolve9(path);
   let dir = abs;
   const tail = [];
   for (;; ) {
@@ -2865,7 +3287,7 @@ function canonicalizeNearestExisting(path) {
 }
 function resolveSddDir(harnessDir, planId) {
   assertSafePathComponent(planId, "planId");
-  const base = resolve8(harnessDir);
+  const base = resolve9(harnessDir);
   const declared = mstarcDirOverride(base, "sddDir");
   const sddBase = declared !== null ? declared : join10(base, "sdd");
   return join10(sddBase, planId);
@@ -2874,21 +3296,21 @@ function resolveIterationDir(harnessDir) {
   const declared = mstarcDirOverride(harnessDir, "iterationDir");
   if (declared !== null)
     return declared;
-  return join10(resolve8(harnessDir), "iterations");
+  return join10(resolve9(harnessDir), "iterations");
 }
 function resolveKnowledgeDir(harnessDir) {
   const declared = mstarcDirOverride(harnessDir, "knowledgeDir");
   if (declared !== null)
     return declared;
-  return join10(resolve8(harnessDir), "knowledge");
+  return join10(resolve9(harnessDir), "knowledge");
 }
 function resolveHarnessSubdir(startDir, opts, key, fallback) {
   const harness = resolveHarnessDir(startDir, opts);
   if (harness === null) {
-    throw new Error(`harness dir not found from ${resolve8(startDir)} — cannot resolve the ${fallback} dir (run \`mstar harness scaffold\`, pass opts.harnessDir, or set MSTAR_HARNESS_DIR)`);
+    throw new Error(`harness dir not found from ${resolve9(startDir)} — cannot resolve the ${fallback} dir (run \`mstar harness scaffold\`, pass opts.harnessDir, or set MSTAR_HARNESS_DIR)`);
   }
   const declared = mstarcDirOverride(harness, key);
-  return declared !== null ? declared : join10(resolve8(harness), fallback);
+  return declared !== null ? declared : join10(resolve9(harness), fallback);
 }
 function resolveWorkflowDir(startDir = process.cwd(), opts = {}) {
   return resolveHarnessSubdir(startDir, opts, "workflowDir", "workflows");
@@ -2903,11 +3325,11 @@ var EMPTY_STATUS_TEMPLATE = {
 };
 var SCAFFOLD_DIRS = ["plans", "iterations", "knowledge", "specs", "sdd"];
 function resolveScaffoldDirs(root) {
-  const start = resolve8(root);
-  const boundary = resolve8(start, defaultWorkspaceRoot(start));
+  const start = resolve9(root);
+  const boundary = resolve9(start, defaultWorkspaceRoot(start));
   const rc = loadMstarc(start, boundary);
   const explicit = process.env.MSTAR_HARNESS_DIR;
-  const harnessDir = explicit ? resolve8(start, explicit) : rc !== null && rc.config.harnessDir ? resolve8(rc.dir, rc.config.harnessDir) : join10(start, ".mstar");
+  const harnessDir = explicit ? resolve9(start, explicit) : rc !== null && rc.config.harnessDir ? resolve9(rc.dir, rc.config.harnessDir) : join10(start, ".mstar");
   const declaredProjectDir = mstarcDirOverride(harnessDir, "projectDir");
   const projectDir = declaredProjectDir !== null ? declaredProjectDir : join10(harnessDir, "projects");
   return { harnessDir, projectDir };
@@ -2997,7 +3419,7 @@ function emitGitignoreSnippet(kind) {
   return `${GITIGNORE_SNIPPET}${GITIGNORE_SNIPPET_AGENTS}`;
 }
 function validateGitignore(root) {
-  const gitignorePath = join10(resolve8(root), ".gitignore");
+  const gitignorePath = join10(resolve9(root), ".gitignore");
   const kind = detectHarnessKind(resolveHarnessDir(root));
   let content;
   try {
@@ -3045,7 +3467,7 @@ function validateGitignore(root) {
 function detectHarnessKind(harnessDir) {
   if (!harnessDir)
     return null;
-  const name = basename5(resolve8(harnessDir));
+  const name = basename5(resolve9(harnessDir));
   if (name === ".mstar")
     return "mstar";
   if (name === ".agents")
@@ -3053,7 +3475,7 @@ function detectHarnessKind(harnessDir) {
   return null;
 }
 function assertPlanWritingPath(planPath, harnessDir) {
-  const planAbs = resolve8(planPath);
+  const planAbs = resolve9(planPath);
   if (!harnessDir) {
     return {
       ok: false,
@@ -3078,7 +3500,7 @@ function assertPlanWritingPath(planPath, harnessDir) {
   if (existsSync8(planAbs)) {
     try {
       const canonicalPlan = realpathSync3(planAbs);
-      const canonicalPlanDir = existsSync8(planDir) ? realpathSync3(planDir) : resolve8(planDir);
+      const canonicalPlanDir = existsSync8(planDir) ? realpathSync3(planDir) : resolve9(planDir);
       const canonicalRel = relative2(canonicalPlanDir, canonicalPlan);
       const canonicalInside = canonicalRel === "" || !canonicalRel.startsWith("..") && !isAbsolute6(canonicalRel);
       if (!canonicalInside) {
@@ -3108,7 +3530,7 @@ function isDirectory(dir) {
 }
 function hasFiles(dir) {
   try {
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         if (hasFiles(join10(dir, entry.name)))
           return true;
@@ -4284,7 +4706,7 @@ function assessSddEvidenceReuse(record, artifacts, expected, target) {
 // src/worktree.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync9, realpathSync as realpathSync4 } from "node:fs";
-import { isAbsolute as isAbsolute7, join as join11, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join11, resolve as resolve10 } from "node:path";
 var DEFAULT_PROBE_TIMEOUT_MS = 1e4;
 function gitProbeTimeoutMs() {
   const raw = process.env.MSTAR_GIT_PROBE_TIMEOUT_MS;
@@ -4429,7 +4851,7 @@ function l1PreDispatchCheck(input, opts = {}) {
   const violations = [];
   const checkoutCache = new Map;
   const checkout = (path) => {
-    const key = resolve9(path);
+    const key = resolve10(path);
     if (!checkoutCache.has(key))
       checkoutCache.set(key, probeCheckout(path, opts));
     return checkoutCache.get(key);
@@ -4480,7 +4902,7 @@ function l1PreDispatchCheck(input, opts = {}) {
     }
   }
   const identityViolation = (aPath, bPath, code, describe, fix) => {
-    if (resolve9(aPath) === resolve9(bPath)) {
+    if (resolve10(aPath) === resolve10(bPath)) {
       return violation8("critical", code, `${describe} — the same checkout (normalized path equality) is not isolation`, fix);
     }
     if (!existsSync9(aPath) || !existsSync9(bPath))
@@ -4541,7 +4963,7 @@ function l2PreDispatchCheck(input, opts = {}) {
       violations.push(violation8("high", "worktree.l2.track-path-relative", `track ${index + 1} worktreePath "${track.worktreePath}" is not an absolute path — L2 tracks MUST use absolute worktree checkout paths (consistent with the lease validator's absolute worktree_path enforcement)`, `use an absolute path for track ${index + 1} (e.g. /Users/<you>/worktrees/<branch>)`));
       return;
     }
-    const normalized = resolve9(track.worktreePath);
+    const normalized = resolve10(track.worktreePath);
     if (seenPaths.has(normalized)) {
       violations.push(violation8("high", "worktree.l2.track-path-collision", `duplicate worktreePath "${track.worktreePath}" across parallel tracks — L2 parallel-writable isolation requires a distinct absolute Worktree path per track (N parallel invokes ≠ isolation)`, "give every parallel track its own git worktree checkout"));
       return;
@@ -4715,9 +5137,9 @@ function scanActiveLifecycleBranches(harnessDir, governingWorkflowId) {
 
 // src/sdd.ts
 import { execFileSync as execFileSync3, spawn } from "node:child_process";
-import { mkdirSync as mkdirSync6, readdirSync as readdirSync6, readFileSync as readFileSync9, realpathSync as realpathSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync7, readFileSync as readFileSync9, realpathSync as realpathSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { constants as osConstants } from "node:os";
-import { basename as basename7, dirname as dirname9, isAbsolute as isAbsolute8, join as join13, relative as relative3, resolve as resolve10 } from "node:path";
+import { basename as basename7, dirname as dirname9, isAbsolute as isAbsolute8, join as join13, relative as relative3, resolve as resolve11 } from "node:path";
 class SddScriptError extends Error {
   exitCode;
   constructor(message, exitCode) {
@@ -4775,7 +5197,7 @@ function hasWorkflowSnapshot(harnessDir) {
   if (!isDirectory2(workflowsDir))
     return false;
   try {
-    for (const entry of readdirSync6(workflowsDir, { withFileTypes: true })) {
+    for (const entry of readdirSync7(workflowsDir, { withFileTypes: true })) {
       if (entry.isDirectory() && isFile2(join13(workflowsDir, entry.name, "snapshot.json")))
         return true;
     }
@@ -4785,9 +5207,9 @@ function hasWorkflowSnapshot(harnessDir) {
   return false;
 }
 function checkoutRootNearestExisting(dir, boundary) {
-  const stop = resolve10(boundary);
-  const startInside = isInside(resolve10(dir), stop);
-  let current = resolve10(dir);
+  const stop = resolve11(boundary);
+  const startInside = isInside(resolve11(dir), stop);
+  let current = resolve11(dir);
   for (;; ) {
     const probed = probeCheckoutRoot(current);
     if (probed !== null)
@@ -4841,12 +5263,12 @@ function sddWorkspace(planId, opts = {}) {
   const harnessOverride = opts.harnessDir ?? (process.env.MSTAR_HARNESS_DIR || undefined);
   let harnessDir;
   if (harnessOverride) {
-    harnessDir = resolve10(root, harnessOverride);
+    harnessDir = resolve11(root, harnessOverride);
   } else {
     const rc = findMstarc(root, root);
     const rcHarnessDir = rc !== null ? parseMstarc(readFileSync9(rc, "utf8")).harnessDir : undefined;
     if (rcHarnessDir) {
-      harnessDir = resolve10(rc !== null ? dirname9(rc) : root, rcHarnessDir);
+      harnessDir = resolve11(rc !== null ? dirname9(rc) : root, rcHarnessDir);
     } else {
       const probed = probeHarnessWithStatus(root);
       if (probed) {
@@ -4878,7 +5300,7 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
   const bound = opts.context;
   const observedCwd = opts.cwd ?? process.cwd();
   if (bound) {
-    const inputPlan = canonicalizeNearestExisting(resolve10(observedCwd, planFile));
+    const inputPlan = canonicalizeNearestExisting(resolve11(observedCwd, planFile));
     if (inputPlan !== canonicalizeNearestExisting(bound.planFile)) {
       throwGateFail([
         contextViolation("high", "sdd.context.plan-file-mismatch", `plan file "${planFile}" does not match the bound context plan file "${bound.planFile}" — ` + "bound mode extracts only the resolved context's plan; refused before any read or write")
@@ -4894,7 +5316,7 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
   let out;
   let mkdirAfterGate = null;
   if (outFile) {
-    out = bound ? resolve10(observedCwd, outFile) : outFile;
+    out = bound ? resolve11(observedCwd, outFile) : outFile;
   } else if (bound) {
     out = join13(bound.sddDir, `task-${taskN}-brief.md`);
     mkdirAfterGate = bound.sddDir;
@@ -4937,7 +5359,7 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
   if (printed.length === 0) {
     throw new SddScriptError(`task ${taskN} not found in ${planFile} (no heading matching Task ${taskN})`, 3);
   }
-  return bound ? resolve10(observedCwd, out) : out;
+  return bound ? resolve11(observedCwd, out) : out;
 }
 function reviewPackage(base, head, outFile, opts = {}) {
   if (!base || !head) {
@@ -4958,7 +5380,7 @@ function reviewPackage(base, head, outFile, opts = {}) {
   let out;
   let mkdirAfterGate = null;
   if (outFile) {
-    out = bound ? resolve10(observedCwd, outFile) : outFile;
+    out = bound ? resolve11(observedCwd, outFile) : outFile;
   } else if (bound) {
     const shortBase = gitOut(cwd, ["rev-parse", "--short", base]) ?? base;
     const shortHead = gitOut(cwd, ["rev-parse", "--short", head]) ?? head;
@@ -5002,7 +5424,7 @@ function reviewPackage(base, head, outFile, opts = {}) {
     run(["diff", "-U10", `${base}..${head}`])
   ];
   writeFileSync4(out, Buffer.concat(parts));
-  return bound ? resolve10(observedCwd, out) : out;
+  return bound ? resolve11(observedCwd, out) : out;
 }
 function assertBaseSha(ref, opts = {}) {
   if (typeof ref !== "string" || !/^[0-9a-f]{4,40}$/i.test(ref)) {
@@ -5106,24 +5528,28 @@ function normalizeSnapshotWorktreePath(doc) {
   const { control_worktree_path: _dropped, ...rest } = doc;
   return { ...rest, integration_worktree_path: legacy };
 }
-function readActiveWorkflowIds(controlHarnessRoot) {
+function classifyWorkflowRegisterState(controlHarnessRoot) {
   const statusPath = join13(controlHarnessRoot, "status.json");
   if (!isFile2(statusPath))
-    return null;
+    return { state: "absent" };
   let doc;
   try {
     doc = readJson(statusPath);
   } catch {
-    return null;
+    return { state: "unreadable" };
   }
   if (!isPlainObject7(doc) || doc.version !== 2 || !Array.isArray(doc.workflows))
-    return null;
-  const ids = new Set;
+    return { state: "unreadable" };
+  const activeIds = new Set;
   for (const entry of doc.workflows) {
     if (isPlainObject7(entry) && typeof entry.id === "string")
-      ids.add(entry.id);
+      activeIds.add(entry.id);
   }
-  return ids;
+  return { state: "readable", activeIds };
+}
+function readActiveWorkflowIds(controlHarnessRoot) {
+  const register = classifyWorkflowRegisterState(controlHarnessRoot);
+  return register.state === "readable" ? register.activeIds : null;
 }
 function findWorkflowPlanRow(controlHarnessRoot, planId) {
   let workflowsDir;
@@ -5136,7 +5562,7 @@ function findWorkflowPlanRow(controlHarnessRoot, planId) {
     return { kind: "none" };
   let workflowIds;
   try {
-    workflowIds = readdirSync6(workflowsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    workflowIds = readdirSync7(workflowsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return { kind: "none" };
   }
@@ -5272,6 +5698,12 @@ function resolveSddExecutionContext(input) {
       contextViolation("critical", "sdd.context.feature-in-control", `featureCwd "${canonicalFeatureCwd}" is inside the control checkout "${controlCheckout}" and is not a distinct Git checkout — a plain subdirectory or symlink alias of the control checkout is not isolation; product edits never land in the control checkout (execution_lease.worktree_path MUST be a distinct checkout)`, "use a distinct feature worktree for the plan (git worktree add <path> <branch>)")
     ]);
   }
+  const registerState = classifyWorkflowRegisterState(canonicalControlHarnessRoot);
+  if (registerState.state === "unreadable") {
+    throwGateFail([
+      contextViolation("critical", "sdd.context.register-unreadable", `control harness root "${canonicalControlHarnessRoot}" has a status.json that is present but not a readable v2 workflow register (malformed JSON, non-v2 version, or missing workflows[]) — ` + 'a damaged register is never treated as "no register": registered active lifecycles cannot be resolved over it, so execution is refused (plan-workflow-lifecycle contract §6 S2) instead of silently continuing on branch alignment alone', "repair or migrate the control root's status.json to the v2 shape ('mstar migrate' / register repair), then retry the execution")
+    ]);
+  }
   const match = findWorkflowPlanRow(canonicalControlHarnessRoot, planId);
   if (match.kind === "ambiguous") {
     throwGateFail([
@@ -5314,6 +5746,11 @@ function resolveSddExecutionContext(input) {
   } else if (match.kind === "row" && match.row.status === "InProgress") {
     throwGateFail(verifyPlanExecutionLease(match.row, planId).violations);
   } else {
+    if (match.kind === "none" && registerState.state === "readable") {
+      throwGateFail([
+        contextViolation("high", "sdd.context.plan-not-registered", `plan "${planId}" has no active registered workflow row in the control harness's workflow register — ` + "on the normal plan route, SDD execution requires a registered running workflow row (plan-workflow-lifecycle contract §6 S2; a retained terminal snapshot's row is history, never registration evidence): " + "register it with `mstar workflow register --workflow <id> --plan-id <id> --plan-title <title> --plan-file <path> " + `--delivery-kind <${WORKFLOW_DELIVERY_KINDS.join("|")}> ...` + "` (`registerPlanWorkflow`), then retry — registration is create-only and preserves prior state; " + "re-running the same register command completes an interrupted registration without duplicating identity", "register the plan workflow, then retry the execution")
+      ]);
+    }
     const branchGate = assertBranchAlignment(canonicalFeatureCwd, workingBranch);
     if (!branchGate.ok)
       throwGateFail(branchGate.violations);
@@ -5343,11 +5780,11 @@ function checkSddAction(context, action) {
   const featureReal = canonicalDir(context.featureCwd);
   const canonicalSddDir = canonicalizeNearestExisting(context.sddDir);
   const canonicalPlanFile = canonicalizeNearestExisting(context.planFile);
-  const cwdResolved = resolve10(action.cwd);
+  const cwdResolved = resolve11(action.cwd);
   const checkTarget = (baseDir, target, kind) => {
     if (featureReal === null)
       return;
-    const targetAbs = resolve10(baseDir, target);
+    const targetAbs = resolve11(baseDir, target);
     const canonical = canonicalizeNearestExisting(targetAbs);
     if (!isInside(canonical, featureReal)) {
       const declaredPrefix = targetAbs === featureReal || targetAbs.startsWith(`${featureReal}/`);
@@ -5375,10 +5812,10 @@ function checkSddAction(context, action) {
       add("sdd.context.target-missing", "artifact checks require the destination target");
       return { ok: false, violations };
     }
-    const targetAbs = resolve10(cwdResolved, action.target);
+    const targetAbs = resolve11(cwdResolved, action.target);
     const canonical = canonicalizeNearestExisting(targetAbs);
     if (!isInside(canonical, canonicalSddDir) && canonical !== canonicalPlanFile) {
-      const rawSddDir = resolve10(context.sddDir);
+      const rawSddDir = resolve11(context.sddDir);
       const declaredPrefix = targetAbs === rawSddDir || targetAbs.startsWith(`${rawSddDir}/`) || targetAbs === canonicalSddDir || targetAbs.startsWith(`${canonicalSddDir}/`) || targetAbs === canonicalPlanFile;
       if (declaredPrefix) {
         add("sdd.context.artifact-symlink-escape", `artifact target "${targetAbs}" canonicalizes to "${canonical}", outside the plan's control sddDir — symlink escape refused before write`);
@@ -5465,7 +5902,7 @@ async function runInSddContext(context, argv) {
 }
 // src/gates.ts
 import { existsSync as existsSync11, statSync as statSync5 } from "node:fs";
-import { basename as basename8, dirname as dirname10, join as join14, relative as relative4, resolve as resolve11 } from "node:path";
+import { basename as basename8, dirname as dirname10, join as join14, relative as relative4, resolve as resolve12 } from "node:path";
 var STATUS_FILE = "status.json";
 var SNAPSHOT_FILE = "snapshot.json";
 var REGISTER_FILE = "residuals.json";
@@ -5505,7 +5942,7 @@ function hasHarnessRootMarkers(dir) {
   }
 }
 function resolveHarnessRootOf(target) {
-  let dir = resolve11(target);
+  let dir = resolve12(target);
   for (;; ) {
     if (hasHarnessRootMarkers(dir))
       return dir;
@@ -5518,7 +5955,7 @@ function resolveHarnessRootOf(target) {
 function harnessDocKindOfTarget(targetPath) {
   if (typeof targetPath !== "string" || targetPath.trim() === "")
     return null;
-  const resolved = resolve11(targetPath);
+  const resolved = resolve12(targetPath);
   const name = basename8(resolved);
   if (name !== STATUS_FILE && name !== SNAPSHOT_FILE && name !== REGISTER_FILE)
     return null;
@@ -5638,8 +6075,8 @@ function formatStatusWriteBlockReason(violations, skillPointer) {
 `);
 }
 // src/migrate.ts
-import { copyFileSync, mkdirSync as mkdirSync7, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename9, dirname as dirname11, isAbsolute as isAbsolute9, join as join15, relative as relative5, resolve as resolve12, sep as sep3 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync10, readdirSync as readdirSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename9, dirname as dirname11, isAbsolute as isAbsolute9, join as join15, relative as relative5, resolve as resolve13, sep as sep3 } from "node:path";
 var MIGRATE_STATUS_FILE = "status.json";
 var ARCHIVED_STATUS_V1_FILE = "archived/status.v1.json";
 var NOTES_LEDGER_FILE = "notes.jsonl";
@@ -5683,7 +6120,7 @@ function scanCompasses(harnessDir) {
   const out = [];
   let entries;
   try {
-    entries = readdirSync7(iterationsDir, { withFileTypes: true });
+    entries = readdirSync8(iterationsDir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -5775,7 +6212,7 @@ function buildIterationSnapshot(compass, rowById, rootUpdatedAt) {
     data: snapshot
   };
 }
-function buildStandaloneSnapshot(row, rootUpdatedAt, migrationNotes) {
+function buildStandaloneSnapshot(row, rootUpdatedAt, migrationNotes, declaration = {}) {
   const id = rowIdOf(row) ?? "<unnamed>";
   const statusValue = row.status;
   let status;
@@ -5802,6 +6239,17 @@ function buildStandaloneSnapshot(row, rootUpdatedAt, migrationNotes) {
     updated_at: status === "completed" ? endedAt : updatedAt,
     plans: [row]
   };
+  if (status !== "completed" && declaration.deliveryKind !== undefined) {
+    snapshot.delivery_kind = declaration.deliveryKind;
+    if (declaration.branchSource !== undefined || declaration.branchTarget !== undefined) {
+      snapshot.branch = {
+        ...declaration.branchSource !== undefined ? { source: declaration.branchSource } : {},
+        ...declaration.branchTarget !== undefined ? { target: declaration.branchTarget } : {}
+      };
+    }
+    if (declaration.completionPolicy !== undefined)
+      snapshot.completion_policy = declaration.completionPolicy;
+  }
   return {
     id,
     type: "plan",
@@ -5953,10 +6401,22 @@ function collectNotesFiles(snapshots) {
   return out;
 }
 function migrateHarnessTree(root, opts = {}) {
-  const harnessDir = resolve12(root);
+  const harnessDir = resolve13(root);
   const workflowDir = resolveWorkflowDir(harnessDir, { harnessDir });
   const projectDir = resolveProjectDir(harnessDir, { harnessDir });
   const projectId = opts.projectId ?? _DEFAULT_PROJECT;
+  if (opts.deliveryKind !== undefined && !WORKFLOW_DELIVERY_KINDS.includes(opts.deliveryKind)) {
+    throw new Error(`refusing to migrate: options.deliveryKind must be one of ${WORKFLOW_DELIVERY_KINDS.join(" | ")} — got ${JSON.stringify(opts.deliveryKind)}`);
+  }
+  if (opts.deliveryKind !== undefined) {
+    assertDeliveryRegistrationCoherence(opts.deliveryKind, opts, "migrate");
+  }
+  const declaration = {
+    deliveryKind: opts.deliveryKind,
+    branchSource: opts.branchSource,
+    branchTarget: opts.branchTarget,
+    completionPolicy: opts.completionPolicy
+  };
   const statusPath = join15(harnessDir, MIGRATE_STATUS_FILE);
   const source = readArtifactBytes(statusPath);
   const sourceVersion = source?.version ?? "absent";
@@ -5972,6 +6432,8 @@ function migrateHarnessTree(root, opts = {}) {
       alreadyMigrated: true,
       message: `no-op: ${statusPath} is already at schema version 2 (migrated) — nothing to do`,
       snapshots: [],
+      deliveryKindRequired: [],
+      deliveryKindAmbiguous: [],
       notesFiles: [],
       register: null,
       roadmap: null,
@@ -6022,8 +6484,11 @@ function migrateHarnessTree(root, opts = {}) {
   for (const row of rows) {
     const id = rowIdOf(row);
     if (id !== null && !byPlan.has(id))
-      snapshots.push(buildStandaloneSnapshot(row, rootUpdatedAt, migrationNotes));
+      snapshots.push(buildStandaloneSnapshot(row, rootUpdatedAt, migrationNotes, declaration));
   }
+  const deliveryKindRequired = snapshots.filter((snapshot) => snapshot.type === "plan" && snapshot.status !== "completed" && snapshot.data.delivery_kind === undefined).map((snapshot) => snapshot.id);
+  const declaredKindTargets = declaration.deliveryKind === undefined ? [] : snapshots.filter((snapshot) => snapshot.type === "plan" && snapshot.status !== "completed" && snapshot.data.delivery_kind !== undefined).map((snapshot) => snapshot.id).sort(compareIds);
+  const deliveryKindAmbiguous = declaredKindTargets.length > 1 ? declaredKindTargets : [];
   const lifecycleSources = new Map;
   for (const snapshot of snapshots) {
     const sources = lifecycleSources.get(snapshot.id) ?? [];
@@ -6093,6 +6558,8 @@ function migrateHarnessTree(root, opts = {}) {
     alreadyMigrated: false,
     message: `planned migration of ${snapshots.length} lifecycles (${steps.length} steps)`,
     snapshots,
+    deliveryKindRequired,
+    deliveryKindAmbiguous,
     notesFiles,
     register,
     roadmap,
@@ -6106,14 +6573,20 @@ async function applyMigratePlan(plan) {
   if (plan.dryRun) {
     return { applied: false, message: `dry-run: ${plan.steps.length} steps planned (source → destination), zero writes` };
   }
+  if (plan.deliveryKindAmbiguous.length > 0) {
+    throw new Error(`refusing to apply migration: one delivery declaration cannot describe ` + `${plan.deliveryKindAmbiguous.length} active standalone plan lifts (${plan.deliveryKindAmbiguous.join(", ")}) — ` + `migrate them in batches of one declared lifecycle (CLI: run migrate once per plan, each with its own --delivery-kind)`);
+  }
+  if (plan.deliveryKindRequired.length > 0) {
+    throw new Error(`refusing to apply migration: ${plan.deliveryKindRequired.length} active standalone plan snapshot(s) ` + `(${plan.deliveryKindRequired.join(", ")}) would be lifted without a declared delivery kind — ` + `re-plan with an explicit deliveryKind (CLI: --delivery-kind <${WORKFLOW_DELIVERY_KINDS.join("|")}>)`);
+  }
   const statusPath = join15(plan.root, MIGRATE_STATUS_FILE);
   const current = readJson(statusPath);
   if (current.version === 2) {
     return { applied: false, message: "no-op: status.json already at schema version 2 (migrated) — nothing to do" };
   }
-  const harnessRoot = resolve12(plan.root);
-  const workflowRoot = resolve12(plan.workflowDir);
-  const projectRoot = resolve12(plan.projectDir);
+  const harnessRoot = resolve13(plan.root);
+  const workflowRoot = resolve13(plan.workflowDir);
+  const projectRoot = resolve13(plan.projectDir);
   if (!isAbsolute9(plan.workflowDir) || !isAbsolute9(plan.projectDir)) {
     throw new Error(`refusing to apply migration: plan workflowDir/projectDir must be absolute (got ${JSON.stringify(plan.workflowDir)} / ${JSON.stringify(plan.projectDir)})`);
   }
@@ -6125,7 +6598,7 @@ async function applyMigratePlan(plan) {
     ...plan.roadmap !== null ? [plan.roadmap.file] : []
   ];
   for (const destination of allDestinations) {
-    const resolvedDest = resolve12(join15(plan.root, destination));
+    const resolvedDest = resolve13(join15(plan.root, destination));
     const inside = (dir) => resolvedDest === dir || resolvedDest.startsWith(`${dir}${sep3}`);
     if (!inside(harnessRoot) && !inside(workflowRoot) && !inside(projectRoot)) {
       throw new Error(`refusing to apply migration: destination escapes the harness dir (${JSON.stringify(destination)}) — every write must stay under ${JSON.stringify(plan.root)}, the workflow dir (${JSON.stringify(plan.workflowDir)}) or the project dir (${JSON.stringify(plan.projectDir)})`);
@@ -6134,6 +6607,32 @@ async function applyMigratePlan(plan) {
   const store = getArtifactStore();
   return withStatusWriteLock(statusPath, () => applyMigratePlanLocked(plan, statusPath, store, workflowRoot, projectRoot));
 }
+function rawTargetStoreError(filePath, error) {
+  return new CoordinationError("coordination.store", `cannot write migration target ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
+}
+function writeRawMigrateTarget(filePath, expected) {
+  try {
+    mkdirSync7(dirname11(filePath), { recursive: true });
+  } catch (error) {
+    throw rawTargetStoreError(filePath, error);
+  }
+  try {
+    writeFileSync5(filePath, expected, { flag: "wx" });
+    return;
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw rawTargetStoreError(filePath, error);
+  }
+  let existing;
+  try {
+    existing = readFileSync10(filePath);
+  } catch (error) {
+    throw rawTargetStoreError(filePath, error);
+  }
+  if (Buffer.compare(existing, expected) !== 0) {
+    throw new CoordinationError("coordination.version-conflict", `refusing to apply migration: ${filePath} already exists with different content — migration is additive-only`, { path: filePath });
+  }
+}
 async function applyMigratePlanLocked(plan, statusPath, store, workflowRoot, projectRoot) {
   const workflowTargetOf = (canonicalFile) => join15(workflowRoot, relative5("workflows", canonicalFile));
   const projectTargetOf = (canonicalFile) => join15(projectRoot, relative5("projects", canonicalFile));
@@ -6146,8 +6645,7 @@ async function applyMigratePlanLocked(plan, statusPath, store, workflowRoot, pro
   if (sourceVersion !== plan.sourceVersion) {
     throw new CoordinationError("coordination.version-conflict", `refusing to apply migration: ${statusPath} changed since the plan was built (planned ${plan.sourceVersion}, found ${sourceVersion}) — re-run the plan against the current root`, { path: statusPath, expected: plan.sourceVersion, actual: sourceVersion });
   }
-  mkdirSync7(join15(plan.root, dirname11(plan.archive.file)), { recursive: true });
-  copyFileSync(statusPath, join15(plan.root, plan.archive.file));
+  writeRawMigrateTarget(join15(plan.root, plan.archive.file), readFileSync10(statusPath));
   for (const snapshot of plan.snapshots) {
     const snapshotDir = dirname11(workflowTargetOf(snapshot.file));
     const snapshotPath = join15(snapshotDir, WORKFLOW_SNAPSHOT_FILE);
@@ -6161,12 +6659,10 @@ async function applyMigratePlanLocked(plan, statusPath, store, workflowRoot, pro
     }
   }
   for (const notes of plan.notesFiles) {
-    const filePath = workflowTargetOf(notes.file);
-    mkdirSync7(dirname11(filePath), { recursive: true });
     const content = notes.lines.length > 0 ? `${notes.lines.join(`
 `)}
 ` : "";
-    writeFileSync5(filePath, content, "utf8");
+    writeRawMigrateTarget(workflowTargetOf(notes.file), Buffer.from(content, "utf8"));
   }
   if (plan.register !== null) {
     const registerData = plan.register.data;
@@ -6192,9 +6688,7 @@ async function applyMigratePlanLocked(plan, statusPath, store, workflowRoot, pro
     }
   }
   if (plan.roadmap !== null) {
-    const filePath = projectTargetOf(plan.roadmap.file);
-    mkdirSync7(dirname11(filePath), { recursive: true });
-    writeFileSync5(filePath, plan.roadmap.content, "utf8");
+    writeRawMigrateTarget(projectTargetOf(plan.roadmap.file), Buffer.from(plan.roadmap.content, "utf8"));
   }
   const rootGate = validateStatusV2(plan.rootV2.data, { harnessDir: plan.root });
   if (!rootGate.ok) {
@@ -6609,8 +7103,8 @@ function completenessLevel(frontmatterText, checklist) {
 }
 // src/audit.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync8, readFileSync as readFileSync11, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename10, join as join16, resolve as resolve13, sep as sep4 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync11, rmdirSync as rmdirSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename10, join as join16, resolve as resolve14, sep as sep4 } from "node:path";
 function violation10(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -6963,7 +7457,7 @@ var LOCKFILE_NAMES = [
 function rootLockfiles(root) {
   let entries;
   try {
-    entries = readdirSync8(root, { withFileTypes: true });
+    entries = readdirSync9(root, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -6996,7 +7490,7 @@ function supplyChainChecks(repoRoot) {
   const workflowsDir = join16(repoRoot, ".github", "workflows");
   let wfEntries = [];
   try {
-    wfEntries = readdirSync8(workflowsDir, { withFileTypes: true });
+    wfEntries = readdirSync9(workflowsDir, { withFileTypes: true });
   } catch {
     wfEntries = [];
   }
@@ -7162,7 +7656,7 @@ function scaffoldAuditPlan(outDir, findings, options = {}) {
   mkdirSync8(outDir, { recursive: true });
   const existingReadme = join16(outDir, "README.md");
   const carried = existsSync12(existingReadme) ? extractSecurityDispositionSections(readFileSync11(existingReadme, "utf8")) : { needsVerification: [], hardeningChecked: [] };
-  const existing = readdirSync8(outDir).filter((f) => /^\d{3}-.*\.md$/.test(f));
+  const existing = readdirSync9(outDir).filter((f) => /^\d{3}-.*\.md$/.test(f));
   let next = existing.reduce((max, f) => Math.max(max, Number(f.slice(0, 3))), 0) + 1;
   const redactedFindings = findings.map(redactFinding);
   const written = [];
@@ -7227,7 +7721,7 @@ function scaffoldAuditPlan(outDir, findings, options = {}) {
     needsVerification: needsVerificationLines,
     hardeningChecked: hardeningCheckedLines
   }));
-  return { outDir: resolve13(outDir), date, files: written, nextNumber: next };
+  return { outDir: resolve14(outDir), date, files: written, nextNumber: next };
 }
 async function promoteAuditPlans(outDir, selected, options) {
   if (selected.length === 0) {
@@ -7236,9 +7730,13 @@ async function promoteAuditPlans(outDir, selected, options) {
   if (typeof options.harnessDir !== "string" || options.harnessDir.trim() === "") {
     throw new Error("promoteAuditPlans: options.harnessDir is required (must contain status.json + workflows/)");
   }
-  const workflowId = options.workflowId ?? basename10(resolve13(outDir));
+  if (typeof options.deliveryKind !== "string" || !WORKFLOW_DELIVERY_KINDS.includes(options.deliveryKind)) {
+    throw new Error(`promoteAuditPlans: options.deliveryKind must be one of ${WORKFLOW_DELIVERY_KINDS.join(" | ")} — got ${JSON.stringify(options.deliveryKind)} (a promoted plan workflow declares its delivery kind at registration; it is never inferred and never defaulted)`);
+  }
+  assertDeliveryRegistrationCoherence(options.deliveryKind, options, "promoteAuditPlans");
+  const workflowId = options.workflowId ?? basename10(resolve14(outDir));
   assertSafePathComponent(workflowId, "workflow id");
-  const harnessDir = resolve13(options.harnessDir);
+  const harnessDir = resolve14(options.harnessDir);
   const statusPath = join16(harnessDir, "status.json");
   const workflowDir = join16(harnessDir, "workflows", workflowId);
   const snapshotPath = join16(workflowDir, WORKFLOW_SNAPSHOT_FILE);
@@ -7265,8 +7763,17 @@ async function promoteAuditPlans(outDir, selected, options) {
     status: "running",
     started_at: now.toISOString(),
     updated_at: now.toISOString().slice(0, 10),
-    plans
+    plans,
+    delivery_kind: options.deliveryKind
   };
+  if (options.branchSource !== undefined || options.branchTarget !== undefined) {
+    snapshot.branch = {
+      ...options.branchSource !== undefined ? { source: options.branchSource } : {},
+      ...options.branchTarget !== undefined ? { target: options.branchTarget } : {}
+    };
+  }
+  if (options.completionPolicy !== undefined)
+    snapshot.completion_policy = options.completionPolicy;
   const entry = {
     id: workflowId,
     type: "plan",
@@ -7299,8 +7806,8 @@ async function promoteAuditPlans(outDir, selected, options) {
         });
       }
       try {
-        if (readdirSync8(workflowDir).length === 0) {
-          rmdirSync2(workflowDir);
+        if (readdirSync9(workflowDir).length === 0) {
+          rmdirSync3(workflowDir);
         }
       } catch {}
       throw error;
@@ -7310,7 +7817,7 @@ async function promoteAuditPlans(outDir, selected, options) {
   return { workflowId, snapshotPath };
 }
 function resolveSelectedPlanFiles(outDir, selected) {
-  const files = readdirSync8(outDir).filter((f) => /^\d{3}-.*\.md$/.test(f)).sort();
+  const files = readdirSync9(outDir).filter((f) => /^\d{3}-.*\.md$/.test(f)).sort();
   const byNum = new Map;
   const byStem = new Map;
   for (const file of files) {
@@ -7325,7 +7832,7 @@ function resolveSelectedPlanFiles(outDir, selected) {
   for (const id of selected) {
     const file = byNum.get(id) ?? byStem.get(id) ?? byStem.get(id.replace(/\.md$/, ""));
     if (file === undefined) {
-      throw new Error(`promoteAuditPlans: selected plan ${JSON.stringify(id)} does not match any NNN-*.md file in ${resolve13(outDir)}`);
+      throw new Error(`promoteAuditPlans: selected plan ${JSON.stringify(id)} does not match any NNN-*.md file in ${resolve14(outDir)}`);
     }
     if (!seen.has(file)) {
       seen.add(file);
@@ -7364,7 +7871,7 @@ function readExecutionOrderIndex(outDir) {
   return rows;
 }
 function planFileRel(outDir, planFile) {
-  const resolved = resolve13(outDir);
+  const resolved = resolve14(outDir);
   const parts = resolved.split(sep4);
   const plansIdx = parts.lastIndexOf("plans");
   if (plansIdx >= 0) {
@@ -7373,8 +7880,8 @@ function planFileRel(outDir, planFile) {
   return planFile;
 }
 // src/compound.ts
-import { existsSync as existsSync13, readdirSync as readdirSync9, readFileSync as readFileSync12 } from "node:fs";
-import { basename as basename11, isAbsolute as isAbsolute10, join as join17, relative as relative6, resolve as resolve14, sep as sep5 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync10, readFileSync as readFileSync12 } from "node:fs";
+import { basename as basename11, isAbsolute as isAbsolute10, join as join17, relative as relative6, resolve as resolve15, sep as sep5 } from "node:path";
 function violation11(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -7660,7 +8167,7 @@ function referenceExists(repoRoot, docText) {
       const dir = stack.pop();
       let entries;
       try {
-        entries = readdirSync9(dir, { withFileTypes: true });
+        entries = readdirSync10(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -7681,7 +8188,7 @@ function referenceExists(repoRoot, docText) {
   for (const { ref, isSymbol, module } of refs) {
     if (!isSymbol || module === undefined) {
       const candidate = ref.replace(LINE_SUFFIX_RE, "").replace(ANCHOR_RE, "");
-      if (existsSync13(resolve14(repoRoot, candidate))) {
+      if (existsSync13(resolve15(repoRoot, candidate))) {
         checked++;
       } else {
         violations.push(violation11("medium", "compound.reference.missing-file", `referenced path \`${ref}\` does not exist under ${repoRoot} (compound-refresh Phase 2: referenced code still exists?)`, "update the doc to reference an existing path, or delete the stale reference"));
@@ -7701,7 +8208,7 @@ function collectKnowledgeDocs(dir) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync9(current, { withFileTypes: true });
+      entries = readdirSync10(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -7764,9 +8271,9 @@ function isFileLikeRoot(root) {
   return /^[^.]*\.[A-Za-z0-9]{1,10}$/.test(basename11(root));
 }
 function scopeGuard(path, allowedRoots) {
-  const resolved = resolve14(path);
+  const resolved = resolve15(path);
   for (const root of allowedRoots) {
-    const r = resolve14(root);
+    const r = resolve15(root);
     if (isFileLikeRoot(r)) {
       if (resolved === r)
         return { ok: true, violations: [] };
@@ -8395,7 +8902,7 @@ function resolveAssetPath(skillName, relPath, host) {
   return `skill \`${skillName}\` → ${relPath} (${resolveSkillRoot(host, { skill: skillName, rel: relPath })})`;
 }
 // src/prreview.ts
-import { readdirSync as readdirSync10 } from "node:fs";
+import { readdirSync as readdirSync11 } from "node:fs";
 import { isAbsolute as isAbsolute11, join as join19 } from "node:path";
 var MERGE_CLASSES = ["must-fix", "should-fix", "nit"];
 var PR_VERDICTS = ["ship it", "needs fixes", "blocked"];
@@ -8636,7 +9143,7 @@ function prReviewReportPath(opts) {
   const sameStem = new RegExp(`^${escaped}(?:-r([0-9]+))?\\.md$`);
   let dirents;
   try {
-    dirents = readdirSync10(opts.reportsDir, { withFileTypes: true });
+    dirents = readdirSync11(opts.reportsDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT")
       dirents = [];
@@ -9361,7 +9868,7 @@ function validateQcReport(text) {
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync13, statSync as statSync6, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename12, dirname as dirname12, isAbsolute as isAbsolute12, join as join20, resolve as resolve15, sep as sep6 } from "node:path";
+import { basename as basename12, dirname as dirname12, isAbsolute as isAbsolute12, join as join20, resolve as resolve16, sep as sep6 } from "node:path";
 var SESSION_DIR = "sessions";
 var SNAPSHOT_FILE2 = "snapshot.json";
 var ENVELOPE_KEYS = ["schema_version", "role", "session_id", "workflow_id", "plan_id", "harness_root"];
@@ -9460,7 +9967,7 @@ function localStore(harnessRoot) {
   try {
     store = getArtifactStore();
   } catch (error) {
-    throw new CoordinationError("coordination.local-store-required", `no artifact store is resolvable from ${resolve15(process.cwd())} — scoped coordination requires createFsStore(<control harness root>): ${errorMessage(error)}`, { harness_root: harnessRoot });
+    throw new CoordinationError("coordination.local-store-required", `no artifact store is resolvable from ${resolve16(process.cwd())} — scoped coordination requires createFsStore(<control harness root>): ${errorMessage(error)}`, { harness_root: harnessRoot });
   }
   const root = "root" in store ? store.root : undefined;
   if (typeof root !== "string") {
@@ -9479,8 +9986,8 @@ function isWithin(parent, child) {
 }
 function resolveProcessHarnessDir(cwd = process.cwd(), harnessDir) {
   if (isNonEmptyString(harnessDir))
-    return resolve15(cwd, harnessDir);
-  const start = resolve15(cwd);
+    return resolve16(cwd, harnessDir);
+  const start = resolve16(cwd);
   const main = readMainWorktree(start);
   if (main !== null)
     return resolveHarnessDir(main.root);
@@ -9520,7 +10027,7 @@ var ASSIGNMENT_FIELDS = [
 ];
 var ABSOLUTE_PATH_HEADERS = ["control harness root", "plan path", "worktree path", "sdd dir"];
 function parseAssignmentFile(assignmentPath) {
-  const abs = resolve15(assignmentPath);
+  const abs = resolve16(assignmentPath);
   if (!existsSync15(abs)) {
     throw new CoordinationError("coordination.assignment-invalid", `Assignment not found: ${abs}`, { path: abs });
   }
@@ -9652,7 +10159,7 @@ function registerPathOf(harnessRoot, projectId) {
 }
 function scopeFromAssignment(assignment, cwd, options) {
   const harnessRoot = assignment.controlHarnessRoot;
-  const processRoot = resolveProcessHarnessDir(cwd);
+  const processRoot = options.chosenRoot === undefined ? resolveProcessHarnessDir(cwd) : null;
   if (processRoot !== null && canonicalTarget(processRoot) !== harnessRoot) {
     throw new CoordinationError("coordination.scope-mismatch", `Assignment "Control harness root" ${harnessRoot} does not match the process harness root ${canonicalTarget(processRoot)}`, { expected: harnessRoot, actual: canonicalTarget(processRoot) });
   }
@@ -9719,7 +10226,7 @@ async function resolvePlanScope(input, cwd = process.cwd()) {
   }
   const harnessRoot = resolveProcessHarnessDir(cwd, harnessDir);
   if (harnessRoot === null) {
-    throw new CoordinationError("coordination.harness-not-found", `no harness root is resolvable from ${resolve15(cwd)} — pass the control harness root explicitly`, { cwd: resolve15(cwd) });
+    throw new CoordinationError("coordination.harness-not-found", `no harness root is resolvable from ${resolve16(cwd)} — pass the control harness root explicitly`, { cwd: resolve16(cwd) });
   }
   const snapshot = readSnapshot(dirname12(snapshotPathOf(harnessRoot, workflowId)));
   const { row } = findPlanRow2(snapshot, planId);
@@ -9734,7 +10241,7 @@ function readSessionEnvelope(sessionPath) {
   if (!isNonEmptyString(sessionPath) || !isAbsolute12(sessionPath)) {
     throw invalidInput("sessionPath must be an absolute path");
   }
-  const abs = resolve15(sessionPath);
+  const abs = resolve16(sessionPath);
   if (!existsSync15(abs)) {
     throw new CoordinationError("coordination.session-not-found", `session envelope not found: ${abs}`, { path: abs });
   }
@@ -10081,11 +10588,12 @@ function assertRootRegisterEntry(harnessRoot, workflowId) {
   if (entry === undefined) {
     throw new CoordinationError("coordination.workflow-not-found", `workflow ${workflowId} is not an active entry of ${path} (kind ${store.root})`, { path, workflow_id: workflowId });
   }
+  return entry;
 }
 function assertCoordinatorResidency(cwd, snapshot) {
   const main = readMainWorktree(cwd);
   if (main === null) {
-    throw new CoordinationError("coordination.not-in-git", `coordinator binding requires a Git process root — ${resolve15(cwd)} has no readable main worktree`, { cwd: resolve15(cwd) });
+    throw new CoordinationError("coordination.not-in-git", `coordinator binding requires a Git process root — ${resolve16(cwd)} has no readable main worktree`, { cwd: resolve16(cwd) });
   }
   const here = canonicalizeNearestExisting(cwd);
   const allowed = [canonicalTarget(main.root)];
@@ -10142,7 +10650,7 @@ async function bindCoordinatorSession(cwd, workflowId, harnessDir) {
 function requireProcessRoot(cwd, harnessDir) {
   const root = resolveProcessHarnessDir(cwd, harnessDir);
   if (root === null) {
-    throw new CoordinationError("coordination.harness-not-found", `no harness root is resolvable from ${resolve15(cwd)} — pass the control harness root explicitly`, { cwd: resolve15(cwd) });
+    throw new CoordinationError("coordination.harness-not-found", `no harness root is resolvable from ${resolve16(cwd)} — pass the control harness root explicitly`, { cwd: resolve16(cwd) });
   }
   return root;
 }
@@ -10657,7 +11165,10 @@ async function mutatePlanCoordination(request) {
         throw invalidInput("prepare requires an absolute assignmentPath");
       }
       const assignment = parseAssignmentFile(operation.assignmentPath);
-      const scope = scopeFromAssignment(assignment, session.harness_root, { requirePrepared: false });
+      const scope = scopeFromAssignment(assignment, session.harness_root, {
+        requirePrepared: false,
+        chosenRoot: session.harness_root
+      });
       if (request.planId !== undefined && request.planId !== scope.planId) {
         throw new CoordinationError("coordination.scope-mismatch", `request planId ${request.planId} is not the Assignment's plan ${scope.planId}`, { expected: scope.planId, actual: request.planId });
       }
@@ -10833,7 +11344,7 @@ function gitCheckout(path) {
   let operation;
   for (const [marker, label] of UNFINISHED_GIT_OPERATIONS) {
     const markerPath = gitRead(path, ["rev-parse", "--git-path", marker]);
-    if (markerPath !== undefined && markerPath.length > 0 && existsSync15(resolve15(path, markerPath))) {
+    if (markerPath !== undefined && markerPath.length > 0 && existsSync15(resolve16(path, markerPath))) {
       operation = label;
       break;
     }
@@ -11762,6 +12273,624 @@ async function replaceProjectRegister(input, harnessRoot) {
     });
   });
 }
+var PREPARE_PHASE = "phase-1-prepare";
+var PREPARE_PATCH_KEYS = [
+  "mainWorktreeBranch",
+  "appendPlans",
+  "integrationWorktreePath",
+  "planParallelism"
+];
+var PREPARE_APPEND_KEYS = ["id", "title", "file", "metadata"];
+var PREPARE_APPEND_METADATA_KEYS = [
+  "primary_spec",
+  "spec_refs",
+  "iteration_compass",
+  "iteration_refs",
+  "working_branch",
+  "spec_integration_branch",
+  "merge_target"
+];
+var PLAN_PARALLELISM_VALUES = ["serial", "parallel"];
+function prepareAmendmentRefusal(reason, message, details = {}) {
+  const code = `coordination.prepare-amendment.${reason}`;
+  return new CoordinationError(code, message, details);
+}
+function prepareWorkflowScope(sessionPath, cwd) {
+  const session = readSessionEnvelope(sessionPath);
+  if (session.role !== "coordinator") {
+    throw new CoordinationError("coordination.session-role", `workflow Prepare verbs require a coordinator session, not ${session.role}`, { actual: session.role });
+  }
+  const harnessRoot = canonicalizeNearestExisting(session.harness_root);
+  localStore(harnessRoot);
+  const processRoot = resolveProcessHarnessDir(cwd);
+  if (processRoot !== null && canonicalTarget(processRoot) !== harnessRoot) {
+    throw new CoordinationError("coordination.scope-mismatch", `session ${session.session_id} belongs to harness root ${harnessRoot}, but this process resolves ${canonicalTarget(processRoot)}`, { expected: harnessRoot, actual: canonicalTarget(processRoot) });
+  }
+  const workflowId = safePlanId(session.workflow_id, "workflow_id");
+  const snapshotPath = assertSnapshotPath(harnessRoot, workflowId, snapshotPathOf(harnessRoot, workflowId));
+  return { session, sessionPath: canonicalTarget(sessionPath), harnessRoot, workflowId, snapshotPath };
+}
+function readPrepareSnapshot(snapshotPath) {
+  const bytes = readArtifactBytes(snapshotPath);
+  if (bytes === undefined) {
+    throw new CoordinationError("coordination.workflow-not-found", `workflow snapshot not found: ${snapshotPath}`, {
+      path: snapshotPath
+    });
+  }
+  return { snapshot: readSnapshot(dirname12(snapshotPath)), version: bytes.version };
+}
+function prepareCompassDeclaration(frontmatter, key, workflowId, path) {
+  const value = frontmatter[key];
+  if (value === undefined)
+    return;
+  if (!isNonEmptyString(value)) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${workflowId} compass ${path} declares a malformed ${key} — every declaration must be a non-empty string`, { workflow_id: workflowId, path, field: key, actual: value });
+  }
+  return value;
+}
+function readPrepareCompass(harnessRoot, snapshot) {
+  const ref = snapshot.compass_ref;
+  if (!isNonEmptyString(ref) || isAbsolute12(ref)) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} declares no usable compass_ref — the amendment requires the reviewed iteration compass`, { workflow_id: snapshot.id, actual: ref ?? null });
+  }
+  const root = canonicalizeNearestExisting(harnessRoot);
+  const path = canonicalTarget(join20(harnessRoot, ref));
+  if (!isWithin(root, path)) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass_ref ${JSON.stringify(ref)} resolves outside the harness root ${root}`, { workflow_id: snapshot.id, path, expected: ref });
+  }
+  let bytes;
+  try {
+    bytes = readFileSync13(path);
+  } catch (error) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass ${path} is unreadable: ${errorMessage(error)}`, { workflow_id: snapshot.id, path });
+  }
+  let frontmatter;
+  try {
+    frontmatter = parseCompassFrontmatterText(bytes.toString("utf8"), path);
+  } catch (error) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass ${path} has no parsable frontmatter: ${errorMessage(error)}`, { workflow_id: snapshot.id, path });
+  }
+  const iterationId = frontmatter.iteration_id;
+  if (!isNonEmptyString(iterationId)) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass ${path} declares no iteration_id — a lifecycle amends only its own compass`, { workflow_id: snapshot.id, path, actual: iterationId ?? null });
+  }
+  if (iterationId !== snapshot.id) {
+    throw prepareAmendmentRefusal("compass-mismatch", `compass ${path} declares iteration_id ${iterationId}, not workflow ${snapshot.id} — a lifecycle amends only its own compass`, { workflow_id: snapshot.id, expected: snapshot.id, actual: iterationId });
+  }
+  const declaredPlans = frontmatter.plans;
+  if (!Array.isArray(declaredPlans) || declaredPlans.length === 0) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass ${path} declares no plan ids in its frontmatter — the amendment cannot verify the approved plan set`, { workflow_id: snapshot.id, path, actual: declaredPlans ?? null });
+  }
+  const malformed = declaredPlans.filter((entry) => !isNonEmptyString(entry));
+  if (malformed.length > 0) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass ${path} declares ${malformed.length} malformed plan id(s) — every plans entry must be a non-empty string`, { workflow_id: snapshot.id, path, plans: declaredPlans });
+  }
+  const planIds = declaredPlans;
+  if (new Set(planIds).size !== planIds.length) {
+    throw prepareAmendmentRefusal("compass-mismatch", `workflow ${snapshot.id} compass ${path} declares the same plan id more than once — the reviewed plan set is not a multiset`, { workflow_id: snapshot.id, path, plans: planIds });
+  }
+  const specIntegrationBranch = prepareCompassDeclaration(frontmatter, "spec_integration_branch", snapshot.id, path);
+  const integrationWorktreePath = prepareCompassDeclaration(frontmatter, "integration_worktree_path", snapshot.id, path);
+  return {
+    path,
+    version: `sha256:${sha256Bytes(bytes)}`,
+    planIds,
+    ...specIntegrationBranch !== undefined ? { specIntegrationBranch } : {},
+    ...integrationWorktreePath !== undefined ? { integrationWorktreePath } : {}
+  };
+}
+function prepareAdmission(harnessRoot, workflowId, snapshot) {
+  const entry = assertRootRegisterEntry(harnessRoot, workflowId);
+  if (isNonEmptyString(entry.status) && entry.status !== "running") {
+    return {
+      ok: false,
+      reason: "not-prepare",
+      message: `root register entry ${workflowId} is ${entry.status} — the amendment is available only while the lifecycle runs`,
+      details: { workflow_id: workflowId, status: entry.status }
+    };
+  }
+  if (snapshot.status !== "running") {
+    return {
+      ok: false,
+      reason: "not-prepare",
+      message: `workflow ${workflowId} is ${snapshot.status} — the amendment is available only in Prepare`,
+      details: { workflow_id: workflowId, status: snapshot.status }
+    };
+  }
+  if (snapshot.phase !== PREPARE_PHASE) {
+    return {
+      ok: false,
+      reason: "not-prepare",
+      message: `workflow ${workflowId} is in ${snapshot.phase ?? "no declared phase"}, not ${PREPARE_PHASE}`,
+      details: { workflow_id: workflowId, expected: PREPARE_PHASE, actual: snapshot.phase ?? null }
+    };
+  }
+  if (snapshot.integration_merge_lease !== undefined) {
+    return {
+      ok: false,
+      reason: "execution-started",
+      message: `workflow ${workflowId} carries an integration merge lease — execution ownership already exists`,
+      details: { workflow_id: workflowId }
+    };
+  }
+  for (const row of snapshot.plans) {
+    const planId = rowPlanIds(row)[0] ?? "";
+    const status = rowStatusOf(row);
+    if (status !== "Todo") {
+      return {
+        ok: false,
+        reason: "execution-started",
+        message: `plan ${planId} is ${status} — the amendment is available only while every row is Todo`,
+        details: { workflow_id: workflowId, plan_id: planId, actual: status }
+      };
+    }
+    if (row.progress !== undefined && row.progress !== 0) {
+      return {
+        ok: false,
+        reason: "execution-started",
+        message: `plan ${planId} reports progress ${JSON.stringify(row.progress)} — the amendment must not rewrite executed work`,
+        details: { workflow_id: workflowId, plan_id: planId, actual: row.progress }
+      };
+    }
+    if (row.execution_lease !== undefined) {
+      return {
+        ok: false,
+        reason: "execution-started",
+        message: `plan ${planId} carries an execution lease — the plan has an owner and is no longer in Prepare`,
+        details: { workflow_id: workflowId, plan_id: planId, holder: isPlainObject2(row.execution_lease) ? row.execution_lease.holder : null }
+      };
+    }
+    if (row.coordination !== undefined) {
+      return {
+        ok: false,
+        reason: "execution-started",
+        message: `plan ${planId} carries a coordination block — preparation or execution evidence already exists for this row`,
+        details: { workflow_id: workflowId, plan_id: planId, revision: rowCoordinationOf(row)?.revision ?? null }
+      };
+    }
+  }
+  return { ok: true };
+}
+var PLAN_CONSULTED_HEADERS = {
+  plan_id: true,
+  "main worktree branch": true,
+  "working branch": true
+};
+function planHeadersOf(planPath, planId) {
+  const headers = new Map;
+  let marker;
+  let markerLength = 0;
+  for (const raw of readFileSync13(planPath, "utf8").split(/\r?\n/)) {
+    const line = raw.trim();
+    const fence = /^(`{3,}|~{3,})/.exec(line);
+    if (fence !== null) {
+      const run = fence[1];
+      if (marker === undefined) {
+        marker = run.charAt(0);
+        markerLength = run.length;
+      } else if (run.charAt(0) === marker && run.length >= markerLength) {
+        marker = undefined;
+      }
+      continue;
+    }
+    if (marker !== undefined)
+      continue;
+    const match = /^\*{0,2}([^:*]+?)\*{0,2}:\*{0,2}\s*(\S.*)$/.exec(line);
+    if (match === null)
+      continue;
+    const label = match[1].trim();
+    const key = label.toLowerCase();
+    if (PLAN_CONSULTED_HEADERS[key] !== true)
+      continue;
+    const value = match[2].trim();
+    const prior = headers.get(key);
+    if (prior !== undefined && prior !== value) {
+      throw prepareAmendmentRefusal("invalid-plan", `plan ${planId} markdown declares conflicting "${label}" headers (${prior} vs ${value})`, { plan_id: planId, header: label });
+    }
+    headers.set(key, value);
+  }
+  return headers;
+}
+function prepareReferencePath(harnessRoot, value, field, planId) {
+  if (!isNonEmptyString(value) || !isAbsolute12(value)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${planId} ${field} must be an absolute path — got ${JSON.stringify(value ?? null)}`, { plan_id: planId, field, actual: value ?? null });
+  }
+  const canonical = canonicalTarget(value);
+  if (!isWithin(canonicalizeNearestExisting(harnessRoot), canonical)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${planId} ${field} ${canonical} escapes the harness root ${harnessRoot}`, { plan_id: planId, field, path: canonical, expected: harnessRoot });
+  }
+  if (!existsSync15(canonical) || !statSync6(canonical).isFile()) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${planId} ${field} does not exist: ${canonical}`, {
+      plan_id: planId,
+      field,
+      path: canonical
+    });
+  }
+  return canonical;
+}
+function prepareReferenceList(harnessRoot, value, field, planId) {
+  if (!Array.isArray(value)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${planId} ${field} must be an array of absolute paths — got ${JSON.stringify(value ?? null)}`, { plan_id: planId, field, actual: value ?? null });
+  }
+  return value.map((entry, index) => prepareReferencePath(harnessRoot, entry, `${field}[${index}]`, planId));
+}
+function prepareMetadataString(metadata, key, planId) {
+  const value = metadata[key];
+  if (!isNonEmptyString(value)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${planId} metadata.${key} must be a non-empty string — got ${JSON.stringify(value ?? null)}`, { plan_id: planId, field: `metadata.${key}`, actual: value ?? null });
+  }
+  return value;
+}
+function readPlanAppend(value, context) {
+  if (!isPlainObject2(value)) {
+    throw prepareAmendmentRefusal("invalid-plan", "every appendPlans entry must be an object", { actual: value ?? null });
+  }
+  const unexpected = Object.keys(value).filter((key) => !PREPARE_APPEND_KEYS.includes(key));
+  if (unexpected.length > 0) {
+    throw prepareAmendmentRefusal("invalid-plan", `a plan append accepts only ${PREPARE_APPEND_KEYS.join(", ")} — unexpected key(s): ${unexpected.join(", ")}`, { allowed: [...PREPARE_APPEND_KEYS], unexpected });
+  }
+  const id = value.id;
+  if (!isNonEmptyString(id)) {
+    throw prepareAmendmentRefusal("invalid-plan", `a plan append requires a non-empty id — got ${JSON.stringify(id ?? null)}`, {
+      actual: id ?? null
+    });
+  }
+  try {
+    assertSafePathComponent(id, "plan id");
+  } catch (error) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan id ${JSON.stringify(id)} is not a safe path component: ${errorMessage(error)}`, {
+      plan_id: id
+    });
+  }
+  const title = value.title;
+  if (!isNonEmptyString(title)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} requires a non-empty title`, { plan_id: id, actual: title ?? null });
+  }
+  const declaredFile = value.file;
+  if (!isNonEmptyString(declaredFile) || !isAbsolute12(declaredFile)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} file must be the absolute plan path — got ${JSON.stringify(declaredFile ?? null)}`, { plan_id: id, actual: declaredFile ?? null });
+  }
+  const planPath = canonicalTarget(declaredFile);
+  const planDir = canonicalizeNearestExisting(resolvePlanDir(context.harnessRoot));
+  if (dirname12(planPath) !== planDir || basename12(planPath) !== `${id}.md`) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} file ${planPath} is not ${join20(planDir, `${id}.md`)}`, { plan_id: id, expected: join20(planDir, `${id}.md`), actual: planPath });
+  }
+  if (!existsSync15(planPath) || !statSync6(planPath).isFile()) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} markdown not found: ${planPath}`, { plan_id: id, path: planPath });
+  }
+  const headers = planHeadersOf(planPath, id);
+  const declaredPlanId = headers.get("plan_id");
+  if (declaredPlanId === undefined) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} markdown ${planPath} declares no plan_id header — the row cannot be traced to its reviewed plan`, { plan_id: id, path: planPath });
+  }
+  if (declaredPlanId !== id) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan append id ${id} does not match the plan markdown header plan_id ${declaredPlanId} (${planPath})`, { plan_id: id, expected: id, actual: declaredPlanId, path: planPath });
+  }
+  const metadata = value.metadata;
+  if (!isPlainObject2(metadata)) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} metadata must be an object`, { plan_id: id, actual: metadata ?? null });
+  }
+  const unexpectedMetadata = Object.keys(metadata).filter((key) => !PREPARE_APPEND_METADATA_KEYS.includes(key));
+  if (unexpectedMetadata.length > 0) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} metadata accepts only ${PREPARE_APPEND_METADATA_KEYS.join(", ")} — unexpected key(s): ${unexpectedMetadata.join(", ")}`, { plan_id: id, allowed: [...PREPARE_APPEND_METADATA_KEYS], unexpected: unexpectedMetadata });
+  }
+  const primarySpec = prepareReferencePath(context.harnessRoot, metadata.primary_spec, "metadata.primary_spec", id);
+  const specRefs = prepareReferenceList(context.harnessRoot, metadata.spec_refs, "metadata.spec_refs", id);
+  const iterationCompass = prepareReferencePath(context.harnessRoot, metadata.iteration_compass, "metadata.iteration_compass", id);
+  if (iterationCompass !== context.compass.path) {
+    throw prepareAmendmentRefusal("compass-mismatch", `plan ${id} metadata.iteration_compass ${iterationCompass} is not this workflow's reviewed compass ${context.compass.path}`, { plan_id: id, expected: context.compass.path, actual: iterationCompass });
+  }
+  const iterationRefs = prepareReferenceList(context.harnessRoot, metadata.iteration_refs, "metadata.iteration_refs", id);
+  const workingBranch = prepareMetadataString(metadata, "working_branch", id);
+  const specIntegrationBranch = prepareMetadataString(metadata, "spec_integration_branch", id);
+  const mergeTarget = prepareMetadataString(metadata, "merge_target", id);
+  const anchors = context.snapshot.branch ?? {};
+  for (const [label, branch] of [
+    ["branch.base", anchors.base],
+    ["branch.integration", anchors.integration],
+    ["branch.target", anchors.target]
+  ]) {
+    if (isNonEmptyString(branch) && branch === workingBranch) {
+      throw prepareAmendmentRefusal("invalid-plan", `plan ${id} metadata.working_branch ${workingBranch} is the workflow's ${label} — a plan row owns its own feature branch`, { plan_id: id, field: "metadata.working_branch", actual: workingBranch });
+    }
+  }
+  const declaredWorking = headers.get("working branch");
+  if (declaredWorking === undefined) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} markdown ${planPath} declares no Working branch header — the appended row's branch metadata cannot be verified against the reviewed plan`, { plan_id: id, field: "metadata.working_branch", path: planPath });
+  }
+  if (declaredWorking !== workingBranch) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} metadata.working_branch ${workingBranch} does not match the Working branch declared by ${planPath} (${declaredWorking})`, { plan_id: id, expected: declaredWorking, actual: workingBranch, path: planPath });
+  }
+  const declaredMain = headers.get("main worktree branch");
+  if (declaredMain === undefined) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} markdown ${planPath} declares no Main worktree branch header — the amendment cannot verify the branch the reviewed plan was written against`, { plan_id: id, field: "mainWorktreeBranch", path: planPath });
+  }
+  if (declaredMain !== context.mainWorktreeBranch) {
+    throw prepareAmendmentRefusal("invalid-plan", `plan ${id} metadata records main worktree branch ${context.mainWorktreeBranch}, but ${planPath} declares ${declaredMain}`, { plan_id: id, expected: declaredMain, actual: context.mainWorktreeBranch, path: planPath });
+  }
+  if (isNonEmptyString(anchors.integration)) {
+    for (const [field, recorded] of [
+      ["metadata.spec_integration_branch", specIntegrationBranch],
+      ["metadata.merge_target", mergeTarget]
+    ]) {
+      if (recorded !== anchors.integration) {
+        throw prepareAmendmentRefusal("invalid-plan", `plan ${id} ${field} ${recorded} is not the workflow's integration branch ${anchors.integration}`, { plan_id: id, expected: anchors.integration, actual: recorded });
+      }
+    }
+  }
+  if (context.compass.specIntegrationBranch !== undefined && specIntegrationBranch !== context.compass.specIntegrationBranch) {
+    throw prepareAmendmentRefusal("compass-mismatch", `plan ${id} metadata.spec_integration_branch ${specIntegrationBranch} is not the reviewed compass integration branch ${context.compass.specIntegrationBranch}`, { plan_id: id, expected: context.compass.specIntegrationBranch, actual: specIntegrationBranch });
+  }
+  const row = {
+    id,
+    title,
+    file: planPath,
+    status: "Todo",
+    owner: "project-manager",
+    progress: 0,
+    created_at: nowIso(),
+    metadata: {
+      primary_spec: primarySpec,
+      spec_refs: specRefs,
+      iteration_compass: iterationCompass,
+      iteration_refs: iterationRefs,
+      working_branch: workingBranch,
+      spec_integration_branch: specIntegrationBranch,
+      merge_target: mergeTarget
+    }
+  };
+  const gate2 = validatePlanRow(row);
+  if (!gate2.ok) {
+    throw prepareAmendmentRefusal("invalid-plan", `constructed row ${id} fails plan-row validation — ${summarize(gate2.violations)}`, {
+      plan_id: id,
+      violations: gate2.violations.map((entry) => entry.code)
+    });
+  }
+  return row;
+}
+function readIntegrationWorktreePath(value, context) {
+  const refuse = (message, details = {}) => {
+    throw prepareAmendmentRefusal("invalid-worktree", message, details);
+  };
+  if (!isNonEmptyString(value) || !isAbsolute12(value)) {
+    return refuse(`integrationWorktreePath must be an absolute path — got ${JSON.stringify(value ?? null)}`, {
+      actual: value ?? null
+    });
+  }
+  const path = canonicalTarget(value);
+  if (!existsSync15(path) || !statSync6(path).isDirectory()) {
+    return refuse(`integration checkout ${path} does not exist`, { path, expected: value });
+  }
+  const mainRoot = canonicalTarget(context.main.root);
+  const control = canonicalizeNearestExisting(context.harnessRoot);
+  const controlRepo = readMainWorktree(control);
+  if (controlRepo === null) {
+    return refuse(`the control harness root ${control} has no readable Git main worktree — the integration checkout cannot be proven to be a checkout of this repository`, { path, harness_root: control });
+  }
+  const controlMainRoot = canonicalTarget(controlRepo.root);
+  if (controlMainRoot !== mainRoot) {
+    return refuse(`this call runs from the main worktree of ${mainRoot}, not the repository owning the control harness root ${control} (${controlMainRoot}) — the recorded checkout must belong to that repository`, { path, expected: controlMainRoot, actual: mainRoot });
+  }
+  if (path === mainRoot || path === control) {
+    return refuse(`integration checkout ${path} is the main/control checkout — a dedicated integration worktree is required`, {
+      path,
+      expected: `a checkout distinct from ${mainRoot}`
+    });
+  }
+  const repo = readMainWorktree(path);
+  if (repo === null || canonicalTarget(repo.root) !== controlMainRoot) {
+    return refuse(`integration checkout ${path} is not a checkout of the repository owning the control harness root ${control} (${controlMainRoot})`, {
+      path,
+      expected: controlMainRoot,
+      actual: repo === null ? null : canonicalTarget(repo.root)
+    });
+  }
+  if (!isDistinctCheckout(context.main.root, path)) {
+    return refuse(`integration checkout ${path} is not a distinct checkout (same Git checkout as ${mainRoot})`, {
+      path,
+      expected: `a checkout distinct from ${mainRoot}`
+    });
+  }
+  const integrationBranch = context.snapshot.branch?.integration;
+  if (!isNonEmptyString(integrationBranch)) {
+    return refuse(`workflow ${context.snapshot.id} records no branch.integration — the integration checkout cannot be verified`, { workflow_id: context.snapshot.id, path });
+  }
+  const branch = gitRead(path, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (branch !== integrationBranch) {
+    return refuse(`integration checkout ${path} is on ${branch === undefined ? "an unreadable checkout" : branch || "a detached HEAD"}, not the recorded ${integrationBranch}`, { path, expected: integrationBranch, actual: branch ?? null });
+  }
+  return path;
+}
+function samePlanIdSet(left, right) {
+  const leftSet = new Set(left);
+  const rightSet = new Set(right);
+  if (leftSet.size !== rightSet.size)
+    return false;
+  for (const id of leftSet)
+    if (!rightSet.has(id))
+      return false;
+  return true;
+}
+function readPreparePatch(patch, context) {
+  if (!isPlainObject2(patch)) {
+    throw prepareAmendmentRefusal("invalid-patch", "the amendment patch must be an object", { actual: patch ?? null });
+  }
+  const unexpected = Object.keys(patch).filter((key) => !PREPARE_PATCH_KEYS.includes(key));
+  if (unexpected.length > 0) {
+    throw prepareAmendmentRefusal("invalid-patch", `the amendment patch accepts only ${PREPARE_PATCH_KEYS.join(", ")} — unexpected key(s): ${unexpected.join(", ")}`, { allowed: [...PREPARE_PATCH_KEYS], unexpected });
+  }
+  const mainWorktreeBranch = patch.mainWorktreeBranch;
+  if (!isNonEmptyString(mainWorktreeBranch)) {
+    throw prepareAmendmentRefusal("invalid-patch", `the amendment patch requires mainWorktreeBranch as a non-empty string — got ${JSON.stringify(mainWorktreeBranch ?? null)}`, { actual: mainWorktreeBranch ?? null });
+  }
+  if (context.main.branch !== mainWorktreeBranch) {
+    throw new CoordinationError("coordination.scope-mismatch", `the main worktree ${context.main.root} is on ${context.main.branch === "" ? "a detached HEAD" : context.main.branch}, but this amendment declares ${mainWorktreeBranch}`, { expected: mainWorktreeBranch, actual: context.main.branch });
+  }
+  const rawAppends = patch.appendPlans;
+  if (!Array.isArray(rawAppends)) {
+    throw prepareAmendmentRefusal("invalid-patch", "the amendment patch requires appendPlans as an array", {
+      actual: rawAppends ?? null
+    });
+  }
+  const requestedParallelism = patch.planParallelism;
+  if (requestedParallelism !== undefined && !(isNonEmptyString(requestedParallelism) && PLAN_PARALLELISM_VALUES.includes(requestedParallelism))) {
+    throw prepareAmendmentRefusal("invalid-patch", `planParallelism must be one of ${PLAN_PARALLELISM_VALUES.join(" | ")} — got ${JSON.stringify(requestedParallelism ?? null)}`, { allowed: [...PLAN_PARALLELISM_VALUES], actual: requestedParallelism ?? null });
+  }
+  const planParallelism = isNonEmptyString(requestedParallelism) ? requestedParallelism : undefined;
+  const existingIds = new Set(context.snapshot.plans.flatMap((row) => rowPlanIds(row)));
+  const declaredIds = new Set;
+  for (const entry of rawAppends) {
+    const id = isPlainObject2(entry) ? entry.id : undefined;
+    if (!isNonEmptyString(id))
+      continue;
+    if (existingIds.has(id)) {
+      throw prepareAmendmentRefusal("duplicate-plan", `plan ${id} is already a row of workflow ${context.snapshot.id} — the amendment appends new rows and never replaces existing ones`, { plan_id: id, workflow_id: context.snapshot.id });
+    }
+    if (declaredIds.has(id)) {
+      throw prepareAmendmentRefusal("duplicate-plan", `plan ${id} appears twice in one patch`, { plan_id: id });
+    }
+    declaredIds.add(id);
+  }
+  const rows = rawAppends.map((entry) => readPlanAppend(entry, {
+    harnessRoot: context.harnessRoot,
+    snapshot: context.snapshot,
+    compass: context.compass,
+    mainWorktreeBranch
+  }));
+  const integrationWorktreePath = patch.integrationWorktreePath === undefined ? undefined : readIntegrationWorktreePath(patch.integrationWorktreePath, context);
+  const recordedPath = isNonEmptyString(context.snapshot.integration_worktree_path) ? canonicalTarget(context.snapshot.integration_worktree_path) : undefined;
+  const recordedParallelism = isPlainObject2(context.snapshot.execution_policy) ? context.snapshot.execution_policy.plan_parallelism : undefined;
+  const changesPath = integrationWorktreePath !== undefined && integrationWorktreePath !== recordedPath;
+  const changesPolicy = planParallelism !== undefined && planParallelism !== recordedParallelism;
+  if (rows.length === 0 && !changesPath && !changesPolicy) {
+    throw prepareAmendmentRefusal("invalid-patch", `the patch changes nothing on workflow ${context.snapshot.id} — it appends no plan, records no new integration checkout and no different plan parallelism`, { workflow_id: context.snapshot.id });
+  }
+  if (context.compass.specIntegrationBranch !== undefined) {
+    const recordedBranch = context.snapshot.branch?.integration;
+    if (!isNonEmptyString(recordedBranch) || recordedBranch !== context.compass.specIntegrationBranch) {
+      throw prepareAmendmentRefusal("compass-mismatch", `workflow ${context.snapshot.id} records integration branch ${JSON.stringify(recordedBranch ?? null)}, but the reviewed compass ${context.compass.path} declares ${context.compass.specIntegrationBranch}`, { expected: context.compass.specIntegrationBranch, actual: recordedBranch ?? null });
+    }
+  }
+  if (context.compass.integrationWorktreePath !== undefined) {
+    const declaredPath = canonicalTarget(context.compass.integrationWorktreePath);
+    const effectivePath = integrationWorktreePath ?? recordedPath;
+    if (effectivePath !== declaredPath) {
+      throw prepareAmendmentRefusal("compass-mismatch", `workflow ${context.snapshot.id} would record integration checkout ${effectivePath ?? "(none)"}, but the reviewed compass ${context.compass.path} declares ${declaredPath}`, { path: effectivePath ?? null, expected: declaredPath, actual: effectivePath ?? null });
+    }
+  }
+  const proposedIds = [
+    ...context.snapshot.plans.flatMap((row) => rowPlanIds(row)),
+    ...rows.map((row) => rowPlanIds(row)[0] ?? "")
+  ];
+  if (!samePlanIdSet(context.compass.planIds, proposedIds)) {
+    const missing = context.compass.planIds.filter((id) => !proposedIds.includes(id));
+    const undeclared = proposedIds.filter((id) => !context.compass.planIds.includes(id));
+    throw prepareAmendmentRefusal("compass-mismatch", `the amended workflow's plan ids must match the reviewed compass ${context.compass.path} exactly — missing: ${missing.join(", ") || "(none)"}; not declared by the compass: ${undeclared.join(", ") || "(none)"}`, { expected: [...context.compass.planIds], actual: proposedIds, missing, undeclared });
+  }
+  return {
+    rows,
+    ...integrationWorktreePath !== undefined ? { integrationWorktreePath } : {},
+    ...planParallelism !== undefined ? { planParallelism } : {}
+  };
+}
+function prepareVersionToken(value, field) {
+  if (!isNonEmptyString(value)) {
+    throw invalidInput(`prepare amendment ${field} is required — read it from \`show-prepare\``, { field });
+  }
+  const bare = value.startsWith("sha256:") ? value.slice("sha256:".length) : value;
+  if (!/^[0-9a-f]{64}$/.test(bare)) {
+    throw invalidInput(`prepare amendment ${field} must be a raw-byte sha256 version ("sha256:<64 hex>" or "<64 hex>") — got ${JSON.stringify(value)}`, { field });
+  }
+  return value;
+}
+function prepareVersionDigest(token) {
+  return token.startsWith("sha256:") ? token.slice("sha256:".length) : token;
+}
+async function showPrepareWorkflow(input) {
+  assertExactKeys(input, ["sessionPath", "cwd"], "prepare workflow read");
+  const cwd = input.cwd ?? process.cwd();
+  const scope = prepareWorkflowScope(input.sessionPath, cwd);
+  const { snapshot, version } = readPrepareSnapshot(scope.snapshotPath);
+  assertCoordinatorBinding(scope.session, scope.sessionPath, snapshot);
+  const compass = readPrepareCompass(scope.harnessRoot, snapshot);
+  const admission = prepareAdmission(scope.harnessRoot, scope.workflowId, snapshot);
+  return {
+    ok: true,
+    operation: "show-prepare",
+    session: scope.session,
+    session_file: scope.sessionPath,
+    view: {
+      workflowId: scope.workflowId,
+      snapshotVersion: version,
+      compassVersion: compass.version,
+      planIds: snapshot.plans.map((row) => rowPlanIds(row)[0] ?? ""),
+      allowed: admission.ok,
+      blockers: admission.ok ? [] : [`${admission.reason}: ${admission.message}`]
+    }
+  };
+}
+async function amendPrepareWorkflow(input) {
+  assertExactKeys(input, ["sessionPath", "cwd", "expectedSnapshotVersion", "expectedCompassVersion", "patch"], "prepare amendment input");
+  const cwd = input.cwd ?? process.cwd();
+  const expectedSnapshotVersion = prepareVersionToken(input.expectedSnapshotVersion, "expectedSnapshotVersion");
+  const expectedCompassVersion = prepareVersionToken(input.expectedCompassVersion, "expectedCompassVersion");
+  const scope = prepareWorkflowScope(input.sessionPath, cwd);
+  const committed = await withStatusWriteLock(scope.snapshotPath, async () => {
+    const { snapshot, version } = readPrepareSnapshot(scope.snapshotPath);
+    assertCoordinatorBinding(scope.session, scope.sessionPath, snapshot);
+    const main = assertCoordinatorResidency(cwd, snapshot);
+    if (prepareVersionDigest(version) !== prepareVersionDigest(expectedSnapshotVersion)) {
+      throw prepareAmendmentRefusal("stale", `snapshot ${scope.snapshotPath} is at ${version}, this call expected ${expectedSnapshotVersion} — re-read \`workflow show-prepare\` and review again`, { path: scope.snapshotPath, expected: expectedSnapshotVersion, actual: version });
+    }
+    const compass = readPrepareCompass(scope.harnessRoot, snapshot);
+    if (prepareVersionDigest(compass.version) !== prepareVersionDigest(expectedCompassVersion)) {
+      throw prepareAmendmentRefusal("stale", `compass ${compass.path} is at ${compass.version}, this call expected ${expectedCompassVersion} — re-read \`workflow show-prepare\` and review again`, { path: compass.path, expected: expectedCompassVersion, actual: compass.version });
+    }
+    const admission = prepareAdmission(scope.harnessRoot, scope.workflowId, snapshot);
+    if (!admission.ok)
+      throw prepareAmendmentRefusal(admission.reason, admission.message, admission.details);
+    const proposal = readPreparePatch(input.patch, { harnessRoot: scope.harnessRoot, snapshot, compass, main });
+    const executionPolicy = { ...snapshot.execution_policy ?? {} };
+    if (proposal.planParallelism !== undefined)
+      executionPolicy.plan_parallelism = proposal.planParallelism;
+    const next = {
+      ...snapshot,
+      updated_at: nowIso(),
+      plans: [...snapshot.plans, ...proposal.rows],
+      ...proposal.integrationWorktreePath !== undefined ? { integration_worktree_path: proposal.integrationWorktreePath } : {},
+      ...proposal.planParallelism !== undefined ? { execution_policy: executionPolicy } : {}
+    };
+    const rechecked = readPrepareCompass(scope.harnessRoot, snapshot);
+    if (prepareVersionDigest(rechecked.version) !== prepareVersionDigest(compass.version)) {
+      throw prepareAmendmentRefusal("stale", `compass ${compass.path} changed while this amendment was being applied (${compass.version} → ${rechecked.version}) — re-read \`workflow show-prepare\` and review again`, { path: compass.path, expected: compass.version, actual: rechecked.version });
+    }
+    await commitSnapshot(scope.harnessRoot, scope.workflowId, scope.snapshotPath, next);
+    const written = readArtifactBytes(scope.snapshotPath);
+    if (written === undefined) {
+      throw new CoordinationError("coordination.store", `snapshot ${scope.snapshotPath} is unreadable after this call committed it`, { path: scope.snapshotPath });
+    }
+    return {
+      planIds: next.plans.map((row) => rowPlanIds(row)[0] ?? ""),
+      compassVersion: compass.version,
+      snapshotVersion: written.version
+    };
+  });
+  return {
+    ok: true,
+    operation: "amend-prepare",
+    session: scope.session,
+    session_file: scope.sessionPath,
+    outcome: "amended",
+    view: {
+      workflowId: scope.workflowId,
+      snapshotVersion: committed.snapshotVersion,
+      compassVersion: committed.compassVersion,
+      planIds: committed.planIds,
+      allowed: true,
+      blockers: []
+    }
+  };
+}
 export {
   ARCHIVED_STATUS_V1_FILE,
   AUDIT_CATEGORIES,
@@ -11805,12 +12934,15 @@ export {
   SEVERITY_ORDER,
   SHARED_FAMILIES,
   SddScriptError,
+  WORKFLOW_COMPOUND_OUTCOMES,
+  WORKFLOW_DELIVERY_KINDS,
   WORKFLOW_LIFECYCLE_STATUSES,
   WORKFLOW_LIFECYCLE_TYPES,
   WORKFLOW_SNAPSHOT_FILE,
   WORKFLOW_TERMINAL_STATUSES,
   WorkflowSnapshotValidationError,
   _DEFAULT_PROJECT,
+  amendPrepareWorkflow,
   antiRecursionPrecheck,
   appendProjectRegisterEntries,
   applyEnforcement,
@@ -11819,6 +12951,7 @@ export {
   assertBranchAlignment,
   assertControlVsFeaturePath,
   assertDefaultBranchProtected,
+  assertDeliveryRegistrationCoherence,
   assertFsStorePath,
   assertIndexRowObligations,
   assertIndexRows,
@@ -11843,7 +12976,9 @@ export {
   composeDispatchGate,
   compoundRefreshScope,
   computePrTally,
+  consultDeliveryEvidence,
   createFsStore,
+  declareWorkflowDeliveryKind,
   detectHarnessKind,
   detectHost,
   emitGitignoreSnippet,
@@ -11905,7 +13040,9 @@ export {
   readProgressLedger,
   readSessionEnvelope,
   readWorkflowSnapshot,
+  recordWorkflowDelivery,
   referenceExists,
+  registerPlanWorkflow,
   registerWorkflow,
   releaseLease,
   replaceCoordinatedArtifact,
@@ -11939,6 +13076,7 @@ export {
   scopeGuard,
   sddWorkspace,
   setArtifactStore,
+  showPrepareWorkflow,
   singleReviewSnapshot,
   stripFrontmatter,
   supplyChainChecks,