mancode 0.6.2 → 0.6.3

package/dist/cli.js

@@ -10,6 +10,7 @@ import {
   assertExecutableImplementationScope,
   assertHandoffTransition,
   assertKnownKeys,
+  assertManDeliveryVerificationSurfaces,
   assertOperationJournalTransition,
   assertOperationReservationTopology,
   assertParentWorkflowRelation,
@@ -71,6 +72,8 @@ import {
   parseClaim,
   parseFreshness,
   parseHandoff,
+  parseManReviewEvidence,
+  parseManVerificationSurface,
   parseOperationJournal,
   parseOperationReservation,
   parseProjectConfig,
@@ -114,8 +117,9 @@ import {
   workflowMetadataDigest,
   writeOperationReservation,
   writeProjectFacts
-} from "./chunk-44UHUCE6.js";
+} from "./chunk-NG72XZ3R.js";
 import {
+  ACCEPTED_STATE_NARRATIVE_GUIDANCE,
   DEFAULT_MANCODE_END_MARKER,
   DEFAULT_MANCODE_START_MARKER,
   INTERFACE_EMOJI_ICON_GUIDANCE,
@@ -128,6 +132,7 @@ import {
   assertV3AdapterInstallable,
   assertV3AdapterTargetSafe,
   hasManagedBlock,
+  inspectUnsafeV3AdapterPaths,
   inspectV3Adapter,
   inspectV3AdapterVersions,
   planV3AdapterFiles,
@@ -135,11 +140,13 @@ import {
   removeManagedBlock,
   removeV3Adapter,
   replaceManagedBlock,
+  replaceUnsafeV3AdapterSymlinks,
   stageV3Adapter,
   stageV3AdapterUpgradeFiles,
   v3AdapterTargetPath,
-  v3AdapterVersionsFromStatuses
-} from "./chunk-GCLUIY65.js";
+  v3AdapterVersionsFromStatuses,
+  writeThroughResolvedPath
+} from "./chunk-RDPFQODS.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";
@@ -383,6 +390,14 @@ var V3_AUTHORITY_PATHS = [
   "local",
   "runtime"
 ];
+var LOCAL_CONTINUITY_PATHS = [
+  "sessions",
+  "workflows",
+  "cache",
+  "quarantine",
+  "publish",
+  "runtime"
+];
 async function scanLegacyAuthority(projectRoot) {
   const root = path.resolve(projectRoot, ".mancode");
   const entries = await Promise.all(
@@ -402,9 +417,10 @@ async function scanLegacyAuthority(projectRoot) {
 async function inspectMancodeLayout(projectRoot) {
   const root = path.resolve(projectRoot);
   const mancodeRoot = path.join(root, ".mancode");
-  const [legacy, target] = await Promise.all([
+  const [legacy, target, entries] = await Promise.all([
     scanLegacyAuthority(root),
-    lstatOrNull(mancodeRoot)
+    lstatOrNull(mancodeRoot),
+    targetEntries(mancodeRoot)
   ]);
   const v3AuthorityPathsPresent = (await Promise.all(
     V3_AUTHORITY_PATHS.map(
@@ -413,10 +429,16 @@ async function inspectMancodeLayout(projectRoot) {
   )).filter(
     (value) => value !== null
   );
+  const blockingV3AuthorityPresent = v3AuthorityPathsPresent.some(
+    (relativePath2) => relativePath2 !== "local"
+  );
+  const v3ScratchOnly = target?.isDirectory() === true && !blockingV3AuthorityPresent && !await localHasContinuityContent(mancodeRoot);
   return {
     legacy,
     v3TargetExists: target !== null,
-    v3AuthorityPathsPresent
+    v3AuthorityPathsPresent,
+    v3ScratchOnly,
+    v3TargetEntries: entries
   };
 }
 async function assertGreenfieldInitializationPreflight(projectRoot) {
@@ -525,6 +547,23 @@ async function lstatOrNull(target) {
     throw error;
   }
 }
+async function targetEntries(root) {
+  const stat5 = await lstatOrNull(root);
+  if (stat5 === null || !stat5.isDirectory()) return [];
+  const names = await readdir(root);
+  names.sort(compareUtf8);
+  return names;
+}
+async function localHasContinuityContent(root) {
+  const localPath = path.join(root, "local");
+  const stat5 = await lstatOrNull(localPath);
+  if (stat5 === null) return false;
+  if (!stat5.isDirectory()) return true;
+  const names = await readdir(localPath);
+  return names.some(
+    (name) => LOCAL_CONTINUITY_PATHS.includes(name)
+  );
+}
 function sha256(value) {
   return `sha256:${createHash("sha256").update(value).digest("hex")}`;
 }
@@ -2697,6 +2736,13 @@ function operationRecoveryPayloadPath(store, operationId) {
   assertUlid(operationId, "operation recovery payload operationId");
   return path3.join(operationRecoveryDirectory(store), `${operationId}.json`);
 }
+function operationRecoveryPayloadVersionPath(store, operationId, payloadDigest) {
+  assertUlid(operationId, "operation recovery payload operationId");
+  return path3.join(
+    operationRecoveryDirectory(store),
+    `${operationId}.${payloadDigestToken(payloadDigest)}.json`
+  );
+}
 async function writeOperationRecoveryPayload(store, value) {
   const payload = parseOperationRecoveryPayload(value);
   if (payload.primaryStoreId !== store.storeId) {
@@ -2725,12 +2771,51 @@ async function writeOperationRecoveryPayload(store, value) {
     throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_CONFLICT");
   }
 }
+async function writeOperationRecoveryPayloadVersion(store, value) {
+  const payload = parseOperationRecoveryPayload(value);
+  if (payload.primaryStoreId !== store.storeId) {
+    throw new Error(
+      "operation recovery payload primaryStoreId does not match its home store"
+    );
+  }
+  const digest = operationRecoveryPayloadDigest(payload);
+  const directory = operationRecoveryDirectory(store);
+  const target = operationRecoveryPayloadVersionPath(
+    store,
+    payload.operationId,
+    digest
+  );
+  await mkdir2(directory, { recursive: true });
+  try {
+    await writeFile2(target, serialize(payload), {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    return payload;
+  } catch (error) {
+    if (!isAlreadyExists2(error)) throw error;
+    const existing = await readOperationRecoveryPayloadAtPath(target);
+    if (existing !== null && operationRecoveryPayloadDigest(existing) === digest) {
+      return existing;
+    }
+    throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_CONFLICT");
+  }
+}
 async function readOperationRecoveryPayload(store, operationId) {
+  return readOperationRecoveryPayloadAtPath(
+    operationRecoveryPayloadPath(store, operationId)
+  );
+}
+async function readOperationRecoveryPayloadForDigest(store, operationId, payloadDigest) {
+  const versioned = await readOperationRecoveryPayloadAtPath(
+    operationRecoveryPayloadVersionPath(store, operationId, payloadDigest)
+  );
+  if (versioned !== null) return versioned;
+  return readOperationRecoveryPayload(store, operationId);
+}
+async function readOperationRecoveryPayloadAtPath(target) {
   try {
-    const raw = await readFile3(
-      operationRecoveryPayloadPath(store, operationId),
-      "utf8"
-    );
+    const raw = await readFile3(target, "utf8");
     return parseOperationRecoveryPayload(JSON.parse(raw));
   } catch (error) {
     if (isNotFound3(error)) return null;
@@ -2740,6 +2825,13 @@ async function readOperationRecoveryPayload(store, operationId) {
     throw error;
   }
 }
+function payloadDigestToken(payloadDigest) {
+  const match = /^sha256:([a-f0-9]{64})$/.exec(payloadDigest);
+  if (match?.[1] === void 0) {
+    throw new Error("operation recovery payload digest is invalid");
+  }
+  return match[1];
+}
 function serialize(payload) {
   return `${JSON.stringify(payload, null, 2)}
 `;
@@ -5420,6 +5512,30 @@ async function writeTaskCheckpointAtRoot(taskRoot2, value) {
     throw new Error("MANCODE_CHECKPOINT_ID_CONFLICT");
   }
 }
+async function assertTaskCheckpointIdAvailableAtRoot(taskRoot2, checkpointId) {
+  assertUlid(checkpointId, "checkpointId");
+  await assertSafeTaskDirectory(taskRoot2);
+  const directory = path11.join(taskRoot2, "checkpoints");
+  try {
+    const entry = await lstat4(directory);
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  } catch (error) {
+    if (isNotFound11(error)) return;
+    throw error;
+  }
+  try {
+    const entry = await lstat4(path11.join(directory, `${checkpointId}.json`));
+    if (!entry.isFile() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  } catch (error) {
+    if (isNotFound11(error)) return;
+    throw error;
+  }
+  throw new Error("MANCODE_CHECKPOINT_ID_CONFLICT");
+}
 async function readTaskCheckpointAtRoot(taskRoot2, checkpointId) {
   assertUlid(checkpointId, "checkpointId");
   await assertSafeTaskDirectory(taskRoot2);
@@ -5434,9 +5550,13 @@ async function readTaskCheckpointAtRoot(taskRoot2, checkpointId) {
     throw error;
   }
   try {
-    return await readImmutableCheckpoint(
+    const checkpoint = await readImmutableCheckpoint(
       path11.join(directory, `${checkpointId}.json`)
     );
+    if (checkpoint.checkpointId !== checkpointId) {
+      throw new Error("MANCODE_CHECKPOINT_CORRUPT");
+    }
+    return checkpoint;
   } catch (error) {
     if (error instanceof Error && error.message === "MANCODE_CHECKPOINT_ID_CONFLICT") {
       return null;
@@ -5607,6 +5727,16 @@ import path12 from "path";
 var REQUIREMENTS_FILE = "requirements.json";
 var REQUIREMENTS_MARKDOWN_FILE = "requirements.md";
 var ACCEPTANCE_ID_PATTERN = /^AC-[A-Z0-9][A-Z0-9-]{0,27}$/;
+var VERIFICATION_SURFACES = /* @__PURE__ */ new Set([
+  "unit",
+  "component",
+  "handler",
+  "real_http",
+  "browser",
+  "device",
+  "external_service",
+  "manual_observation"
+]);
 var REQUIREMENT_DIMENSIONS = [
   "platform",
   "core_scope",
@@ -5692,11 +5822,16 @@ function parseRequirementsLedger2(raw, options = {}) {
       throw new Error(`duplicate acceptance criterion: ${item.id}`);
     }
     ids.add(item.id);
+    const verificationSurfaces = parseVerificationSurfaces(
+      item.verificationSurfaces,
+      item.method
+    );
     return {
       id: item.id,
       description: item.description.trim(),
       required: item.required,
-      method: item.method
+      method: item.method,
+      ...verificationSurfaces === void 0 ? {} : { verificationSurfaces }
     };
   });
   if (!options.allowIncomplete && !acceptanceCriteria.some((item) => item.required)) {
@@ -5757,9 +5892,10 @@ function renderRequirementsMarkdown(ledger) {
 
 ${items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : "- \u65E0"}
 `;
-  const criteria = ledger.acceptanceCriteria.map(
-    (item) => `- **${item.id}** [${item.required ? "\u5FC5\u9700" : "\u53EF\u9009"} / ${item.method}] ${item.description}`
-  ).join("\n");
+  const criteria = ledger.acceptanceCriteria.map((item) => {
+    const surfaces = item.verificationSurfaces ? ` / ${Object.entries(item.verificationSurfaces).map(([slot, surface]) => `${slot}=${surface}`).join(", ")}` : "";
+    return `- **${item.id}** [${item.required ? "\u5FC5\u9700" : "\u53EF\u9009"} / ${item.method}${surfaces}] ${item.description}`;
+  }).join("\n");
   const coverage = ledger.coverage.map((item) => `- **${item.dimension}** [${item.status}] ${item.rationale}`).join("\n");
   return `# Requirements
 
@@ -5800,6 +5936,32 @@ function isNonEmptyStringArray(value) {
 function isVerificationMethod(value) {
   return value === "automated" || value === "manual" || value === "hybrid";
 }
+function parseVerificationSurfaces(value, method) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value))
+    throw new Error("invalid acceptance verificationSurfaces");
+  const unknown = Object.keys(value).filter(
+    (key) => key !== "automated" && key !== "manual"
+  );
+  if (unknown.length)
+    throw new Error("invalid acceptance verificationSurfaces");
+  const automated = parseVerificationSurface(value.automated);
+  const manual = parseVerificationSurface(value.manual);
+  if (method === "automated" && (automated === void 0 || manual !== void 0) || method === "manual" && (automated !== void 0 || manual === void 0) || method === "hybrid" && (automated === void 0 || manual === void 0)) {
+    throw new Error("invalid acceptance verificationSurfaces");
+  }
+  return {
+    ...automated === void 0 ? {} : { automated },
+    ...manual === void 0 ? {} : { manual }
+  };
+}
+function parseVerificationSurface(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !VERIFICATION_SURFACES.has(value)) {
+    throw new Error("invalid acceptance verification surface");
+  }
+  return value;
+}
 function isRequirementDimension(value) {
   return REQUIREMENT_DIMENSIONS.some((dimension) => dimension === value);
 }
@@ -9677,7 +9839,7 @@ async function activateLegacyMigration(input) {
     if (session === null || session.status !== "active") {
       throw new Error("MANCODE_SESSION_NOT_FOUND");
     }
-    const store = new (await import("./store-TQFQCAAF.js")).V3ContextStore(root);
+    const store = new (await import("./store-C3G3HN3N.js")).V3ContextStore(root);
     const project = await store.readProjectSnapshot();
     const stage = await readMigrationStage(root, input.stageId);
     if (stage.state !== "staged" || stage.revision !== input.expectedStageRevision) {
@@ -9940,7 +10102,7 @@ async function activateLegacyMigration(input) {
       for (const action of payload.actions.filter(
         (action2) => action2.kind === "v3_adapter_file"
       )) {
-        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-ZLYZAA4P.js");
+        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-7KIOYYWS.js");
         await applyV3AdapterFilePlan2(root, action);
       }
       journal = await completeActivationStep(
@@ -12906,8 +13068,17 @@ async function executeOperationRecovery(input) {
   assertUlid(input.operationId, "operation recovery operationId");
   assertUlid(input.actorId, "operation recovery actorId");
   assertUlid(input.sessionId, "operation recovery sessionId");
+  if (input.replacementCheckpointId !== void 0) {
+    assertUlid(
+      input.replacementCheckpointId,
+      "operation recovery replacementCheckpointId"
+    );
+  }
   const now = input.now ?? /* @__PURE__ */ new Date();
   const mode = input.mode ?? "repair";
+  if (mode === "abort" && input.replacementCheckpointId !== void 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
+  }
   const stores = await knownOperationStores(input.projectRoot);
   const located = await locateJournal(stores, input.operationId);
   if (located === null) throw new Error("MANCODE_OPERATION_JOURNAL_NOT_FOUND");
@@ -12921,23 +13092,30 @@ async function executeOperationRecovery(input) {
   });
   assertRecoveryActor(initialPlan, input.actorId, input.sessionId);
   if (located.journal.state === "committed" || located.journal.state === "aborted") {
+    await assertTerminalCheckpointReplacementRetry(
+      located.store,
+      located.journal,
+      input.replacementCheckpointId
+    );
     return {
       state: "already_terminal",
       journal: located.journal,
       reason: "terminal"
     };
   }
+  assertCheckpointReplacementSupported(
+    located.journal,
+    input.replacementCheckpointId
+  );
   const locks = await acquireRecoveryOperationLocks(
     located.store,
     located.journal,
     stores,
-    now
+    now,
+    input.replacementCheckpointId === void 0 ? [] : [`checkpoint:${input.replacementCheckpointId}`]
   );
   try {
-    const journal = await readOperationJournal(
-      located.store,
-      input.operationId
-    );
+    let journal = await readOperationJournal(located.store, input.operationId);
     if (journal === null)
       throw new Error("MANCODE_OPERATION_JOURNAL_NOT_FOUND");
     const plan = planOperationRecovery({
@@ -12946,9 +13124,18 @@ async function executeOperationRecovery(input) {
     });
     assertRecoveryActor(plan, input.actorId, input.sessionId);
     if (journal.state === "committed" || journal.state === "aborted") {
+      await assertTerminalCheckpointReplacementRetry(
+        located.store,
+        journal,
+        input.replacementCheckpointId
+      );
       return { state: "already_terminal", journal, reason: "terminal" };
     }
-    const payload = await loadBoundPayload(located.store, journal);
+    assertCheckpointReplacementSupported(
+      journal,
+      input.replacementCheckpointId
+    );
+    let payload = await loadBoundPayload(located.store, journal);
     if (payload === null) {
       if (plan.action === "safe_abort") {
         const aborted = await abortOperation(
@@ -12971,6 +13158,28 @@ async function executeOperationRecovery(input) {
         reason: "MANCODE_OPERATION_RECOVERY_PAYLOAD_REQUIRED"
       };
     }
+    if (input.replacementCheckpointId === void 0 && payload.type === "reframe" && await reframeCheckpointReplacementProvenance(
+      located.store,
+      journal,
+      payload
+    ) !== null) {
+      throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_REQUIRED");
+    }
+    let checkpointReplacement;
+    if (input.replacementCheckpointId !== void 0) {
+      const amended = await replaceReframeRecoveryCheckpoint({
+        projectRoot: input.projectRoot,
+        primaryStore: located.store,
+        stores,
+        journal,
+        payload,
+        replacementCheckpointId: input.replacementCheckpointId,
+        now
+      });
+      journal = amended.journal;
+      payload = amended.payload;
+      checkpointReplacement = amended.checkpointReplacement;
+    }
     assertOperationRecoveryPayloadCoversJournal(journal, payload);
     try {
       await removePrivateWorkflowStaging(input.projectRoot, journal, payload);
@@ -12992,6 +13201,7 @@ async function executeOperationRecovery(input) {
     }
     if (mode === "abort") throw new Error("MANCODE_OPERATION_ABORT_UNSAFE");
     try {
+      await assertReframeRecoveryPlanCurrent(input.projectRoot, payload);
       const repaired = await applyPayload(
         input.projectRoot,
         located.store,
@@ -13010,14 +13220,16 @@ async function executeOperationRecovery(input) {
       return {
         state: "repaired",
         journal: repaired,
-        reason: "forward_repair"
+        reason: "forward_repair",
+        ...checkpointReplacement === void 0 ? {} : { checkpointReplacement }
       };
     } catch (error) {
       const blocked = await markRepairRequired(located.store, journal, now);
       return {
         state: "repair_required",
         journal: blocked,
-        reason: error instanceof Error && error.message === "MANCODE_OPERATION_RECOVERY_CONFLICT" ? "MANCODE_OPERATION_RECOVERY_CONFLICT" : "MANCODE_OPERATION_RECOVERY_FAILED"
+        reason: error instanceof Error && error.message === "MANCODE_OPERATION_RECOVERY_CONFLICT" ? "MANCODE_OPERATION_RECOVERY_CONFLICT" : "MANCODE_OPERATION_RECOVERY_FAILED",
+        ...checkpointReplacement === void 0 ? {} : { checkpointReplacement }
       };
     }
   } finally {
@@ -13055,7 +13267,7 @@ async function readReservations(journal, stores) {
     })
   ).then((values) => values.filter((value) => value !== null));
 }
-async function acquireRecoveryOperationLocks(primaryStore, journal, stores, now) {
+async function acquireRecoveryOperationLocks(primaryStore, journal, stores, now, extraPrimaryEntityLocks = []) {
   const byId = new Map(stores.map((store) => [store.storeId, store]));
   const secondaryTargets = journal.secondaryReservations.map((reservation) => {
     const store = byId.get(reservation.storeId);
@@ -13067,7 +13279,12 @@ async function acquireRecoveryOperationLocks(primaryStore, journal, stores, now)
   return acquireOperationEntityLocks(
     journal.operationId,
     [
-      { store: primaryStore, entityLockKeys: journal.entityLocks },
+      {
+        store: primaryStore,
+        entityLockKeys: [
+          .../* @__PURE__ */ new Set([...journal.entityLocks, ...extraPrimaryEntityLocks])
+        ]
+      },
       ...secondaryTargets
     ],
     { now }
@@ -13075,9 +13292,10 @@ async function acquireRecoveryOperationLocks(primaryStore, journal, stores, now)
 }
 async function loadBoundPayload(store, journal) {
   if (journal.recoveryPayloadDigest === void 0) return null;
-  const payload = await readOperationRecoveryPayload(
+  const payload = await readOperationRecoveryPayloadForDigest(
     store,
-    journal.operationId
+    journal.operationId,
+    journal.recoveryPayloadDigest
   );
   if (payload === null) {
     throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_MISSING");
@@ -13088,6 +13306,301 @@ async function loadBoundPayload(store, journal) {
   }
   return parsed;
 }
+function assertCheckpointReplacementSupported(journal, replacementCheckpointId) {
+  if (replacementCheckpointId === void 0) return;
+  if (journal.type !== "reframe" || journal.state !== "repair_required" || journal.recoveryPayloadDigest === void 0 || journal.secondaryReservations.length !== 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_UNSUPPORTED");
+  }
+}
+async function assertTerminalCheckpointReplacementRetry(store, journal, replacementCheckpointId) {
+  if (replacementCheckpointId === void 0) return;
+  if (journal.type !== "reframe" || journal.state !== "committed" || journal.recoveryPayloadDigest === void 0 || journal.secondaryReservations.length !== 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_UNSUPPORTED");
+  }
+  const payload = await loadBoundPayload(store, journal);
+  if (payload === null) {
+    throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_REQUIRED");
+  }
+  assertOperationRecoveryPayloadCoversJournal(journal, payload);
+  const replacement = await reframeCheckpointReplacementProvenance(
+    store,
+    journal,
+    payload
+  );
+  if (replacement?.replacementCheckpointId !== replacementCheckpointId) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_NOT_APPLICABLE");
+  }
+}
+async function replaceReframeRecoveryCheckpoint(input) {
+  const checkpointAction = singleReframeCheckpointAction(input.payload);
+  const previousCheckpointId = checkpointAction.checkpoint.checkpointId;
+  const priorReplacement = await reframeCheckpointReplacementProvenance(
+    input.primaryStore,
+    input.journal,
+    input.payload
+  );
+  if (priorReplacement !== null) {
+    if (priorReplacement.replacementCheckpointId !== input.replacementCheckpointId) {
+      throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_NOT_APPLICABLE");
+    }
+    await assertRecoveryPayloadState(
+      input.projectRoot,
+      input.stores,
+      input.payload
+    );
+    return {
+      journal: input.journal,
+      payload: input.payload,
+      checkpointReplacement: priorReplacement
+    };
+  }
+  if (previousCheckpointId === input.replacementCheckpointId) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_NOT_APPLICABLE");
+  }
+  const taskRootPath2 = await taskRoot(
+    input.projectRoot,
+    checkpointAction.checkpoint.taskRef
+  );
+  const currentCheckpoint = await readTaskCheckpointAtRoot(
+    taskRootPath2,
+    previousCheckpointId
+  );
+  if (!reframeCheckpointStepReached(input.journal) || currentCheckpoint === null || currentCheckpoint.operationId === input.journal.operationId || !sameTaskRef(
+    currentCheckpoint.taskRef,
+    checkpointAction.checkpoint.taskRef
+  ) || digestCanonicalJson(currentCheckpoint) === digestCanonicalJson(checkpointAction.checkpoint)) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_NOT_APPLICABLE");
+  }
+  await assertRecoveryPayloadState(
+    input.projectRoot,
+    input.stores,
+    input.payload,
+    checkpointAction
+  );
+  await assertReframeRecoveryPlanCurrent(input.projectRoot, input.payload);
+  const payload = buildReframeCheckpointReplacementPayload(
+    input.payload,
+    checkpointAction,
+    input.replacementCheckpointId
+  );
+  const replacementAction = singleReframeCheckpointAction(payload);
+  const existingReplacement = await readTaskCheckpointAtRoot(
+    taskRootPath2,
+    input.replacementCheckpointId
+  );
+  if (existingReplacement !== null && digestCanonicalJson(existingReplacement) !== digestCanonicalJson(replacementAction.checkpoint)) {
+    throw new Error("MANCODE_REPLACEMENT_CHECKPOINT_ID_CONFLICT");
+  }
+  await assertRecoveryPayloadState(input.projectRoot, input.stores, payload);
+  const fromKey = `checkpoint:${previousCheckpointId}`;
+  const toKey = `checkpoint:${input.replacementCheckpointId}`;
+  const payloadDigest = operationRecoveryPayloadDigest(payload);
+  const journal = parseOperationJournal({
+    ...input.journal,
+    recoveryPayloadDigest: payloadDigest,
+    entityLocks: input.journal.entityLocks.map(
+      (key) => key === fromKey ? toKey : key
+    ),
+    expectedRevisions: Object.fromEntries(
+      Object.entries(input.journal.expectedRevisions).map(([key, revision]) => [
+        key === fromKey ? toKey : key,
+        revision
+      ])
+    ),
+    updatedAt: input.now.toISOString()
+  });
+  assertOperationJournalMatchesDefinition(journal);
+  assertOperationRecoveryPayloadCoversJournal(journal, payload);
+  await writeOperationRecoveryPayloadVersion(input.primaryStore, payload);
+  const updatedJournal = await updateOperationJournal(
+    input.primaryStore,
+    journal,
+    {
+      canAbort: false,
+      reframeCheckpointReplacement: {
+        fromCheckpointId: previousCheckpointId,
+        toCheckpointId: input.replacementCheckpointId
+      }
+    }
+  );
+  throwIfOperationCrashInjected("reframe", "rebind-reframe-checkpoint");
+  return {
+    journal: updatedJournal,
+    payload,
+    checkpointReplacement: {
+      previousCheckpointId,
+      replacementCheckpointId: input.replacementCheckpointId
+    }
+  };
+}
+function reframeCheckpointStepReached(journal) {
+  const checkpointIndex = journal.steps.findIndex(
+    (step) => step.id === "write-reframe-checkpoint"
+  );
+  return checkpointIndex >= 0 && journal.steps.slice(0, checkpointIndex).every((step) => step.state === "completed");
+}
+async function reframeCheckpointReplacementProvenance(store, journal, payload) {
+  if (journal.type !== "reframe") return null;
+  const canonicalValue = await readOperationRecoveryPayload(
+    store,
+    journal.operationId
+  );
+  if (canonicalValue === null) {
+    throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_MISSING");
+  }
+  const canonical = parseOperationRecoveryPayload(canonicalValue);
+  if (canonical.operationId !== journal.operationId || canonical.type !== journal.type || canonical.primaryStoreId !== journal.primaryStoreId) {
+    throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_MISMATCH");
+  }
+  if (operationRecoveryPayloadDigest(canonical) === operationRecoveryPayloadDigest(payload)) {
+    return null;
+  }
+  const previousCheckpointId = singleReframeCheckpointAction(canonical).checkpoint.checkpointId;
+  const replacementCheckpointId = singleReframeCheckpointAction(payload).checkpoint.checkpointId;
+  if (previousCheckpointId === replacementCheckpointId) return null;
+  const expected = buildReframeCheckpointReplacementPayload(
+    canonical,
+    singleReframeCheckpointAction(canonical),
+    replacementCheckpointId
+  );
+  if (operationRecoveryPayloadDigest(expected) !== operationRecoveryPayloadDigest(payload)) {
+    throw new Error("MANCODE_OPERATION_RECOVERY_PAYLOAD_MISMATCH");
+  }
+  return { previousCheckpointId, replacementCheckpointId };
+}
+async function assertReframeRecoveryPlanCurrent(projectRoot, payload) {
+  if (payload.type !== "reframe") return;
+  const checkpointAction = singleReframeCheckpointAction(payload);
+  const archiveAction = singleTaskArchiveAction(payload);
+  const task = await new V3ContextStore(projectRoot).readTaskSnapshot(
+    checkpointAction.checkpoint.taskRef
+  );
+  if ((task.plan?.digest ?? null) !== archiveAction.sourcePlanDigest) {
+    throw new Error("MANCODE_OPERATION_RECOVERY_CONFLICT");
+  }
+}
+function buildReframeCheckpointReplacementPayload(payload, checkpointAction, replacementCheckpointId) {
+  const finalMetadataAction = singleTaskAuthorityAction(
+    payload,
+    "commit-reframed-metadata",
+    "metadata.json"
+  );
+  const requirementsAction = singleTaskAuthorityAction(
+    payload,
+    "write-requirements-draft",
+    "requirements.json"
+  );
+  const reviewAction = singleTaskAuthorityAction(
+    payload,
+    "mark-review-verification-stale",
+    "review-ledger.json"
+  );
+  const verificationAction = singleTaskAuthorityAction(
+    payload,
+    "mark-review-verification-stale",
+    "verification-ledger.json"
+  );
+  const archiveAction = singleTaskArchiveAction(payload);
+  const metadata = parseWorkflowMetadata(
+    JSON.parse(finalMetadataAction.targetContent)
+  );
+  if (metadata.lastOperationId !== payload.operationId || metadata.latestCheckpointRef?.kind !== "checkpoint" || metadata.latestCheckpointRef.artifactId !== checkpointAction.checkpoint.checkpointId) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
+  }
+  const checkpoint = parseCheckpoint({
+    ...checkpointAction.checkpoint,
+    checkpointId: replacementCheckpointId
+  });
+  const replacementMetadata = parseWorkflowMetadata({
+    ...metadata,
+    latestCheckpointRef: {
+      ...metadata.latestCheckpointRef,
+      artifactId: replacementCheckpointId
+    }
+  });
+  const aggregate = buildTaskAggregateManifest({
+    metadata: replacementMetadata,
+    requirements: parseRequirementsLedger(
+      JSON.parse(requirementsAction.targetContent)
+    ),
+    review: parseReviewLedger(JSON.parse(reviewAction.targetContent)),
+    verification: parseVerificationLedger(
+      JSON.parse(verificationAction.targetContent)
+    ),
+    planDigest: archiveAction.sourcePlanDigest,
+    latestCheckpoint: checkpoint
+  });
+  const fenceActions = payload.actions.filter(
+    (action) => action.kind === "task_head_fence"
+  );
+  if (fenceActions.length > 1) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
+  }
+  return parseOperationRecoveryPayload({
+    ...payload,
+    actions: payload.actions.map((action) => {
+      if (action === checkpointAction) {
+        return { ...action, checkpoint };
+      }
+      if (action === finalMetadataAction) {
+        return {
+          ...action,
+          targetContent: serializeTaskAuthority(replacementMetadata)
+        };
+      }
+      if (action.kind === "task_head_fence") {
+        return {
+          ...action,
+          fence: parseTaskHeadFence({
+            ...action.fence,
+            aggregateDigest: taskAggregateDigest(aggregate)
+          })
+        };
+      }
+      return action;
+    })
+  });
+}
+function singleReframeCheckpointAction(payload) {
+  const matches = payload.actions.filter(
+    (action) => action.kind === "checkpoint" && action.stepId === "write-reframe-checkpoint" && action.beforeDigest === null
+  );
+  if (matches.length !== 1 || matches[0] === void 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_UNSUPPORTED");
+  }
+  return matches[0];
+}
+function singleTaskAuthorityAction(payload, stepId, fileName) {
+  const matches = payload.actions.filter(
+    (action) => action.kind === "task_authority_file" && action.stepId === stepId && action.fileName === fileName
+  );
+  if (matches.length !== 1 || matches[0] === void 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_UNSUPPORTED");
+  }
+  return matches[0];
+}
+function singleTaskArchiveAction(payload) {
+  const matches = payload.actions.filter(
+    (action) => action.kind === "task_archive" && action.stepId === "archive-requirements-plan"
+  );
+  if (matches.length !== 1 || matches[0] === void 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_UNSUPPORTED");
+  }
+  return matches[0];
+}
+async function assertRecoveryPayloadState(projectRoot, stores, payload, ignoredAction) {
+  for (const [index, action] of payload.actions.entries()) {
+    if (action === ignoredAction) continue;
+    const current = await currentActionDigest(projectRoot, stores, action);
+    const target = recoveryActionTargetDigest(action);
+    const laterTarget = payload.actions.slice(index + 1).some(
+      (candidate) => recoveryActionResourceKey(candidate) === recoveryActionResourceKey(action) && recoveryActionTargetDigest(candidate) === current
+    );
+    if (current !== target && current !== action.beforeDigest && !laterTarget) {
+      throw new Error("MANCODE_OPERATION_RECOVERY_CONFLICT");
+    }
+  }
+}
 async function allActionsAtInitialState(projectRoot, stores, payload) {
   const initialByResource = /* @__PURE__ */ new Map();
   for (const action of payload.actions) {
@@ -13796,7 +14309,7 @@ async function upgradeV3Adapters(input) {
   if (unfinished.length > 0) {
     throw new Error("MANCODE_ADAPTER_UPGRADE_OPERATION_PENDING");
   }
-  const actualVersions = await import("./v3-adapter-ZLYZAA4P.js").then(
+  const actualVersions = await import("./v3-adapter-7KIOYYWS.js").then(
     ({ inspectV3AdapterVersions: inspectV3AdapterVersions2 }) => inspectV3AdapterVersions2(
       root,
       managedAdapterNames(project.manifest.managedAdapters)
@@ -14808,6 +15321,7 @@ trigger: <\u5177\u4F53\u4E8B\u5B9E>
 
 **\u6536\u5C3E\u9636\u6BB5**\uFF1A
 - \u4E00\u8F6E\u4FEE\u590D\u540E\u91CD\u8DD1\u53D7\u5F71\u54CD\u7684 build/lint/typecheck/test \u548C\u5FC5\u8981 smoke test\uFF0C\u4E0D\u91CD\u590D\u8FD0\u884C\u5DF2\u5B8C\u6210 reviewer\u3002
+- ${ACCEPTED_STATE_NARRATIVE_GUIDANCE}
 - \u751F\u6210 summary\uFF1A\u6539\u52A8/\u65B0\u5EFA\u6587\u4EF6\u3001\u590D\u7528\u8D44\u6E90\u3001\u9A8C\u8BC1\u7ED3\u679C\u3001\u5BA1\u67E5\u6DF1\u5EA6\u3001\u95EE\u9898\u5904\u7F6E\u3001\u8DF3\u8FC7\u6B65\u9AA4\u548C\u6B8B\u4F59\u98CE\u9669\u3002
 - \u53EA\u6709\u9A8C\u8BC1\u901A\u8FC7\u3001\u6240\u9700\u5BA1\u67E5\u9886\u57DF\u5B8C\u6210\u4E14 blocker \u6E05\u96F6\u624D\u5EFA\u8BAE \`completed\`\uFF1B\u5426\u5219\u5199 \`blocked\` \u4E0E\u660E\u786E blockingReason\u3002
 - \u5C06\u5173\u952E\u51B3\u7B56\u4EA4\u7ED9\u8C03\u7528\u65B9 appendTeamDecision\uFF0C\u5E76\u66F4\u65B0 Active Plans\u3002
@@ -15388,6 +15902,9 @@ trigger: <\u5177\u4F53\u4E8B\u5B9E>
 - \u547D\u540D\u3001\u53EF\u8BFB\u6027\u3001DRY\u3001loading/error \u5F62\u5F0F\u7B49\u5EFA\u8BAE\u4E0D\u81EA\u52A8\u6269\u5927\u6539\u52A8\uFF1B\u4E0E\u9700\u6C42\u65E0\u5173\u65F6\u4E0D\u8F93\u51FA\u3002
 - \u9274\u6743\u3001\u652F\u4ED8\u3001\u654F\u611F\u6570\u636E\u3001\u5220\u9664\u3001\u516C\u5F00 API\u3001\u672A\u53EF\u4FE1\u8F93\u5165\u3001\u5E76\u53D1\u6216\u57FA\u7840\u8BBE\u65BD\u7B49\u786C\u98CE\u9669\u540C\u6837\u5C5E\u4E8E\u5347\u7EA7\u4FE1\u53F7\uFF1B\u82E5\u6CA1\u6709\u89E6\u53D1 realignment\uFF0C\u7528\u6237\u660E\u786E\u9009\u62E9\u7EE7\u7EED solo \u540E\u53EF\u4EE5\u7EE7\u7EED\u3002
 
+### \u6700\u7EC8\u4EA4\u4ED8\u53D9\u4E8B
+${ACCEPTED_STATE_NARRATIVE_GUIDANCE}
+
 ## \u4F60\u7684\u98CE\u683C
 
 - \u76F4\u63A5\u3001\u7B80\u6D01\u3001\u4E0D\u5E9F\u8BDD
@@ -15403,7 +15920,11 @@ var CORE_CODING_PRINCIPLES = `## \u94C1\u5F8B\uFF08\u6C38\u4E0D\u8FDD\u53CD\uFF0
 2. **\u5148\u9A8C\u8BC1\u518D\u58F0\u79F0\u5B8C\u6210** \u2014 \u5F00\u5DE5\u524D\u5199\u660E\u5B9E\u8D28\u5047\u8BBE\u548C\u53EF\u9A8C\u8BC1\u6210\u529F\u6807\u51C6\uFF1Bbuild/lint/test \u5FC5\u987B\u5B9E\u9645\u8DD1
 3. **\u5931\u8D25\u4E24\u6B21\u5FC5\u987B\u505C\u4E0B** \u2014 \u4E0D\u76F2\u8BD5
 4. **\u4E0D\u53EF\u9006\u64CD\u4F5C\u5148\u95EE** \u2014 \u5220\u9664\u3001force push\u3001worktree \u5408\u5E76
-5. **\u53EA\u89E3\u51B3\u88AB\u95EE\u5230\u7684\u95EE\u9898** \u2014 \u4F18\u5148\u590D\u7528\u73B0\u6709\u5B9E\u73B0\uFF0C\u9009\u62E9\u6EE1\u8DB3\u9A8C\u6536\u7684\u6700\u5C0F\u76F4\u63A5\u6539\u52A8\uFF1B\u4E0D\u52A0\u63A8\u6D4B\u6027\u529F\u80FD\u3001\u4E00\u6B21\u6027\u62BD\u8C61\u3001\u65E0\u5173\u6E05\u7406\u6216\u591A\u4F59\u914D\u7F6E`;
+5. **\u53EA\u89E3\u51B3\u88AB\u95EE\u5230\u7684\u95EE\u9898** \u2014 \u4F18\u5148\u590D\u7528\u73B0\u6709\u5B9E\u73B0\uFF0C\u9009\u62E9\u6EE1\u8DB3\u9A8C\u6536\u7684\u6700\u5C0F\u76F4\u63A5\u6539\u52A8\uFF1B\u4E0D\u52A0\u63A8\u6D4B\u6027\u529F\u80FD\u3001\u4E00\u6B21\u6027\u62BD\u8C61\u3001\u65E0\u5173\u6E05\u7406\u6216\u591A\u4F59\u914D\u7F6E
+
+## \u6700\u7EC8\u4EA4\u4ED8\u53D9\u4E8B
+
+${ACCEPTED_STATE_NARRATIVE_GUIDANCE}`;
 
 // src/templates/skills/man.ts
 var MAN_SKILL = {
@@ -15415,6 +15936,10 @@ var MAN_SKILL = {
 
 \u7528 \`mancode workflow create man "<task>" --json\` \u521B\u5EFA workflow \u5E76\u8BFB\u53D6\u8FD4\u56DE\u7684 taskId\uFF1B\u4E0D\u5F97\u76F4\u63A5\u521B\u5EFA\u6216\u6539\u5199 metadata.json\u3002\u968F\u540E\u53EA\u7528 workflow CLI \u66F4\u65B0\u9700\u6C42\u3001\u9A8C\u8BC1\u3001step/status/planVersion/skippedSteps\u3002\u901A\u7528 \`--skipped\` \u53EA\u7528\u4E8E Step 1\u20132 \u7684 \`clarification\`\uFF1B\u7528\u6237\u660E\u786E\u8DF3\u8FC7\u6574\u4E2A review \u65F6\u5FC5\u987B\u5728 Step 6 \u4F7F\u7528\u4E13\u7528 \`workflow review ... skip --reason\`\uFF0C\u4E0D\u80FD\u5199\u6570\u5B57\u3001\`film-1\` \u6216 \`film-2\`\u3002state \u7684 \`currentMode\`\u3001\`currentTask\` \u548C \`currentWorkflowMode\` \u6307\u5411\u672C task\u3002
 
+\u5F53\u4EFB\u52A1\u663E\u5F0F\u4F7F\u7528 document-bound delivery\uFF08\`mancode workflow create man "<task>" --delivery\`\uFF0Cplanning policy 3\uFF09\u65F6\uFF0C\u4EE5\u4E0B\u4EA4\u4ED8\u89C4\u5219\u53EA\u5BF9\u8BE5\u65B0 \`/man\` \u4EFB\u52A1\u751F\u6548\uFF1B\u666E\u901A \`/man\`\u3001\u65E7\u4EFB\u52A1\u3001\`/manba\`\u3001\`/manteam\`\u3001\`/manps\`\u3001\`/mansolo\` \u548C Solo handoff \u4FDD\u6301\u539F\u534F\u8BAE\u3002\u8BA1\u5212\u5FC5\u987B\u7ED1\u5B9A\u9879\u76EE\u6307\u5B9A\u7684\u8BA1\u5212\u6587\u4EF6\uFF08\u9ED8\u8BA4 \`doc/\`\uFF0C\u5DF2\u6709 \`docs/\` \u7EA6\u5B9A\u4F18\u5148\uFF09\uFF0C\u6A21\u5757\u5B8C\u6210\u540E\u628A\u5B9E\u9645\u4EA4\u4ED8\u56DE\u5199\u5230\u540C\u4E00\u6587\u4EF6\u7684 delivery record\uFF0C\u518D\u505A\u4E00\u6B21\u6A21\u5757\u603B\u5BA1\u3002\u603B\u5BA1\u8BFB\u53D6\u5DF2\u6279\u51C6\u8BA1\u5212\u3001\u76F8\u5173\u67B6\u6784\u3001\u5B8C\u6574\u6A21\u5757 diff\u3001\u5165\u53E3/\u8C03\u7528\u94FE\u548C\u9A8C\u8BC1\u8BC1\u636E\uFF0C\u68C0\u67E5\u76EE\u6807\u8986\u76D6\u3001\u771F\u5B9E\u6B63\u786E\u6027/\u6F0F\u6D1E\uFF0C\u4EE5\u53CA\u65E0\u4F9D\u636E\u7684\u9632\u5FA1\u548C\u62BD\u8C61\uFF1B\u5B83\u4E0D\u80FD\u53EA\u542C\u5B9E\u73B0\u8005\u603B\u7ED3\u3002reviewer \u8FDB\u7A0B\u9000\u51FA\u7801\u4E3A 0 \u6216\u81EA\u7136\u8BED\u8A00\u8BF4\u201C\u901A\u8FC7\u201D\u90FD\u4E0D\u4EE3\u8868 review \u5DF2\u5199\u5165\uFF1A\u5FC5\u987B\u91CD\u65B0\u8FD0\u884C \`mancode workflow delivery <TaskRef> inspect --json\`\uFF0C\u770B\u5230 ledger \u4ECD\u4E3A \`pending\`\u3001\`in_review\`\u3001\`stale\` \u6216 \`blocked\` \u65F6\uFF0C\u62A5\u544A \`review_incomplete\` \u5E76\u7EE7\u7EED\u5BA1\u6838\u6216\u4FEE\u590D\u3002\`reviewer: independent\` \u53EA\u662F\u8C03\u7528\u8005\u81EA\u8FF0\u7684\u5BA1\u6838\u5143\u6570\u636E\uFF0C\u4E0D\u662F actor/session \u8EAB\u4EFD\u8BA4\u8BC1\uFF0C\u4E0D\u80FD\u636E\u6B64\u5BA3\u79F0\u7CFB\u7EDF\u5DF2\u8BC1\u660E\u72EC\u7ACB\u5BA1\u6838\u3002
+
+delivery requirements \u7684\u6BCF\u4E2A\u5FC5\u9700\u9A8C\u6536\u9879\u90FD\u5FC5\u987B\u7528 \`verificationSurfaces\` \u6309 automated/manual slot \u58F0\u660E\u671F\u671B observation surface\uFF1Bdelivery \u9A8C\u8BC1\u8F93\u5165\u518D\u58F0\u660E\u5B9E\u9645 surface\uFF1A\`unit\`\u3001\`component\`\u3001\`handler\`\u3001\`real_http\`\u3001\`browser\`\u3001\`device\`\u3001\`external_service\` \u6216 \`manual_observation\`\u3002\u4F8B\u5982\u771F\u5B9E HTTP \u7684\u671F\u671B\u548C\u5B9E\u9645\u90FD\u5FC5\u987B\u662F \`real_http\`\uFF1B\u4E0D\u80FD\u4ECE\u547D\u4EE4\u540D\u731C\u6D4B\uFF0C\u4E5F\u4E0D\u80FD\u628A handler/mock/\u622A\u56FE\u5F53\u6210\u771F\u5B9E HTTP\u3002\u7F3A\u5C11\u6216\u4E0D\u5339\u914D\u7684\u8BC1\u636E\u4FDD\u6301\u672A\u9A8C\u8BC1\u3002\u5B8C\u6210\u524D\u4EE5 \`delivery check --json\` \u7684\u7ED3\u6784\u5316 finalization blockers \u4E3A\u51C6\uFF0C\u5148\u89E3\u51B3 review\u3001verification\u3001delivery record\u3001scope \u548C\u672A\u63D0\u4EA4\u53D8\u66F4\uFF0C\u518D\u8FD0\u884C \`workflow complete\`\uFF1B\u8303\u56F4\u5916\u672A\u63D0\u4EA4\u6587\u4EF6\u5FC5\u987B\u5148\u79FB\u51FA\u3001stash \u6216\u5355\u72EC\u63D0\u4EA4\uFF0C\u4E0D\u80FD\u6DF7\u5165\u672C\u4EFB\u52A1\u63D0\u4EA4\u3002\u6CA1\u6709 upstream \u6216 push \u5931\u8D25\u8868\u793A\u672A\u53D1\u5E03\uFF0C\u4E0D\u662F\u4E1A\u52A1\u963B\u585E\u3002include/exclude \u53EA\u63A5\u6536 repo-relative path \u6216 glob\uFF0C\u8BED\u4E49\u8303\u56F4\u5199\u5728 requirements\uFF1B\u8BA1\u5212\u8DEF\u5F84\u8D8A\u754C\u65F6\u6309 CLI \u7ED9\u51FA\u7684\u5177\u4F53\u8DEF\u5F84\u4FEE\u6B63\uFF0C\u4E0D\u8981\u9760\u731C\u6D4B\u8BCD\u8868\u6269\u5927\u9632\u5FA1\u3002
+
 ## \u8BA1\u5212\u804C\u8D23\u4E0E\u6280\u672F\u9009\u62E9\u5173\u5361
 
 \u628A \`/man\` \u4F5C\u4E3A\u6B63\u5F0F\u8BA1\u5212\u5165\u53E3\uFF1A\u5148\u5BF9\u9F50\u9700\u6C42\u5E76\u4EA7\u51FA\u53EF\u786E\u8BA4\u7684\u8BA1\u5212\uFF0C\u4E0D\u56E0\u8BA1\u5212\u5B8C\u6210\u800C\u81EA\u52A8\u8FDB\u5165\u5B8C\u6574\u5B9E\u65BD\u3002\u8BA1\u5212\u5173\u5361\u5FC5\u987B\u8BA9\u7528\u6237\u9009\u62E9\u53EA\u4FDD\u7559\u8BA1\u5212\u3001\u4EA4\u7ED9\u9ED8\u8BA4 \`solo\` \u8F7B\u91CF\u5B9E\u65BD\u3001\u7EE7\u7EED\u5B8C\u6574 \`/man\` \u6216\u4FEE\u6539\u8BA1\u5212\u3002
@@ -15438,7 +15963,7 @@ var MAN_SKILL = {
 
 \u6309\u4EFB\u52A1\u5B9E\u9645\u9002\u7528\u8303\u56F4\u68C0\u67E5\uFF1A\u7528\u6237\u76EE\u6807\u4E0E\u5E73\u53F0\u3001\u6838\u5FC3\u6D41\u7A0B\u3001\u9996\u671F\u8303\u56F4\u3001\u6392\u9664\u9879\u3001\u6280\u672F\u4E0E\u8FD0\u884C\u7EA6\u675F\u3001\u6570\u636E/\u72B6\u6001/\u96C6\u6210\u3001\u6027\u80FD/\u517C\u5BB9\u6027/\u5B89\u5168\u3001\u53EF\u9A8C\u8BC1\u5B8C\u6210\u6807\u51C6\u3002\u8FDE\u7EED\u6F84\u6E05\u6CA1\u6709\u51CF\u5C11 blocking \u9879\u65F6\uFF0C\u4E0D\u6563\u95EE\uFF1B\u8BA9\u7528\u6237\u9009\u62E9\u7F29\u5C0F\u9996\u671F\u8303\u56F4\u3001\u63A5\u53D7\u5217\u660E\u7684\u63A8\u8350\u9ED8\u8BA4\u503C\u6216\u6682\u505C\u3002
 
-\u628A\u7ED3\u8BBA\u5199\u5165\u7ED3\u6784\u5316\u9700\u6C42\u8F93\u5165\uFF0C\u81F3\u5C11\u5305\u542B \`goal\`\u3001\u975E\u7A7A \`confirmedScope\`\u3001\`excludedScope\`\u3001\`technicalDecisions\`\u3001\`defaults\`\u3001\`blockingUnknowns\`\u3001\`coverage\` \u548C \`acceptanceCriteria\`\u3002coverage \u5FC5\u987B\u9010\u9879\u8BF4\u660E platform\u3001core_scope\u3001technical_stack\u3001data_and_persistence\u3001performance\u3001compatibility\u3001security \u662F \`confirmed\`\u3001\`defaulted\` \u6216\u5E26\u7406\u7531\u7684 \`not_applicable\`\uFF0C\u4E0D\u80FD\u7528\u7A7A\u6570\u7EC4\u5047\u88C5\u5DF2\u7ECF\u8003\u8651\u3002\u6BCF\u4E2A\u6838\u5FC3\u7528\u6237\u884C\u4E3A\u5FC5\u987B\u6709\u7A33\u5B9A\u9A8C\u6536 ID\uFF08\`AC-1\` \u7B49\uFF09\u3001\u63CF\u8FF0\u3001\`required\` \u548C\u9A8C\u8BC1\u65B9\u5F0F \`automated\` / \`manual\` / \`hybrid\`\uFF1B\u81F3\u5C11\u4E00\u4E2A\u9A8C\u6536\u9879\u5FC5\u9700\u3002\u8FD0\u884C \`mancode workflow requirements <taskId> finalize --file <requirements-input.json>\`\uFF0C\u7531 CLI \u6821\u9A8C\u5E76\u751F\u6210\u6743\u5A01 \`requirements.json\` \u4E0E \`requirements.md\`\uFF0C\u4E0D\u8981\u624B\u5DE5\u5236\u9020\u4E24\u4EFD\u53EF\u80FD\u51B2\u7A81\u7684\u7ED3\u8BBA\u3002\u65E0\u987B\u63D0\u95EE\u65F6\u53EF\u628A \`clarification\` \u8BB0\u5165\u7D2F\u8BA1 skippedSteps\uFF0C\u4F46\u4E0D\u80FD\u8DF3\u8FC7\u9700\u6C42\u6458\u8981\u4E0E\u5C31\u7EEA\u5224\u65AD\u3002\u4ECD\u6709 blocking \u9879\u65F6\u505C\u5728 Step 2\uFF1B\u53EA\u6709 CLI \u8FD4\u56DE ready \u624D\u8FD0\u884C \`mancode workflow update <taskId> --step 3\`\u3002
+\u628A\u7ED3\u8BBA\u5199\u5165\u7ED3\u6784\u5316\u9700\u6C42\u8F93\u5165\uFF0C\u81F3\u5C11\u5305\u542B \`goal\`\u3001\u975E\u7A7A \`confirmedScope\`\u3001\`excludedScope\`\u3001\`technicalDecisions\`\u3001\`defaults\`\u3001\`blockingUnknowns\`\u3001\`coverage\` \u548C \`acceptanceCriteria\`\u3002coverage \u5FC5\u987B\u9010\u9879\u8BF4\u660E platform\u3001core_scope\u3001technical_stack\u3001data_and_persistence\u3001performance\u3001compatibility\u3001security \u662F \`confirmed\`\u3001\`defaulted\` \u6216\u5E26\u7406\u7531\u7684 \`not_applicable\`\uFF0C\u4E0D\u80FD\u7528\u7A7A\u6570\u7EC4\u5047\u88C5\u5DF2\u7ECF\u8003\u8651\u3002\u6BCF\u4E2A\u6838\u5FC3\u7528\u6237\u884C\u4E3A\u5FC5\u987B\u6709\u7A33\u5B9A\u9A8C\u6536 ID\uFF08\`AC-1\` \u7B49\uFF09\u3001\u63CF\u8FF0\u3001\`required\` \u548C\u9A8C\u8BC1\u65B9\u5F0F \`automated\` / \`manual\` / \`hybrid\`\uFF1Bdocument-bound delivery \u7684\u5FC5\u9700\u9879\u8FD8\u8981\u63D0\u4F9B\u4E0E method \u69FD\u4F4D\u4E00\u81F4\u7684 \`verificationSurfaces\`\uFF0C\u4F8B\u5982 \`{ "automated": "real_http" }\`\uFF0Chybrid \u540C\u65F6\u63D0\u4F9B automated \u548C manual\u3002\u81F3\u5C11\u4E00\u4E2A\u9A8C\u6536\u9879\u5FC5\u9700\u3002\u8FD0\u884C \`mancode workflow requirements <taskId> finalize --file <requirements-input.json>\`\uFF0C\u7531 CLI \u6821\u9A8C\u5E76\u751F\u6210\u6743\u5A01 \`requirements.json\` \u4E0E \`requirements.md\`\uFF0C\u4E0D\u8981\u624B\u5DE5\u5236\u9020\u4E24\u4EFD\u53EF\u80FD\u51B2\u7A81\u7684\u7ED3\u8BBA\u3002\u65E0\u987B\u63D0\u95EE\u65F6\u53EF\u628A \`clarification\` \u8BB0\u5165\u7D2F\u8BA1 skippedSteps\uFF0C\u4F46\u4E0D\u80FD\u8DF3\u8FC7\u9700\u6C42\u6458\u8981\u4E0E\u5C31\u7EEA\u5224\u65AD\u3002\u4ECD\u6709 blocking \u9879\u65F6\u505C\u5728 Step 2\uFF1B\u53EA\u6709 CLI \u8FD4\u56DE ready \u624D\u8FD0\u884C \`mancode workflow update <taskId> --step 3\`\u3002
 
 ### Step 3: Plan Coach \u51FA\u8BA1\u5212
 
@@ -15492,7 +16017,7 @@ Plan Coach \u5FC5\u987B\u8BC1\u660E\u6240\u6709\u9009\u9879\u89E3\u51B3\u540C\u4
 
 1. \u5B58\u5728 open blocker \u65F6\uFF0CHead Coach \u4E00\u6B21\u6027\u4FEE\u590D\u5168\u90E8 blocker\uFF0C\u5E76\u7528 \`mancode workflow review <taskId> remediate --resolved Q1,D1\` \u8BB0\u5F55\u552F\u4E00\u4E00\u8F6E\u4FEE\u590D\uFF1B\u6CA1\u6709 blocker \u65F6\u4E0D\u8FD0\u884C remediate\u3002\u4E0D\u8981\u4E3A \u{1F7E1}/\u{1F7E2} \u6269\u5927\u6539\u52A8\u3002
 2. remediation \u4F1A\u4F7F\u65E7\u9A8C\u8BC1\u6574\u6279\u5931\u6548\u3002\u5728 Step 9 \u91CD\u8DD1\u5168\u90E8 required \u9A8C\u6536\uFF0C\u5E76\u901A\u8FC7 verify record/require-manual/confirm-manual \u91CD\u65B0\u767B\u8BB0\u8BC1\u636E\uFF1B\u672A\u91CD\u65B0\u5168\u90E8\u901A\u8FC7\u4E0D\u80FD completed\u3002\u4E0D\u91CD\u65B0\u8FD0\u884C\u5DF2\u5B8C\u6210\u7684 reviewer\u3002\u4FEE\u590D\u82E5\u5F15\u5165\u65B0\u7684\u9AD8\u98CE\u9669\u9762\u5219\u6807\u8BB0 blocked\uFF0C\u4E0D\u80FD\u5F00\u542F\u65E0\u754C review \u5FAA\u73AF\u3002
-3. \u5199 \`summary.md\`\uFF1A\u6539\u52A8\u3001\u65B0\u5EFA\u3001\u590D\u7528\u3001\u9A8C\u8BC1\u3001\u5BA1\u67E5\u6DF1\u5EA6\u3001findings \u5904\u7F6E\u3001\u8DF3\u8FC7\u6B65\u9AA4\u548C\u6B8B\u4F59\u98CE\u9669\u3002
+3. \u57FA\u4E8E accepted target\u3001\u4EFB\u52A1\u8D77\u59CB baseline\u3001\u5B9E\u9645\u8BFB\u56DE\u72B6\u6001\u548C task-owned diff \u5199 \`summary.md\` \u53CA\u4EFB\u4F55 commit/PR \u6587\u6848\uFF1A\u8BB0\u5F55\u6539\u52A8\u3001\u65B0\u5EFA\u3001\u590D\u7528\u3001\u9A8C\u8BC1\u3001\u5BA1\u67E5\u6DF1\u5EA6\u3001findings \u5904\u7F6E\u3001\u8DF3\u8FC7\u6B65\u9AA4\u548C\u6B8B\u4F59\u98CE\u9669\uFF1B\u4FDD\u7559 \`excludedScope\`\u3001\u5931\u8D25\u9A8C\u8BC1\u3001blocker\u3001\u8FC1\u79FB/\u56DE\u6EDA\u548C\u5BA1\u8BA1\u4E8B\u5B9E\u3002
 4. CLI \u786E\u8BA4\u6240\u9700\u5BA1\u67E5\u9886\u57DF\u5B8C\u6210\u4E14 blocker \u6E05\u96F6\u540E\u624D\u5199 \`completed\`\uFF1B\u5426\u5219\u7528 \`--status blocked --blocking-reason "<\u539F\u56E0>"\`\u3002
 5. \u5173\u952E\u51B3\u7B56 appendTeamDecision \u5230 \`decisions.md\`\uFF0C\u66F4\u65B0 Active Plans\u3002\u53D1\u73B0\u65B0\u7684\u9AD8\u9891\u9886\u57DF\u8BCD\u65F6\u5411\u7528\u6237\u63D0\u8BAE\uFF0C\u7ECF\u7528\u6237\u786E\u8BA4\u540E\u7528 \`mancode context glossary add\` \u767B\u8BB0\uFF0C\u4E0D\u5F97\u672A\u7ECF\u786E\u8BA4\u5199\u5165\u672F\u8BED\u8868\u3002
 6. worktree \u5408\u5E76\u524D\u53D6\u5F97\u7528\u6237\u786E\u8BA4\uFF1B\u7EC8\u6001\u5199\u5165\u6210\u529F\u540E state \u56DE solo \u5E76\u6E05\u7A7A workflow \u6307\u9488\u3002
@@ -15540,7 +16065,7 @@ var MAMBA_SKILL = {
 
 ## 5. \u771F\u5B9E\u56DE\u5F52\u4E0E\u7ED3\u8BBA
 
-\u91CD\u8DD1\u539F\u8DEF\u5F84\uFF0C\u8986\u76D6\u53D7\u5F71\u54CD\u7684\u5173\u952E\u6B63\u5411\u3001\u8D1F\u5411\u548C\u6743\u9650\u8FB9\u754C\u8DEF\u5F84\uFF0C\u5E76\u8FD0\u884C\u5FC5\u8981 build/lint/typecheck/test\u3002\u5199 \`mamba-report.md\`\uFF1A\u73AF\u5883\u3001\u6B65\u9AA4\u3001\u7ED3\u679C\u3001\u4EA7\u7269\u8DEF\u5F84\u3001\u56DE\u5F52\u8303\u56F4\u3001\u98CE\u9669\u4E0E\u5EFA\u8BAE\u3002
+\u91CD\u8DD1\u539F\u8DEF\u5F84\uFF0C\u8986\u76D6\u53D7\u5F71\u54CD\u7684\u5173\u952E\u6B63\u5411\u3001\u8D1F\u5411\u548C\u6743\u9650\u8FB9\u754C\u8DEF\u5F84\uFF0C\u5E76\u8FD0\u884C\u5FC5\u8981 build/lint/typecheck/test\u3002\u57FA\u4E8E\u5B9E\u9645\u89C2\u5BDF\u5230\u7684\u6700\u7EC8\u72B6\u6001\u5199 \`mamba-report.md\`\uFF1A\u73AF\u5883\u3001\u6B65\u9AA4\u3001\u7ED3\u679C\u3001\u4EA7\u7269\u8DEF\u5F84\u3001\u56DE\u5F52\u8303\u56F4\u3001\u98CE\u9669\u4E0E\u5EFA\u8BAE\uFF1B\u62A5\u544A\u5FC5\u987B\u5982\u5B9E\u4FDD\u7559 no_repro\u3001blocked/manual_test_required\u3001\u5931\u8D25\u9A8C\u8BC1\u3001\u8D1F\u5411\u6216\u6743\u9650\u7ED3\u679C\u548C\u6B8B\u4F59\u98CE\u9669\u3002
 
 - \u5DF2\u4FEE\u590D\uFF1A\`status: "completed", outcome: "fixed"\`
 - \u5DF2\u9A8C\u8BC1\u4F46\u672A\u6539\u4EE3\u7801\uFF1A\`status: "completed", outcome: "verified"\`
@@ -15844,6 +16369,8 @@ var MANTEAM_SKILL = {
 - Follow-up TODOs, only if unavoidable
 - Suggested commit message
 
+handoff\u3001commit \u548C PR \u6587\u6848\u5FC5\u987B\u6765\u81EA accepted target\u3001\u4EFB\u52A1\u8D77\u59CB baseline\u3001\u5B9E\u9645\u8BFB\u56DE\u72B6\u6001\u4E0E task-owned diff\u3002\u4E0D\u5F97\u8BA9\u4F1A\u8BDD\u4E2D\u88AB\u5426\u51B3\u7684\u65B9\u6848\u5B9A\u4E49\u4EA4\u4ED8\u8EAB\u4EFD\uFF0C\u4F46\u5FC5\u987B\u4FDD\u7559\u51B2\u7A81\u3001\u672A\u5B8C\u6210\u5DE5\u4F5C\u3001\u5931\u8D25\u9A8C\u8BC1\u3001blocker\u3001\u8FC1\u79FB/\u56DE\u6EDA\u3001\u5BA1\u8BA1\u4E8B\u5B9E\uFF0C\u4EE5\u53CA\u6B63\u5F0F handoff \u7684 rejected/cancelled \u72B6\u6001\u548C reason\u3002
+
 \u53EA\u6709\u5728\u7528\u6237\u786E\u8BA4\u5B9E\u65BD\u5E76\u5B8C\u6210 workflow \u540E\uFF0C\u624D\u628A\u6700\u7EC8 ADR \u8FFD\u52A0\u5230 \`.mancode/memory/decisions.md\`\u3002abandoned / plan-only workflow \u53EA\u80FD\u4FDD\u7559\u5728 \`.mancode/workflows/<taskId>/team-context.md\`\u3001\`plan.md\` \u548C \`handoff.md\`\uFF0C\u4E0D\u80FD\u6C61\u67D3\u957F\u671F\u56E2\u961F memory\u3002
 
 ## Commit Discipline
@@ -16814,7 +17341,7 @@ var MODE_META = {
       "   If environment, permission, or data is missing, set blocked with `--blocking-reason` and keep state resumable instead of advancing.",
       "3. Reproduce the shortest path and write `diagnosis.md` with evidence, root cause or candidates, impact, and confidence; then update to Step 4.",
       "4. Apply only the requested minimum fix, or make no code change when the user requested validation only. New architecture or cross-module scope returns to /man. Then update to Step 5.",
-      "5. Re-run the path and affected positive, negative, and permission boundaries; write `mamba-report.md` with environment, evidence, artifacts, regression scope, and risks.",
+      "5. Re-run the path and affected positive, negative, and permission boundaries; write `mamba-report.md` from the observed final state with environment, evidence, artifacts, regression scope, and risks. Preserve authoritative no_repro, blocked/manual_test_required, failed validation, negative or permission results, and residual risks.",
       "",
       "Finish through the CLI with exactly one result: completed+fixed, completed+verified, completed+no_repro, completed+manual_test_required, or blocked+blockingReason. Never claim real testing in restricted mode. Child blocked/manual_test_required propagation is handled by the CLI. After a child finishes with fixed/verified/no_repro, inspect its parent; if that parent is still blocked because of this child, run `mancode workflow update <parentTaskId> --status in_progress` before restoring parent state at Step 6. Never auto-resume manual_test_required."
     ].join("\n")
@@ -16840,7 +17367,7 @@ var MODE_META = {
       "Step 6 \u2014 Run `workflow verify <taskId> init`, execute detected build/lint/typecheck/test and smoke checks, and record every required acceptance ID with reproducible evidence; automated passed/failed records include the command and exit code. Use require-manual when a foreground browser, device, or human judgment is necessary; stop for explicit user confirmation before confirm-manual. The CLI blocks Step 7 and review until all checks pass. Then write `review-scope.md` and initialize targeted or full review. An explicit user review skip uses `workflow review <taskId> skip --reason <reason>` at Step 6, never generic skipped metadata.",
       "Step 7 \u2014 Run one quality review limited to the changed diff and direct impact. Compare every changed path and behavior with confirmed requirements, acceptance IDs, and implementation scope; any unauthorized behavior, path outside include, or path matching exclude is a blocker. Findings require changed-line evidence and user impact, with at most three new findings. Record stable blocker IDs through `workflow review ... complete`; do not fix yet.",
       "Step 8 \u2014 Only full review runs the security/boundary reviewer. It must read Film #1, mark the same root cause duplicate, and stay within security, permissions, recovery, resources, and boundaries. A targeted review treats the second domain as not applicable; it is never recorded as a skipped step.",
-      "Step 9 \u2014 If open blockers exist, fix them in one remediation round and record resolved IDs through `workflow review ... remediate`; remediation invalidates all earlier acceptance evidence, so re-run and re-record every required check at Step 9 without re-running completed reviewers. Write `summary.md` and set completed only when verification and required review domains are complete and blockers are zero.",
+      "Step 9 \u2014 If open blockers exist, fix them in one remediation round and record resolved IDs through `workflow review ... remediate`; remediation invalidates all earlier acceptance evidence, so re-run and re-record every required check at Step 9 without re-running completed reviewers. Build `summary.md`, commit, and PR copy from the accepted target, authoritative baseline, observed final state, and task-owned diff; preserve excluded scope, failed verification, blockers, migration or rollback, and audit facts. Set completed only when verification and required review domains are complete and blockers are zero.",
       "",
       "Stop and return the read-only diagnostic `NEEDS_REALIGNMENT` with reason `MANCODE_REFRAME_REQUIRED` when new evidence invalidates the confirmed goal, semantic owner, source of truth, or acceptance; platform entries would produce different semantics; status/contract/policy/transition meaning must change; an adapter is stale, the writer is incompatible, an operation is unfinished, an active child/open handoff/active solo assignment exists; or the change exceeds the current requirements/plan scope. Preserve metadata, requirements, plan, ledgers, claims, and handoffs. Do not call generic workflow update, write blocked/currentStep/planning, archive files, release claims, or claim to be back at Step 2.",
       "",
@@ -16870,7 +17397,7 @@ var MODE_META = {
       "`workflow update --status in_progress`; never auto-resume manual_test_required.",
       "",
       "Read `.mancode/memory/prd.md`, `spec.md`, and `decisions.md`; append durable",
-      "decisions only after confirmed implementation. Write `handoff.md`. Never",
+      "decisions only after confirmed implementation. Build `handoff.md`, commit, and PR copy from the accepted target, authoritative baseline, observed final state, and task-owned diff; preserve conflicts, incomplete work, failed verification, migration or rollback, audit facts, and formal rejected or cancelled handoff states and reasons. Never",
       "overwrite teammate changes or commit/merge/push without explicit approval."
     ].join("\n")
   },
@@ -16977,6 +17504,8 @@ function renderPracticeRules() {
     "",
     "For every task, consider: why this change, what already exists, and what is the smallest useful diff?",
     "",
+    `- ${ACCEPTED_STATE_NARRATIVE_GUIDANCE}`,
+    "",
     "In solo mode, use the narrowest meaningful validation and one bounded self-check limited to the current diff. Do not start another reviewer or repeat the review.",
     "Recommend man and explain the trigger when platform entry/flow differs, the semantic owner or source of truth is unclear, status/contract/policy semantics change, scope/architecture/cost/acceptance crosses files or modules, or historical compatibility, migration, cross-platform, or team evidence is required. Auth, payment, sensitive data, deletion, public APIs, untrusted input, concurrency, and infrastructure remain hard-risk signals. Advice alone never changes mode, step, policy, or authority.",
     "While executing confirmed requirements/plan, new evidence that invalidates its goal, owner, source of truth, acceptance, or scope, or a stale adapter/incompatible writer/unfinished operation/active child/open handoff/active solo assignment, requires the read-only diagnostic `NEEDS_REALIGNMENT` with reason `MANCODE_REFRAME_REQUIRED`. Preserve metadata, requirements, plan, ledgers, claims, and handoffs; do not call generic workflow update, write blocked/currentStep/planning, archive files, release claims, or claim to be back at Step 2."
@@ -23357,14 +23886,14 @@ async function planLocalCacheRetention(root, localCacheDays, now) {
 async function applyContextCompaction(plan) {
   const deleted = [];
   for (const candidate of plan.candidates) {
-    await removeRegularFile(candidate.target);
-    deleted.push(candidate.target);
     for (const target of candidate.relatedTargets) {
       if (await regularFileExists(target)) {
         await removeRegularFile(target);
         deleted.push(target);
       }
     }
+    await removeRegularFile(candidate.target);
+    deleted.push(candidate.target);
   }
   return { ...plan, deleted };
 }
@@ -23446,6 +23975,7 @@ async function planOperationRetention(stores, now) {
   for (const store of stores) {
     const directory = operationDirectory(store);
     const entries = await readDirectoryOrEmpty(directory);
+    let recoveryEntries = null;
     for (const entry of entries) {
       if (!entry.endsWith(".json")) continue;
       const target = path42.join(directory, entry);
@@ -23462,7 +23992,12 @@ async function planOperationRetention(stores, now) {
           }
         }
       } else if (Date.parse(journal.updatedAt) < threshold) {
-        candidates.push(operationRetentionCandidate(store, journal, target));
+        recoveryEntries ??= await readDirectoryOrEmpty(
+          operationRecoveryDirectory(store)
+        );
+        candidates.push(
+          operationRetentionCandidate(store, journal, target, recoveryEntries)
+        );
       }
     }
   }
@@ -23495,15 +24030,38 @@ async function planGitRefWorkflowRepairRetention(projectRoot, now) {
   }
   return { candidates, protectedSessionIds, protectedTaskRefs };
 }
-function operationRetentionCandidate(store, journal, target) {
+function operationRetentionCandidate(store, journal, target, recoveryEntries) {
+  const relatedTargets = journal.recoveryPayloadDigest === void 0 ? [] : operationRecoveryTargetsForRetention(store, journal, recoveryEntries);
   return {
     kind: "terminal_operation",
     target,
     reason: `${journal.state} operation exceeds ${TERMINAL_JOURNAL_RETENTION_DAYS} day retention`,
     taskRef: null,
-    relatedTargets: journal.recoveryPayloadDigest === void 0 ? [] : [operationRecoveryPayloadPath(store, journal.operationId)]
+    relatedTargets
   };
 }
+function operationRecoveryTargetsForRetention(store, journal, recoveryEntries) {
+  if (journal.recoveryPayloadDigest === void 0) return [];
+  const directory = operationRecoveryDirectory(store);
+  const versionPrefix = `${journal.operationId}.`;
+  const discoveredVersions = recoveryEntries.filter((entry) => {
+    if (!entry.startsWith(versionPrefix)) return false;
+    return /^[a-f0-9]{64}\.json$/.test(entry.slice(versionPrefix.length));
+  }).map((entry) => path42.join(directory, entry));
+  return [
+    .../* @__PURE__ */ new Set([
+      operationRecoveryPayloadPath(store, journal.operationId),
+      operationRecoveryPayloadVersionPath(
+        store,
+        journal.operationId,
+        journal.recoveryPayloadDigest
+      ),
+      ...discoveredVersions
+    ])
+  ].sort(
+    (left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"))
+  );
+}
 function operationEntityKeys(journal) {
   return [
     ...journal.entityLocks,
@@ -26812,6 +27370,7 @@ function errorCode3(error, fallback) {
 }
 
 // src/commands/init.ts
+import { randomUUID } from "crypto";
 import { promises as fs4 } from "fs";
 import os from "os";
 import path55 from "path";
@@ -27532,6 +28091,54 @@ function createTerminalPrompter() {
       } finally {
         rl.close();
       }
+    },
+    async resolveUnsafeAdapterPaths({ locale, paths, writeThroughAvailable }) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        console.log(
+          locale === "zh-CN" ? "\n\u68C0\u6D4B\u5230\u9002\u914D\u5668\u76EE\u6807\u8DEF\u5F84\u662F\u7B26\u53F7\u94FE\u63A5\uFF1A" : "\nAdapter target paths are symbolic links:"
+        );
+        for (const item of paths) {
+          const detail = item.resolvedTo ? ` -> ${item.resolvedTo}` : "";
+          console.log(`  ${item.relative}${detail}`);
+        }
+        console.log(locale === "zh-CN" ? "1. \u9000\u51FA" : "1. Exit");
+        console.log(
+          locale === "zh-CN" ? "2. \u5C06\u7B26\u53F7\u94FE\u63A5\u66FF\u6362\u4E3A\u666E\u901A\u6587\u4EF6\uFF08\u4FDD\u7559\u539F\u5185\u5BB9\uFF09\u5E76\u7EE7\u7EED\u521D\u59CB\u5316" : "2. Replace the symbolic link(s) with regular file(s) (content preserved) and continue"
+        );
+        if (writeThroughAvailable) {
+          console.log(
+            locale === "zh-CN" ? "3. \u4FDD\u7559\u94FE\u63A5\uFF0Cmancode \u76F4\u63A5\u8BFB\u5199\u5176\u89E3\u6790\u76EE\u6807\uFF08CLAUDE.md -> AGENTS.md \u7EA6\u5B9A\uFF09" : "3. Keep the link(s); mancode reads and writes the resolved file (CLAUDE.md -> AGENTS.md convention)"
+          );
+        }
+        const answer = (await rl.question(
+          locale === "zh-CN" ? `\u9009\u62E9 [1/${writeThroughAvailable ? "2/3" : "2"}]: ` : `Choose [1/${writeThroughAvailable ? "2/3" : "2"}]: `
+        )).trim().toLowerCase();
+        if (answer === "2") return "replace";
+        if (answer === "3" && writeThroughAvailable) return "write-through";
+        return "exit";
+      } finally {
+        rl.close();
+      }
+    },
+    async resolveScratchMancodeTarget({ locale, entries }) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        console.log(
+          locale === "zh-CN" ? "\n`.mancode` \u5DF2\u5B58\u5728\uFF0C\u4F46\u53EA\u5305\u542B\u975E Continuity \u7684\u672C\u5730\u8349\u7A3F\uFF08\u53D1\u5E03\u5DE5\u4EF6\u3001\u5176\u4ED6\u5DE5\u5177\u5907\u4EFD\uFF09\uFF1A" : "\n`.mancode` exists but contains only non-Continuity local scratch (release artifacts, other-tool backups):"
+        );
+        for (const entry of entries) console.log(`  .mancode/${entry}`);
+        console.log(locale === "zh-CN" ? "1. \u9000\u51FA" : "1. Exit");
+        console.log(
+          locale === "zh-CN" ? "2. \u628A `.mancode` \u79FB\u5230\u4E00\u8FB9\uFF08\u5185\u5BB9\u4FDD\u7559\uFF09\u5E76\u7EE7\u7EED\u521D\u59CB\u5316\uFF1B\u6210\u529F\u540E\u539F\u6837\u5F52\u4F4D\u5230 `.mancode/local/`" : "2. Move `.mancode` aside (content preserved) and continue; it is restored under `.mancode/local/` after success"
+        );
+        const answer = (await rl.question(
+          locale === "zh-CN" ? "\u9009\u62E9 [1/2]: " : "Choose [1/2]: "
+        )).trim().toLowerCase();
+        return answer === "2" ? "relocate" : "exit";
+      } finally {
+        rl.close();
+      }
     }
   };
 }
@@ -28449,12 +29056,12 @@ function parseAdapterPlans(value) {
     assertRecord(candidate, "greenfield initialization adapter plan");
     assertKnownKeys(
       candidate,
-      ["target", "beforeContent", "targetContent"],
+      ["target", "beforeContent", "targetContent", "resolvedTarget"],
       "greenfield initialization adapter plan"
     );
     if (typeof candidate.target !== "string" || !V3_ADAPTER_FILE_TARGETS.includes(
       candidate.target
-    ) || seen.has(candidate.target) || candidate.beforeContent !== null && typeof candidate.beforeContent !== "string" || typeof candidate.targetContent !== "string" || !candidate.targetContent.trim()) {
+    ) || seen.has(candidate.target) || candidate.beforeContent !== null && typeof candidate.beforeContent !== "string" || typeof candidate.targetContent !== "string" || !candidate.targetContent.trim() || candidate.resolvedTarget !== void 0 && (typeof candidate.resolvedTarget !== "string" || !candidate.resolvedTarget.trim() || path54.isAbsolute(candidate.resolvedTarget) || candidate.resolvedTarget.split(/[\\/]/).includes(".."))) {
       throw new Error(
         "greenfield initialization journal adapterPlans is invalid"
       );
@@ -28464,7 +29071,8 @@ function parseAdapterPlans(value) {
     return {
       target,
       beforeContent: candidate.beforeContent,
-      targetContent: candidate.targetContent
+      targetContent: candidate.targetContent,
+      resolvedTarget: candidate.resolvedTarget
     };
   });
 }
@@ -29138,7 +29746,16 @@ async function initializeV3(rootDir, options) {
     console.error("   Use one or more supported platform names, or all.");
     return EXIT_INIT_FAILED;
   }
+  let scratchBackup = null;
   try {
+    if (!existingV3) {
+      const unsafeExit = await resolveUnsafeInitAdapterPaths(
+        rootDir,
+        options,
+        selectedPlatforms
+      );
+      if (unsafeExit !== null) return unsafeExit;
+    }
     if (existingV3 && selectedPlatforms.some((platform) => !registeredAdapters.has(platform))) {
       throw new Error(
         "MANCODE_ADAPTER_REGISTRATION_REQUIRED: run `mancode adapter upgrade --platform <platform> --dry-run`, then confirm that operation with an active session."
@@ -29161,6 +29778,9 @@ async function initializeV3(rootDir, options) {
       console.log("\u2139\uFE0F  mancode is already initialized.");
       return EXIT_ALREADY_INITIALIZED;
     }
+    const scratch = await resolveScratchMancodeTarget(rootDir, options);
+    if (scratch.exit !== null) return scratch.exit;
+    scratchBackup = scratch.backupPath;
     const result2 = await initializeV3Project({
       projectRoot: rootDir,
       managedAdapters: Object.fromEntries(
@@ -29171,6 +29791,9 @@ async function initializeV3(rootDir, options) {
     console.log("\u2713  Initialized mancode project.");
     console.log(`   workspace: ${result2.runtime.workspaceId}`);
     console.log(`   operation: ${result2.journal.operationId}`);
+    if (scratchBackup !== null) {
+      await restoreScratchBackup(rootDir, scratchBackup);
+    }
     if (options.team !== void 0) {
       console.log(
         `   team policy: ${options.team ? "on (--team)" : "off (--no-team)"}`
@@ -29185,16 +29808,157 @@ async function initializeV3(rootDir, options) {
     }
     return EXIT_OK2;
   } catch (error) {
+    if (scratchBackup !== null) {
+      console.error(
+        `   Previous .mancode scratch was preserved at ${path55.relative(rootDir, scratchBackup)}.`
+      );
+    }
     printV3InitError(error);
     return EXIT_INIT_FAILED;
   }
 }
+async function resolveUnsafeInitAdapterPaths(rootDir, options, selectedPlatforms) {
+  const prompter = options.prompter ?? (options.interactive ? createTerminalPrompter() : null);
+  if (!prompter) return null;
+  const locale = detectInitLocale(options.lang) ?? "en";
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const platform of selectedPlatforms) {
+    for (const entry of await inspectUnsafeV3AdapterPaths(rootDir, platform)) {
+      if (seen.has(entry.target)) continue;
+      seen.add(entry.target);
+      found.push(entry);
+    }
+  }
+  const fixable = found.filter(
+    (entry) => entry.kind === "symlink" && entry.finalTarget
+  );
+  if (fixable.length === 0) return null;
+  const writeThroughAvailable = found.length > 0 && (await Promise.all(
+    found.map(
+      (entry) => writeThroughResolvedPath(path55.resolve(rootDir), entry.target)
+    )
+  )).every((resolved) => resolved !== null);
+  const choice = await prompter.resolveUnsafeAdapterPaths({
+    locale,
+    paths: found.map(({ relative, resolvedTo }) => ({ relative, resolvedTo })),
+    writeThroughAvailable
+  });
+  if (choice === "exit") {
+    console.log(
+      locale === "zh-CN" ? "\u5DF2\u53D6\u6D88\u521D\u59CB\u5316\u3002" : "Initialization cancelled."
+    );
+    return EXIT_USER_CANCEL;
+  }
+  if (choice === "write-through") {
+    console.log(
+      locale === "zh-CN" ? "\u2139\uFE0F  \u4FDD\u7559\u7B26\u53F7\u94FE\u63A5\uFF0Cmancode \u5C06\u8BFB\u5199\u5176\u89E3\u6790\u76EE\u6807\u3002" : "\u2139\uFE0F  Keeping the symbolic link(s); mancode reads and writes the resolved target."
+    );
+    return null;
+  }
+  await replaceUnsafeV3AdapterSymlinks(fixable);
+  return null;
+}
+var SCRATCH_BACKUP_PREFIX = ".mancode.preinit-scratch-";
+async function resolveScratchMancodeTarget(rootDir, options) {
+  const inspection = await inspectMancodeLayout(rootDir);
+  if (!inspection.v3ScratchOnly) {
+    return { exit: null, backupPath: null };
+  }
+  const mancodeRoot = path55.join(rootDir, ".mancode");
+  if (inspection.v3TargetEntries.length === 0) {
+    await fs4.rmdir(mancodeRoot);
+    console.log(
+      "\u2139\uFE0F  Removed an empty .mancode directory before initialization."
+    );
+    return { exit: null, backupPath: null };
+  }
+  const prompter = options.prompter ?? (options.interactive ? createTerminalPrompter() : null);
+  if (!prompter) {
+    throw new Error("MANCODE_V3_SCRATCH_TARGET_REQUIRES_CHOICE");
+  }
+  const locale = detectInitLocale(options.lang) ?? "en";
+  const choice = prompter.resolveScratchMancodeTarget ? await prompter.resolveScratchMancodeTarget({
+    locale,
+    entries: inspection.v3TargetEntries
+  }) : "exit";
+  if (choice !== "relocate") {
+    console.log(
+      locale === "zh-CN" ? "\u5DF2\u53D6\u6D88\u521D\u59CB\u5316\u3002" : "Initialization cancelled."
+    );
+    return { exit: EXIT_USER_CANCEL, backupPath: null };
+  }
+  const backupPath = path55.join(
+    rootDir,
+    `${SCRATCH_BACKUP_PREFIX}${randomUUID()}`
+  );
+  await fs4.rename(mancodeRoot, backupPath);
+  console.log(
+    `\u2139\uFE0F  Moved non-Continuity .mancode scratch aside: ${path55.relative(rootDir, backupPath)}`
+  );
+  return { exit: null, backupPath };
+}
+async function restoreScratchBackup(rootDir, backupPath) {
+  const localTarget = path55.join(rootDir, ".mancode", "local");
+  const leftover = path55.relative(rootDir, backupPath);
+  try {
+    await fs4.mkdir(localTarget, { recursive: true });
+    const entries = await fs4.readdir(backupPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const source = path55.join(backupPath, entry.name);
+      if (entry.isDirectory() && entry.name === "local") {
+        for (const child of await fs4.readdir(source)) {
+          const destination = path55.join(localTarget, child);
+          if (await pathExists6(destination)) continue;
+          await fs4.rename(path55.join(source, child), destination);
+        }
+      } else {
+        const preinitScratch = path55.join(localTarget, "preinit-scratch");
+        await fs4.mkdir(preinitScratch, { recursive: true });
+        const destination = path55.join(preinitScratch, entry.name);
+        if (await pathExists6(destination)) continue;
+        await fs4.rename(source, destination);
+      }
+    }
+    await fs4.rmdir(path55.join(backupPath, "local")).catch(() => void 0);
+    await fs4.rmdir(backupPath).catch(() => void 0);
+    if (await pathExists6(backupPath)) {
+      console.warn(
+        `\u26A0\uFE0F  Could not fully restore previous scratch; it remains at ${leftover}.`
+      );
+    } else {
+      console.log(
+        "\u2139\uFE0F  Restored previous .mancode scratch into .mancode/local/."
+      );
+    }
+  } catch {
+    console.warn(
+      `\u26A0\uFE0F  Failed to restore previous .mancode scratch; it remains at ${leftover}.`
+    );
+  }
+}
 function printV3InitError(error) {
   const message = error instanceof Error ? error.message : "mancode initialization failed";
   console.error(`\u2717  ${message}`);
   if (message === "MANCODE_LEGACY_AUTHORITY_PRESENT") {
     console.error("   Run `mancode migrate context --dry-run` instead.");
   }
+  if (message === "MANCODE_V3_TARGET_EXISTS") {
+    console.error(
+      "   `.mancode` already exists with Continuity authority content; refusing to overwrite it."
+    );
+    console.error(
+      "   For an initialized project, use `mancode adapter status` / `mancode adapter upgrade`; otherwise inspect `.mancode` first."
+    );
+  }
+  if (message === "MANCODE_V3_SCRATCH_TARGET_REQUIRES_CHOICE") {
+    console.error(
+      "   `.mancode` holds only non-Continuity scratch (release artifacts, other-tool backups)."
+    );
+    console.error(
+      "   Run init interactively to move it aside, or remove/rename the directory yourself."
+    );
+  }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
   const configPath = path55.join(mancodeDir, "config.json");
@@ -29318,15 +30082,17 @@ async function validateV3CliProjectBoundary(rootDir, options, locale, legacyInit
   const isGitRepo = await pathExists6(path55.join(rootDir, ".git"));
   const hasEvidence = await hasProjectEvidence(rootDir);
   if (isGitRepo || hasEvidence) return null;
-  const v3Initialized = await pathExists6(
-    path55.join(rootDir, ".mancode", "schema.json")
-  );
-  const legacyAuthorityPresent = legacyInitialized || (await scanLegacyAuthority(rootDir)).authorityPresent;
-  if (!genericSafety.ok && !((legacyAuthorityPresent || v3Initialized) && genericSafety.reason === "nonempty")) {
+  const inspection = await inspectMancodeLayout(rootDir);
+  const v3Initialized = inspection.v3AuthorityPathsPresent.includes("schema.json");
+  const legacyAuthorityPresent = legacyInitialized || inspection.legacy.authorityPresent;
+  const scratchOnlyMancode = inspection.v3ScratchOnly;
+  if (!genericSafety.ok && !((legacyAuthorityPresent || v3Initialized || scratchOnlyMancode) && genericSafety.reason === "nonempty")) {
     printNotProjectDirectory(rootDir, locale, genericSafety.reason);
     return EXIT_NOT_A_PROJECT_DIR;
   }
-  if (legacyAuthorityPresent || v3Initialized) return null;
+  if (legacyAuthorityPresent || v3Initialized || scratchOnlyMancode) {
+    return null;
+  }
   const prompter = options.prompter ?? (options.interactive ? createTerminalPrompter() : null);
   const confirmed = options.empty || options.yes ? true : prompter ? await prompter.confirmGenericProject({ rootDir, locale }) : false;
   if (!confirmed) {
@@ -31243,8 +32009,19 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
       EXIT_V3_INVALID_ARGUMENT
     );
   }
+  if (options.replacementCheckpointId !== void 0 && !isUlid(options.replacementCheckpointId)) {
+    return printV3Error(
+      options.json,
+      "MANCODE_REPLACEMENT_CHECKPOINT_ID_INVALID",
+      "replacement checkpoint ID must be a canonical ULID.",
+      EXIT_V3_INVALID_ARGUMENT
+    );
+  }
   try {
     assertUlid(operationId, "operationId");
+    if (options.replacementCheckpointId !== void 0) {
+      assertUlid(options.replacementCheckpointId, "replacementCheckpointId");
+    }
     const project = await readV3CommandProject(rootDir);
     const session = await resolveV3CommandSession(project, options);
     const result2 = await executeOperationRecovery({
@@ -31252,7 +32029,8 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
       operationId,
       actorId: session.actorId,
       sessionId: session.sessionId,
-      mode
+      mode,
+      replacementCheckpointId: options.replacementCheckpointId
     });
     return printV3Result(options.json, { schemaVersion: 1, ...result2 });
   } catch (error) {
@@ -31804,7 +32582,7 @@ async function projectUpgrade(rootDir, options) {
 }
 
 // src/commands/refresh-project.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { promises as fs7 } from "fs";
 import path62 from "path";
 import process9 from "process";
@@ -31980,7 +32758,7 @@ async function readOptionalText(filePath) {
 function temporaryPath(filePath) {
   return path62.join(
     path62.dirname(filePath),
-    `.${path62.basename(filePath)}.${process9.pid}.${randomUUID()}.tmp`
+    `.${path62.basename(filePath)}.${process9.pid}.${randomUUID2()}.tmp`
   );
 }
 async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
@@ -41784,7 +42562,8 @@ var WORKFLOW_SUBCOMMANDS = [
   "checkpoint",
   "child",
   "promote",
-  "handoff"
+  "handoff",
+  "delivery"
 ];
 var WORKFLOW_SUBCOMMAND_SET = new Set(
   WORKFLOW_SUBCOMMANDS
@@ -41792,8 +42571,8 @@ var WORKFLOW_SUBCOMMAND_SET = new Set(
 var CONTINUITY_COMPATIBILITY_SUBCOMMANDS = /* @__PURE__ */ new Set(["clean"]);
 
 // src/commands/workflow.ts
-import { access as access6, readFile as readFile48, rm as rm24, writeFile as writeFile51 } from "fs/promises";
-import path70 from "path";
+import { access as access6, readFile as readFile51, rm as rm26, writeFile as writeFile53 } from "fs/promises";
+import path74 from "path";
 
 // src/context/child-result-merge.ts
 async function mergeV3ChildResult(input) {
@@ -42121,8 +42900,746 @@ function assertPositiveRevision6(value, label) {
   }
 }
 
+// src/context/man-delivery-runtime.ts
+import { execFile as execFileCallback7 } from "child_process";
+import { createHash as createHash11, randomUUID as randomUUID4 } from "crypto";
+import {
+  lstat as lstat28,
+  readFile as readFile48,
+  readlink as readlink2,
+  realpath as realpath4,
+  rm as rm24,
+  writeFile as writeFile51
+} from "fs/promises";
+import path71 from "path";
+import { promisify as promisify9 } from "util";
+
+// src/context/man-delivery-plan.ts
+import path69 from "path";
+var SOURCE_PREFIX = "<!-- mancode:delivery-plan ";
+var MARKERS = [
+  "<!-- mancode:plan-baseline:start -->",
+  "<!-- mancode:plan-baseline:end -->",
+  "<!-- mancode:delivery-record:start -->",
+  "<!-- mancode:delivery-record:end -->"
+];
+function parseManPlanDocument(document) {
+  const markers = unfencedLines(document).filter(
+    (line) => MARKERS.includes(line.marker)
+  );
+  if (markers.length !== 4 || markers.some((value, index) => value.marker !== MARKERS[index])) {
+    throw new Error("MANCODE_MAN_PLAN_MARKERS_INVALID");
+  }
+  const [baselineStart, baselineEnd, recordStart, recordEnd] = markers;
+  if (!baselineStart || !baselineEnd || !recordStart || !recordEnd) {
+    throw new Error("MANCODE_MAN_PLAN_MARKERS_INVALID");
+  }
+  const baseline = document.slice(baselineStart.end, baselineEnd.start).trim();
+  if (!baseline) throw new Error("MANCODE_MAN_PLAN_BASELINE_REQUIRED");
+  return {
+    baseline,
+    record: document.slice(recordStart.end, recordEnd.start).trim(),
+    recordStart: recordStart.end,
+    recordEnd: recordEnd.start
+  };
+}
+function manProgressTaskId(baseline) {
+  const bindings = unfencedLines(baseline).map(
+    (line) => /^<!-- mancode:progress-task ([a-zA-Z0-9:_-]+) -->$/.exec(
+      line.marker
+    )?.[1]
+  ).filter((id) => id !== void 0);
+  if (bindings.length > 1)
+    throw new Error("ambiguous plan progress task binding");
+  return bindings[0] ?? null;
+}
+function unfencedLines(document) {
+  let offset = 0;
+  let fence = null;
+  const markers = [];
+  for (const line of document.match(/[^\n]*(?:\n|$)/g) ?? []) {
+    const text = line.replace(/\r?\n$/, "");
+    const delimiter = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(text);
+    if (fence !== null) {
+      if (delimiter && delimiter[1]?.[0] === fence.character && delimiter[1].length >= fence.length && delimiter[2]?.trim() === "")
+        fence = null;
+    } else if (delimiter?.[1]) {
+      fence = {
+        character: delimiter[1][0],
+        length: delimiter[1].length
+      };
+    } else {
+      markers.push({ marker: text, start: offset, end: offset + line.length });
+    }
+    offset += line.length;
+  }
+  return markers;
+}
+function replaceManDeliveryRecord(document, record) {
+  const parsed = parseManPlanDocument(document);
+  const next = `${document.slice(0, parsed.recordStart)}${record.trim()}
+${document.slice(parsed.recordEnd)}`;
+  const checked = parseManPlanDocument(next);
+  if (checked.baseline !== parsed.baseline)
+    throw new Error("MANCODE_MAN_PLAN_BASELINE_CHANGED");
+  return next;
+}
+function assertManPlanPath(file) {
+  if (!file || path69.posix.isAbsolute(file) || /[\\\r\n\0<>:]/.test(file) || file.split("/").some((part) => !part || part === "." || part === "..") || /^(?:\.git|\.mancode|架构|项目接口)(?:\/|$)/.test(file) || !file.endsWith(".md") || !file.includes("/"))
+    throw new Error("MANCODE_MAN_PLAN_PATH_INVALID");
+}
+function parseSource(value) {
+  assertRecord(value, "man plan source");
+  assertKnownKeys(value, ["version", "path", "baseHead"], "man plan source");
+  if (value.version !== 1 || typeof value.path !== "string") {
+    throw new Error("MANCODE_MAN_PLAN_SOURCE_INVALID");
+  }
+  assertManPlanPath(value.path);
+  if (value.baseHead !== null && (typeof value.baseHead !== "string" || !/^[a-f0-9]{40,64}$/.test(value.baseHead))) {
+    throw new Error("MANCODE_MAN_PLAN_BASE_INVALID");
+  }
+  return { version: 1, path: value.path, baseHead: value.baseHead };
+}
+function compileManDeliveryPlan(source, document) {
+  return `${SOURCE_PREFIX}${JSON.stringify(parseSource(source))} -->
+${parseManPlanDocument(document).baseline}`;
+}
+function parseManDeliveryPlan(plan) {
+  if (!plan.startsWith(SOURCE_PREFIX)) return null;
+  const end = plan.indexOf(" -->\n");
+  if (end < 0) throw new Error("MANCODE_MAN_PLAN_SOURCE_INVALID");
+  const source = parseSource(JSON.parse(plan.slice(SOURCE_PREFIX.length, end)));
+  const baseline = plan.slice(end + " -->\n".length);
+  if (!baseline.trim()) throw new Error("MANCODE_MAN_PLAN_BASELINE_REQUIRED");
+  return { source, baseline };
+}
+
+// src/context/man-progress.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { lstat as lstat27, readFile as readFile47, realpath as realpath3, rm as rm23, writeFile as writeFile50 } from "fs/promises";
+import path70 from "path";
+var START = '<script type="application/json" id="mancode-progress-data">';
+var END = "</script>";
+function updateManProgressHtml(html, taskId, status2, reason) {
+  if (html.split(START).length !== 2 || [...html.matchAll(/\bid\s*=\s*["']mancode-progress-data["']/gi)].length !== 1)
+    throw new Error("progress data block is missing or ambiguous");
+  const tokens = [
+    ...html.matchAll(
+      /<!--[\s\S]*?-->|<(script|style|textarea|title|xmp|iframe|noembed|noframes|noscript)\b(?:[^"'<>]|"[^"]*"|'[^']*')*>[\s\S]*?<\/\1\s*>|<(?:[^"'<>]|"[^"]*"|'[^']*')*>/gi
+    )
+  ];
+  if (!tokens.some(
+    (token) => token.index === html.indexOf(START) && token[0].startsWith(START)
+  ))
+    throw new Error("progress data must be an active standalone script block");
+  const start = html.indexOf(START) + START.length;
+  const end = html.indexOf(END, start);
+  if (end < start) throw new Error("progress data block is unterminated");
+  const data = JSON.parse(html.slice(start, end));
+  if (!data || typeof data !== "object" || !("schemaVersion" in data) || data.schemaVersion !== 1 || !("tasks" in data) || !Array.isArray(data.tasks))
+    throw new Error("unsupported progress data");
+  const matches = data.tasks.filter(
+    (item) => item && typeof item === "object" && item.taskId === taskId
+  );
+  if (matches.length !== 1)
+    throw new Error("progress taskId is missing or ambiguous");
+  Object.assign(matches[0], { status: status2, reason });
+  return `${html.slice(0, start)}
+${JSON.stringify(data).replaceAll("<", "\\u003c")}
+${html.slice(end)}`;
+}
+async function syncManProgressPage(root, taskId, status2, reason, allowed) {
+  const target = path70.join(root, "\u9879\u76EE\u8FDB\u5EA6.html");
+  let temporary;
+  try {
+    const stat5 = await lstat27(target);
+    if (!allowed)
+      return {
+        status: "manual_sync",
+        reason: "progress page is outside the approved write scope"
+      };
+    if (!stat5.isFile() || await realpath3(target) !== path70.join(await realpath3(root), "\u9879\u76EE\u8FDB\u5EA6.html"))
+      return {
+        status: "manual_sync",
+        reason: "progress page must be a regular project file"
+      };
+    const previous = await readFile47(target, "utf8");
+    const next = updateManProgressHtml(previous, taskId, status2, reason);
+    if (next !== previous) {
+      temporary = `${target}.${randomUUID3()}.tmp`;
+      await writeFile50(temporary, next, { flag: "wx", mode: stat5.mode });
+      if (await readFile47(target, "utf8") !== previous)
+        throw new Error("progress page changed during sync");
+      await replaceFileAtomically(temporary, target);
+    }
+    return { status: "synced" };
+  } catch (error) {
+    if (error.code === "ENOENT" && !temporary)
+      return { status: "absent" };
+    return {
+      status: "manual_sync",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (temporary) await rm23(temporary, { force: true });
+  }
+}
+
+// src/context/man-delivery-runtime.ts
+var execFile10 = promisify9(execFileCallback7);
+var MAN_DELIVERY_POLICY = 3;
+function isManDelivery(metadata) {
+  return metadata.workflowMode === "man" && metadata.governance.policyVersions.planning === MAN_DELIVERY_POLICY && metadata.governance.planDecision !== "solo_handoff";
+}
+async function manGit(root, args) {
+  return (await execFile10("git", args, {
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024
+  })).stdout;
+}
+async function hasGitWorktree(root) {
+  try {
+    return (await manGit(root, ["rev-parse", "--is-inside-work-tree"])).trim() === "true";
+  } catch (error) {
+    if (error.code === 128 && String(error.stderr).includes(
+      "not a git repository"
+    ))
+      return false;
+    throw error;
+  }
+}
+async function readManPlanFile(root, file) {
+  assertManPlanPath(file);
+  const resolvedRoot = await realpath4(root);
+  const resolved = await realpath4(path71.join(root, file));
+  const relative = path71.relative(resolvedRoot, resolved).split(path71.sep).join("/");
+  assertManPlanPath(relative);
+  if (relative !== file) throw new Error("MANCODE_MAN_PLAN_USE_REAL_PATH");
+  if (!(await lstat28(resolved)).isFile())
+    throw new Error("MANCODE_MAN_PLAN_FILE_REQUIRED");
+  if (!await hasGitWorktree(root)) return readFile48(resolved, "utf8");
+  try {
+    await manGit(root, ["check-ignore", "--no-index", "-q", "--", relative]);
+  } catch (error) {
+    if (error.code === 1)
+      return readFile48(resolved, "utf8");
+    throw error;
+  }
+  throw new Error("MANCODE_MAN_PLAN_IGNORED");
+}
+async function bindManPlan(root, file, document, previous) {
+  if (await readManPlanFile(root, file) !== document)
+    throw new Error("MANCODE_MAN_PLAN_FILE_CHANGED");
+  const existing = previous === null ? null : parseManDeliveryPlan(previous);
+  return compileManDeliveryPlan(
+    {
+      version: 1,
+      path: file,
+      baseHead: existing ? existing.source.baseHead : await readCheckoutCodeHead(root)
+    },
+    document
+  );
+}
+async function readBoundManPlan(root, task) {
+  const plan = task.plan && parseManDeliveryPlan(task.plan.content);
+  if (!plan) throw new Error("MANCODE_MAN_PLAN_SOURCE_REQUIRED");
+  const document = await readManPlanFile(root, plan.source.path);
+  if (parseManPlanDocument(document).baseline !== plan.baseline)
+    throw new Error("MANCODE_MAN_PLAN_BASELINE_CHANGED");
+  return { ...plan, document };
+}
+async function captureManSubject(root, task) {
+  const bound = await readBoundManPlan(root, task);
+  if (!await hasGitWorktree(root))
+    throw new Error(
+      "MANCODE_MAN_DELIVERY_GIT_REQUIRED: planning is available; versioned delivery is not"
+    );
+  const files = [
+    ...new Set(
+      (await manGit(root, [
+        "ls-files",
+        "-z",
+        "--cached",
+        "--others",
+        "--exclude-standard"
+      ])).split("\0").filter(Boolean)
+    )
+  ].sort();
+  const hashes = [];
+  for (const file of files) {
+    if (file.startsWith(".mancode/") || file === "\u9879\u76EE\u8FDB\u5EA6.html") continue;
+    const absolute = path71.join(root, file);
+    let contents;
+    let kind = "deleted";
+    try {
+      const stat5 = await lstat28(absolute);
+      kind = `file:${stat5.mode & 73}`;
+      if (stat5.isSymbolicLink()) {
+        kind = "symlink";
+        const target = path71.relative(
+          await realpath4(root),
+          await realpath4(absolute)
+        );
+        if (target.startsWith(`..${path71.sep}`) || path71.isAbsolute(target))
+          throw new Error("MANCODE_MAN_EXTERNAL_DEPENDENCY_UNVERIFIED");
+        contents = `${await readlink2(absolute)}\0${await readFile48(absolute, "base64")}`;
+      } else if (stat5.isFile()) {
+        contents = file === bound.source.path ? bound.baseline : await readFile48(absolute);
+      } else throw new Error("MANCODE_MAN_CONTENT_NODE_UNSUPPORTED");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      kind = "deleted";
+      contents = "<deleted>";
+    }
+    hashes.push([
+      file,
+      createHash11("sha256").update(`${kind}\0`).update(contents).digest("hex")
+    ]);
+  }
+  return {
+    contentDigest: digestCanonicalJson(hashes),
+    environment: `${process.platform}/${process.arch};node=${process.version}`
+  };
+}
+function assertManReviewCoverage(task, review, subject) {
+  if (!isManDelivery(task.metadata)) {
+    if (review.delivery) throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
+    return;
+  }
+  for (const blocker of task.review.blockers.filter(
+    (item) => item.status === "open"
+  )) {
+    if (!review.blockers.some((item) => item.blockerId === blocker.blockerId))
+      throw new Error(
+        `MANCODE_MAN_REVIEW_FINDING_DROPPED: ${blocker.displayId}`
+      );
+  }
+  if (review.status === "skipped") return;
+  if (!review.delivery && review.status !== "passed") return;
+  if (!review.delivery || review.delivery.subject.contentDigest !== subject.contentDigest || review.delivery.subject.environment !== subject.environment) {
+    throw new Error("MANCODE_MAN_REVIEW_SUBJECT_STALE");
+  }
+  const criteria = task.requirements.acceptanceCriteria;
+  if (review.delivery.coverage.some(
+    (row) => !criteria.some((criterion) => criterion.displayId === row.acceptanceId)
+  ))
+    throw new Error("MANCODE_MAN_REVIEW_UNKNOWN_ACCEPTANCE");
+  if (review.status !== "passed") return;
+  for (const criterion of criteria.filter((item) => item.required)) {
+    if (!review.delivery.coverage.some(
+      (row) => row.acceptanceId === criterion.displayId && row.status === "met"
+    )) {
+      throw new Error(
+        `MANCODE_MAN_REVIEW_ACCEPTANCE_MISSING: ${criterion.displayId}`
+      );
+    }
+  }
+}
+function assertManVerificationSubjects(task, verification, subject) {
+  for (const check of verification.checks) {
+    for (const evidence of [check.automated, check.manual]) {
+      if (!isManDelivery(task.metadata)) {
+        if (evidence?.subject)
+          throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
+      } else if (evidence?.status === "passed" && (evidence.subject?.contentDigest !== subject.contentDigest || evidence.subject.environment !== subject.environment)) {
+        throw new Error(
+          `MANCODE_MAN_VERIFICATION_SUBJECT_STALE: ${check.displayId}`
+        );
+      }
+    }
+  }
+}
+function manScopeContains(metadata, file) {
+  return metadata.implementationScope.include.some(
+    (include) => path71.matchesGlob(file, include)
+  ) && !metadata.implementationScope.exclude.some(
+    (exclude) => path71.matchesGlob(file, exclude)
+  );
+}
+function assertManPlanInScope(metadata, file) {
+  if (!manScopeContains(metadata, file))
+    throw new Error(
+      `MANCODE_MAN_PLAN_OUTSIDE_SCOPE: ${file} is not covered by implementationScope.include; add that exact repo-relative path or a covering glob`
+    );
+}
+function manDeliveryFinalization(task, subject, recordCurrent, outsideScope, outsideScopeDirty, pendingCommit) {
+  const blockers = [];
+  if (task.metadata.governance.planDecision !== "governed_execution")
+    blockers.push({
+      code: "plan_execution_required",
+      status: task.metadata.governance.planDecision ?? "unconfirmed",
+      nextAction: "Confirm the bound plan for governed execution."
+    });
+  const reviewSubjectCurrent = task.review.status === "skipped" || task.review.status === "passed" && task.review.delivery?.subject.contentDigest === subject.contentDigest && task.review.delivery?.subject.environment === subject.environment;
+  if (!reviewSubjectCurrent)
+    blockers.push({
+      code: "review_incomplete",
+      status: task.review.status === "passed" ? "stale" : task.review.status,
+      nextAction: task.review.status === "blocked" ? "Fix the recorded findings, verify the changed module, and submit the targeted review result." : "Complete one module review for the current subject and apply its review ledger."
+    });
+  const verification = assessManVerification(task, subject);
+  if (verification.status !== "passed")
+    blockers.push({
+      code: "verification_incomplete",
+      status: verification.status,
+      nextAction: verification.nextAction
+    });
+  if (!recordCurrent)
+    blockers.push({
+      code: "delivery_record_stale",
+      status: "stale",
+      nextAction: "Sync the delivery record after the latest evidence change."
+    });
+  if (outsideScope.length)
+    blockers.push({
+      code: "committed_outside_scope",
+      status: "blocked",
+      nextAction: "Remove the unrelated committed changes or obtain an approved scope realignment.",
+      files: outsideScope
+    });
+  if (outsideScopeDirty.length)
+    blockers.push({
+      code: "uncommitted_outside_scope",
+      status: "blocked",
+      nextAction: "Move, stash, or separately commit unrelated working-tree changes before recording final delivery evidence; do not add them to this task commit.",
+      files: outsideScopeDirty
+    });
+  if (pendingCommit.length)
+    blockers.push({
+      code: "uncommitted_changes",
+      status: "pending",
+      nextAction: "Commit only the task-owned versionable changes.",
+      files: pendingCommit
+    });
+  return {
+    status: blockers.length ? "incomplete" : "ready",
+    blockers
+  };
+}
+function manInspectionFailureFinalization(error) {
+  const diagnostic = error instanceof Error ? error.message : String(error);
+  let nextAction = "Resolve the reported inspection diagnostic, then run delivery inspect again.";
+  if (diagnostic.includes("MANCODE_MAN_PLAN_BASELINE_CHANGED")) {
+    nextAction = "Restore the approved plan baseline or explicitly reframe the task before inspecting delivery again.";
+  } else if (diagnostic.includes("MANCODE_MAN_PLAN_IGNORED")) {
+    nextAction = "Remove the ignore rule for the approved plan file, then inspect delivery again.";
+  } else if (diagnostic.includes("MANCODE_MAN_DELIVERY_GIT_REQUIRED")) {
+    nextAction = "Use a Git worktree for versioned delivery, then inspect the task again.";
+  } else if (diagnostic.includes("MANCODE_MAN_CONTENT_NODE_UNSUPPORTED")) {
+    nextAction = "Remove the unsupported repository content node from the delivery subject or use a supported versioned file, then inspect again.";
+  }
+  return {
+    status: "incomplete",
+    blockers: [
+      {
+        code: "inspection_failed",
+        status: "failed",
+        nextAction,
+        diagnostic
+      }
+    ]
+  };
+}
+function assessManVerification(task, subject) {
+  const missingConfiguredCriteria = task.requirements.acceptanceCriteria.filter(
+    (criterion) => criterion.required && criterion.verificationSurfaces === void 0
+  ).map((criterion) => criterion.displayId);
+  if (missingConfiguredCriteria.length) {
+    return {
+      status: "surface_requirement_missing",
+      nextAction: `Reframe or re-finalize requirements with verificationSurfaces for ${missingConfiguredCriteria.join(", ")}.`
+    };
+  }
+  if (task.verification.status !== "passed") {
+    return {
+      status: task.verification.status,
+      nextAction: "Run or confirm the missing acceptance evidence against the current subject."
+    };
+  }
+  const criteria = new Map(
+    task.requirements.acceptanceCriteria.map((criterion) => [
+      criterion.criterionId,
+      criterion
+    ])
+  );
+  const missingRequirements = [];
+  const missingActual = [];
+  const stale = [];
+  const mismatches = [];
+  for (const check of task.verification.checks) {
+    if (!check.required) continue;
+    const criterion = criteria.get(check.criterionId);
+    for (const slot of ["automated", "manual"]) {
+      const evidence = check[slot];
+      if (evidence?.status !== "passed") continue;
+      const expected = criterion?.verificationSurfaces?.[slot];
+      const label = `${check.displayId}:${slot}`;
+      if (!expected) {
+        missingRequirements.push(label);
+        continue;
+      }
+      if (!evidence.surface) {
+        missingActual.push(label);
+        continue;
+      }
+      if (subject !== void 0 && (evidence.subject?.contentDigest !== subject.contentDigest || evidence.subject.environment !== subject.environment)) {
+        stale.push(label);
+        continue;
+      }
+      if (evidence.surface !== expected) {
+        mismatches.push(
+          `${label} requires ${expected}, recorded ${evidence.surface}`
+        );
+      }
+    }
+  }
+  if (missingRequirements.length) {
+    return {
+      status: "surface_requirement_missing",
+      nextAction: `Reframe or re-finalize requirements with verificationSurfaces for ${missingRequirements.join(", ")}.`
+    };
+  }
+  if (missingActual.length) {
+    return {
+      status: "surface_required",
+      nextAction: `Record the actual observation surface for ${missingActual.join(", ")}.`
+    };
+  }
+  if (stale.length) {
+    return {
+      status: "stale",
+      nextAction: `Re-run or confirm evidence against the current subject for ${stale.join(", ")}.`
+    };
+  }
+  if (mismatches.length) {
+    return {
+      status: "surface_mismatch",
+      nextAction: `Record evidence at the required observation surface: ${mismatches.join("; ")}.`
+    };
+  }
+  return { status: "passed", nextAction: "No verification action required." };
+}
+async function inspectManDelivery(root, task) {
+  if (!isManDelivery(task.metadata))
+    throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
+  const bound = await readBoundManPlan(root, task);
+  const subject = await captureManSubject(root, task);
+  const head = await readCheckoutCodeHead(root);
+  const trackedDirty = (await manGit(
+    root,
+    head === null ? ["ls-files", "-z", "--cached"] : ["diff", "--name-only", "--relative", "-z", "HEAD", "--", "."]
+  )).split("\0").filter(Boolean);
+  const untracked = (await manGit(root, ["ls-files", "--others", "--exclude-standard", "-z"])).split("\0").filter(Boolean);
+  const inTask = (file) => file === bound.source.path || manScopeContains(task.metadata, file);
+  const dirtyFiles = [.../* @__PURE__ */ new Set([...trackedDirty, ...untracked])].filter(
+    (file) => !file.startsWith(".mancode/")
+  );
+  const pendingCommit = dirtyFiles.filter(inTask);
+  const outsideScopeDirty = dirtyFiles.filter((file) => !inTask(file));
+  const committedChanges = head === null ? [] : bound.source.baseHead === null ? (await manGit(root, ["ls-tree", "-r", "--name-only", "-z", "HEAD"])).split("\0").filter(Boolean) : (await manGit(root, [
+    "diff",
+    "--name-only",
+    "--relative",
+    "-z",
+    bound.source.baseHead,
+    "HEAD",
+    "--",
+    "."
+  ])).split("\0").filter(Boolean);
+  const outsideScope = committedChanges.filter(
+    (file) => !file.startsWith(".mancode/") && !inTask(file)
+  );
+  const upstream = (await manGit(root, [
+    "for-each-ref",
+    "--format=%(upstream:short)",
+    `refs/heads/${(await manGit(root, ["branch", "--show-current"])).trim()}`
+  ])).trim() || null;
+  const recordCurrent = parseManPlanDocument(bound.document).record === renderManDeliveryRecord(task, subject).trim();
+  return {
+    subject,
+    source: bound.source,
+    pendingCommit,
+    outsideScopeDirty,
+    outsideScope,
+    upstream,
+    publication: upstream === null ? "unpublished" : "unknown",
+    finalization: manDeliveryFinalization(
+      task,
+      subject,
+      recordCurrent,
+      outsideScope,
+      outsideScopeDirty,
+      pendingCommit
+    )
+  };
+}
+async function inspectManPublication(root) {
+  const head = await readCheckoutCodeHead(root);
+  const branch = (await manGit(root, ["branch", "--show-current"])).trim();
+  if (!head || !branch)
+    return { status: "unpublished", reason: "no committed task branch" };
+  const [remote, ref] = (await manGit(root, [
+    "for-each-ref",
+    "--format=%(upstream:remotename)%00%(upstream:remoteref)",
+    `refs/heads/${branch}`
+  ])).trim().split("\0");
+  if (!remote || !ref)
+    return { status: "unpublished", reason: "no upstream configured" };
+  try {
+    const remoteHead = (await manGit(root, ["ls-remote", "--exit-code", "--", remote, ref])).trim().split(/\s+/)[0];
+    if (!remoteHead)
+      return { status: "unpublished", reason: "upstream ref absent" };
+    if (remoteHead === head) return { status: "published", head, remoteHead };
+    try {
+      await manGit(root, ["merge-base", "--is-ancestor", head, remoteHead]);
+      return { status: "published", head, remoteHead };
+    } catch (error) {
+      if (error.code === 1)
+        return {
+          status: "unpublished",
+          head,
+          remoteHead,
+          reason: "upstream does not contain this commit"
+        };
+      throw error;
+    }
+  } catch (error) {
+    return {
+      status: "unverified",
+      reason: "upstream publication could not be verified; no fetch, push or business-state change was performed",
+      diagnostic: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function renderManDeliveryRecord(task, subject) {
+  const reviewStale = subject && task.review.delivery && (task.review.delivery.subject.contentDigest !== subject.contentDigest || task.review.delivery.subject.environment !== subject.environment);
+  const verificationStatus = assessManVerification(task, subject).status;
+  return [
+    `Task: ${task.metadata.taskRef.namespace}:${task.metadata.taskRef.taskId}`,
+    `Plan version: ${task.metadata.governance.planVersion}`,
+    `Review: ${reviewStale ? "stale" : task.review.status}`,
+    `Verification: ${verificationStatus}`,
+    "",
+    ...task.review.delivery ? [
+      `Reviewer declaration: ${task.review.delivery.reviewer}`,
+      `Direction: ${task.review.delivery.direction}`,
+      `Correctness: ${task.review.delivery.correctness}`,
+      `Proportionality: ${task.review.delivery.proportionality}`,
+      `Next: ${task.review.delivery.nextAction}`
+    ] : [
+      "Next: finish relevant verification, then review the complete module."
+    ],
+    ...task.review.blockers.map(
+      (item) => `- ${item.displayId}: ${item.status} \u2014 ${item.summary}`
+    ),
+    ...task.review.delivery?.coverage.map(
+      (row) => `- ${row.acceptanceId}: ${row.status} \u2014 ${row.evidence}`
+    ) ?? [],
+    ...task.verification.checks.map((check) => {
+      const component = (item) => item === null ? "n/a" : `${item.status}(surface=${item.surface ?? "unspecified"})`;
+      return `- ${check.displayId}: automated=${component(check.automated)}; manual=${component(check.manual)}; ${check.automated?.summary ?? check.manual?.summary ?? "No evidence yet."}`;
+    })
+  ].join("\n");
+}
+async function syncManDeliveryRecord(root, task) {
+  const bound = await readBoundManPlan(root, task);
+  if (task.metadata.governance.planDecision === "governed_execution" && !manScopeContains(task.metadata, bound.source.path))
+    assertManPlanInScope(task.metadata, bound.source.path);
+  const subject = await hasGitWorktree(root) ? await captureManSubject(root, task) : void 0;
+  const next = replaceManDeliveryRecord(
+    bound.document,
+    renderManDeliveryRecord(task, subject)
+  );
+  if (scanSharedText(next).some(
+    (finding) => ["authorization", "cookie", "private_key", "secret"].includes(
+      finding.kind
+    )
+  ))
+    throw new Error(
+      "MANCODE_MAN_DOCUMENT_SENSITIVE: redact credential-like text before versioning"
+    );
+  const target = await realpath4(path71.join(root, bound.source.path));
+  if (next !== bound.document) {
+    const temporary = `${target}.${randomUUID4()}.tmp`;
+    try {
+      await writeFile51(temporary, next, {
+        flag: "wx",
+        mode: (await lstat28(target)).mode
+      });
+      if (await readFile48(target, "utf8") !== bound.document)
+        throw new Error("MANCODE_MAN_PLAN_FILE_CHANGED");
+      await replaceFileAtomically(temporary, target);
+    } finally {
+      await rm24(temporary, { force: true });
+    }
+  }
+  let taskId;
+  try {
+    taskId = manProgressTaskId(bound.baseline) ?? `${task.metadata.taskRef.namespace}:${task.metadata.taskRef.taskId}`;
+  } catch (error) {
+    return {
+      status: "manual_sync",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const unresolved = task.requirements.blockingUnknowns.filter(
+    (item) => item.status === "open"
+  );
+  const reason = task.metadata.status === "blocked" && unresolved.length ? unresolved.map((item) => item.statement).join("; ") : null;
+  const verified = subject !== void 0 && assessManVerification(task, subject).status === "passed";
+  const reviewed = task.review.status === "skipped" || task.review.status === "passed" && task.review.delivery?.subject.contentDigest === subject?.contentDigest && task.review.delivery?.subject.environment === subject?.environment;
+  const status2 = reason ? "\u963B\u585E" : verified && reviewed ? "\u5DF2\u5B8C\u6210" : verified && task.review.status !== "blocked" ? "\u5F85\u5BA1\u6838" : task.metadata.currentStep >= 5 ? "\u8FDB\u884C\u4E2D" : "\u672A\u5B8C\u6210";
+  return syncManProgressPage(
+    root,
+    taskId,
+    status2,
+    reason,
+    manScopeContains(task.metadata, "\u9879\u76EE\u8FDB\u5EA6.html")
+  );
+}
+async function assertManDeliveryReady(root, task) {
+  if (!isManDelivery(task.metadata)) return;
+  const result2 = await inspectManDelivery(root, task);
+  const blocker = (code) => result2.finalization.blockers.find((item) => item.code === code);
+  const plan = blocker("plan_execution_required");
+  if (plan)
+    throw new Error(
+      `MANCODE_MAN_DELIVERY_EXECUTION_REQUIRED: ${plan.nextAction}`
+    );
+  const verification = blocker("verification_incomplete");
+  if (verification)
+    throw new Error(
+      `MANCODE_MAN_VERIFICATION_INCOMPLETE: ${verification.status}; ${verification.nextAction}`
+    );
+  const review = blocker("review_incomplete");
+  if (review)
+    throw new Error(
+      `MANCODE_MAN_REVIEW_INCOMPLETE: ${review.status}; ${review.nextAction}`
+    );
+  assertManReviewCoverage(task, task.review, result2.subject);
+  assertManVerificationSubjects(task, task.verification, result2.subject);
+  if (blocker("delivery_record_stale"))
+    throw new Error("MANCODE_MAN_DELIVERY_RECORD_STALE");
+  const outside = blocker("committed_outside_scope");
+  if (outside)
+    throw new Error(
+      `MANCODE_MAN_COMMIT_OUTSIDE_SCOPE: ${outside.files?.join(", ")}`
+    );
+  const outsideDirty = blocker("uncommitted_outside_scope");
+  if (outsideDirty)
+    throw new Error(
+      `MANCODE_MAN_UNCOMMITTED_OUTSIDE_SCOPE: ${outsideDirty.files?.join(", ")}`
+    );
+  const pending = blocker("uncommitted_changes");
+  if (pending)
+    throw new Error(
+      `MANCODE_MAN_DELIVERY_UNCOMMITTED: ${pending.files?.join(", ")}`
+    );
+}
+
 // src/context/scope-change.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 async function changeV3WorkflowScope(input) {
   const taskRef = parseTaskRefValue(input.taskRef);
   if (taskRef.namespace !== "shared") {
@@ -42741,7 +44258,7 @@ function scopeSuccessorClaimId(operationId, predecessorClaimId, timestamp4) {
   if (Number.isNaN(milliseconds)) {
     throw new Error("MANCODE_SCOPE_TIMESTAMP_INVALID");
   }
-  const entropy = createHash11("sha256").update(`scope-change:${operationId}:${predecessorClaimId}`, "utf8").digest().subarray(0, 10);
+  const entropy = createHash12("sha256").update(`scope-change:${operationId}:${predecessorClaimId}`, "utf8").digest().subarray(0, 10);
   return createUlid(milliseconds, entropy);
 }
 function requireCodeHead3(context) {
@@ -42760,7 +44277,7 @@ function compareUtf815(left, right) {
 // src/context/plan-revision.ts
 async function reviseV3Plan(input) {
   const taskRef = parseTaskRefValue(input.taskRef);
-  const plan = requirePlan(input.plan);
+  let plan = requirePlan(input.plan);
   const planDecision = parsePlanDecision(input.planDecision);
   const submittedScope = input.implementationScope === void 0 ? null : normalizeImplementationScope(input.implementationScope);
   if (taskRef.namespace === "shared") {
@@ -42777,6 +44294,21 @@ async function reviseV3Plan(input) {
   });
   let journal = null;
   try {
+    if (isManDelivery(context.task.metadata)) {
+      if (input.planSource) {
+        plan = await bindManPlan(
+          input.projectRoot,
+          input.planSource,
+          plan,
+          context.task.plan?.content ?? null
+        );
+      } else {
+        await readBoundManPlan(input.projectRoot, context.task);
+        if (plan !== context.task.plan?.content)
+          throw new Error("MANCODE_MAN_PLAN_SOURCE_REQUIRED");
+      }
+    } else if (input.planSource)
+      throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
     const planChanged = context.task.plan?.content !== plan;
     const executionScopeBinding = assertExecutionScopeBindingAttempt({
       metadata: context.task.metadata,
@@ -42795,6 +44327,17 @@ async function reviseV3Plan(input) {
     const scopeChanged = submittedScope !== null && submittedScope.digest !== context.task.metadata.implementationScope.digest;
     if (planDecision === "governed_execution") {
       assertExecutableImplementationScope(implementationScope);
+      if (isManDelivery(context.task.metadata)) {
+        const source = parseManDeliveryPlan(plan)?.source;
+        if (!source)
+          throw new Error(
+            "MANCODE_MAN_PLAN_OUTSIDE_SCOPE: bound plan source path is missing; provide a repo-relative plan path"
+          );
+        assertManPlanInScope(
+          { ...context.task.metadata, implementationScope },
+          source.path
+        );
+      }
     }
     if (executionScopeBinding) {
       assertExecutableImplementationScope(implementationScope);
@@ -43110,6 +44653,10 @@ async function reframeV3Workflow(input) {
   try {
     assertReframeEligible(context, activeClaims2, openHandoffs, activeChildren);
     assertReframeClaimsFresh(context, activeClaims2);
+    await assertTaskCheckpointIdAvailableAtRoot(
+      context.task.location.taskRoot,
+      input.checkpointId
+    );
     const timestamp4 = context.now.toISOString();
     const archivedRequirementsContent = await readTaskAuthorityFileAtRoot(
       context.task.location.taskRoot,
@@ -43681,6 +45228,9 @@ async function writeV3Requirements(input, action) {
   let journal = null;
   try {
     assertRequirementsFinalizeEligible(context.task.metadata);
+    if (action === "finalize" && context.task.metadata.workflowMode === "man" && context.task.metadata.governance.policyVersions.planning === 3 && context.task.metadata.governance.planDecision !== "solo_handoff") {
+      assertManDeliveryVerificationSurfaces(submitted);
+    }
     const timestamp4 = context.now.toISOString();
     const requirements = createReplacementRequirements(
       context.task.requirements,
@@ -43901,6 +45451,12 @@ async function applyV3ReviewLedger(input) {
   });
   let journal = null;
   try {
+    const subject = isManDelivery(context.task.metadata) ? await captureManSubject(input.projectRoot, context.task) : null;
+    assertManReviewCoverage(
+      context.task,
+      submitted,
+      subject ?? { contentDigest: "", environment: "" }
+    );
     assertReviewEligible(context.task.metadata, context.task.plan !== null);
     const timestamp4 = context.now.toISOString();
     const review = createCurrentReview(
@@ -43910,11 +45466,34 @@ async function applyV3ReviewLedger(input) {
       context.operationId,
       timestamp4
     );
-    const verification = markTaskVerificationStale(
+    let verification = markTaskVerificationStale(
       context.task.verification,
       context.operationId,
       timestamp4
     );
+    const previous = context.task.verification;
+    if (subject && previous.requirementsDigest === context.task.metadata.governance.requirementsDigest && previous.planVersion === context.task.metadata.governance.planVersion && previous.checks.every(
+      (check) => [check.automated, check.manual].every(
+        (item) => item?.status !== "passed" || item.subject?.contentDigest === subject.contentDigest && item.subject.environment === subject.environment
+      )
+    )) {
+      const current = {
+        ...previous,
+        revision: previous.revision + 1,
+        remediationRound: review.remediationRound,
+        lastOperationId: context.operationId,
+        updatedAt: timestamp4
+      };
+      const draft = {
+        ...current,
+        status: deriveVerificationLedgerStatus(current)
+      };
+      verification = parseVerificationLedger({
+        ...draft,
+        contentDigest: verificationLedgerDigest(draft)
+      });
+      assertVerificationLedgerTransition(previous, verification);
+    }
     const metadata = updateMetadata3(
       context.task.metadata,
       review,
@@ -44495,6 +46074,7 @@ async function completeV3Task(input) {
       throw new Error("MANCODE_GIT_REF_TRANSPORT_NOT_IMPLEMENTED");
     }
     const activeChildren = await context.store.listActiveChildTaskRefs(taskRef);
+    await assertManDeliveryReady(input.projectRoot, context.task);
     assertTaskCompletionGate(
       {
         metadata: context.task.metadata,
@@ -44816,6 +46396,12 @@ async function recordV3Verification(input) {
   });
   let journal = null;
   try {
+    const subject = isManDelivery(context.task.metadata) ? await captureManSubject(input.projectRoot, context.task) : null;
+    assertManVerificationSubjects(
+      context.task,
+      submitted,
+      subject ?? { contentDigest: "", environment: "" }
+    );
     assertVerificationEligible(
       context.task.metadata,
       context.task.plan !== null
@@ -44828,7 +46414,12 @@ async function recordV3Verification(input) {
       context.task.review.remediationRound,
       context.task.requirements,
       context.operationId,
-      timestamp4
+      timestamp4,
+      subject !== null && context.task.verification.checks.some(
+        (check) => [check.automated, check.manual].some(
+          (item) => item?.status === "passed" && (item.subject?.contentDigest !== subject.contentDigest || item.subject.environment !== subject.environment)
+        )
+      )
     );
     const metadata = updateMetadata4(
       context.task.metadata,
@@ -44938,7 +46529,7 @@ function assertVerificationEligible(metadata, hasPlan) {
     throw new Error("MANCODE_VERIFICATION_PLAN_GATE_REQUIRED");
   }
 }
-function createCurrentVerification(previous, submitted, metadata, remediationRound, requirements, operationId, updatedAt) {
+function createCurrentVerification(previous, submitted, metadata, remediationRound, requirements, operationId, updatedAt, contentInvalidated) {
   if (submitted.requirementsDigest !== metadata.governance.requirementsDigest || submitted.planVersion !== metadata.governance.planVersion || submitted.remediationRound !== remediationRound) {
     throw new Error("MANCODE_VERIFICATION_CONTEXT_STALE");
   }
@@ -44957,7 +46548,7 @@ function createCurrentVerification(previous, submitted, metadata, remediationRou
     },
     requirements
   );
-  assertVerificationLedgerTransition(previous, next);
+  assertVerificationLedgerTransition(previous, next, contentInvalidated);
   assertVerificationLedgerRequirements(next, requirements);
   assertVerificationLedgerAgainstContext(next, {
     requirementsDigest: metadata.governance.requirementsDigest,
@@ -44985,14 +46576,14 @@ function updateMetadata4(previous, verification, operationId, updatedAt) {
 
 // src/context/workflow-create.ts
 import {
-  lstat as lstat27,
+  lstat as lstat29,
   mkdir as mkdir41,
-  readFile as readFile47,
+  readFile as readFile49,
   rename as rename15,
-  rm as rm23,
-  writeFile as writeFile50
+  rm as rm25,
+  writeFile as writeFile52
 } from "fs/promises";
-import path69 from "path";
+import path72 from "path";
 
 // src/context/creation-resolution.ts
 function resolveWorkflowCreation(request) {
@@ -45102,13 +46693,16 @@ function rejectConflict(provided, expected, label) {
 
 // src/context/workflow-create.ts
 async function createV3Workflow(input) {
-  const projectRoot = path69.resolve(requireProjectRoot2(input.projectRoot));
+  const projectRoot = path72.resolve(requireProjectRoot2(input.projectRoot));
   const task = requireText2(input.task, "workflow task");
   const client = requireText2(input.client, "workflow client");
   const now = input.now ?? /* @__PURE__ */ new Date();
   const timestamp4 = now.toISOString();
   assertUlid(input.sessionId, "workflow sessionId");
   const workflowMode = parseWorkflowMode(input.workflowMode);
+  if (input.delivery && (workflowMode !== "man" || input.parentTaskRef)) {
+    throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
+  }
   const session = await readSession(projectRoot, input.sessionId);
   if (session === null || session.status !== "active") {
     throw new Error("MANCODE_SESSION_NOT_FOUND");
@@ -45189,7 +46783,7 @@ async function createV3Workflow(input) {
     explicitScope: input.implementationScope,
     ownershipEpoch: taskRef.namespace === "shared" && project.config.transport.mode === "git-ref" ? 0 : 1,
     timestamp: timestamp4,
-    planningPolicyVersion: parent === null ? project.manifest.manifestVersion === 2 && workflowMode === "man" ? project.manifest.workflowPolicyDefaults.planning : 1 : parent.metadata.governance.policyVersions.planning
+    planningPolicyVersion: input.delivery ? 3 : parent === null ? project.manifest.manifestVersion === 2 && workflowMode === "man" ? project.manifest.workflowPolicyDefaults.planning : 1 : parent.metadata.governance.policyVersions.planning === 3 ? 2 : parent.metadata.governance.policyVersions.planning
   });
   const homeStore = resolveTaskEntityHomeStore(
     runtime.entityHomeStoreContext,
@@ -45287,8 +46881,8 @@ async function createV3Workflow(input) {
       throw new Error("MANCODE_REVISION_CONFLICT");
     }
     const taskParent = await ensureSafeTaskParent3(projectRoot, taskRef);
-    const targetDirectory = path69.join(taskParent, taskRef.taskId);
-    stagingDirectory = path69.join(
+    const targetDirectory = path72.join(taskParent, taskRef.taskId);
+    stagingDirectory = path72.join(
       taskParent,
       `.${taskRef.taskId}.${operationId}.staging`
     );
@@ -45746,7 +47340,7 @@ async function ensureSafeTaskParent3(projectRoot, taskRef) {
   const segments = [".mancode", taskRef.namespace, "workflows"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = path69.join(current, segment);
+    current = path72.join(current, segment);
     const existing = await lstatOrNull5(current);
     if (existing === null) {
       await mkdir41(current);
@@ -45782,13 +47376,13 @@ async function writeStagedEntities(stagingDirectory, entities) {
 }
 async function writeStagedJson(stagingDirectory, fileName, value) {
   await assertDirectory(stagingDirectory);
-  const target = path69.join(stagingDirectory, fileName);
-  await writeFile50(target, `${JSON.stringify(value, null, 2)}
+  const target = path72.join(stagingDirectory, fileName);
+  await writeFile52(target, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
   });
-  const entry = await lstat27(target);
+  const entry = await lstat29(target);
   if (!entry.isFile() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -45820,13 +47414,13 @@ async function validateStagedEntities(stagingDirectory) {
   });
 }
 async function readStagedJson(stagingDirectory, fileName, parser) {
-  const target = path69.join(stagingDirectory, fileName);
-  const before = await lstat27(target);
+  const target = path72.join(stagingDirectory, fileName);
+  const before = await lstat29(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const parsed = parser(JSON.parse(await readFile47(target, "utf8")));
-  const after = await lstat27(target);
+  const parsed = parser(JSON.parse(await readFile49(target, "utf8")));
+  const after = await lstat29(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -45917,18 +47511,18 @@ async function abortPreparedCreate(store, journal, stagingDirectory, now) {
       { canAbort: true }
     );
   } finally {
-    await rm23(stagingDirectory, { recursive: true, force: true });
+    await rm25(stagingDirectory, { recursive: true, force: true });
   }
 }
 async function assertDirectory(target) {
-  const entry = await lstat27(target);
+  const entry = await lstat29(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function lstatOrNull5(target) {
   try {
-    return await lstat27(target);
+    return await lstat29(target);
   } catch (error) {
     if (isNotFound34(error)) return null;
     throw error;
@@ -46261,6 +47855,7 @@ async function completeGitRefTask(input) {
   try {
     assertNoPendingHandoff(opened.manifest, taskRef);
     assertCompletionOutcome2(opened.context.task.metadata, input.outcome);
+    await assertManDeliveryReady(input.projectRoot, opened.context.task);
     const activeClaims2 = activeRemoteClaims(opened.manifest, taskRef);
     const activeChildren = await opened.context.store.listActiveChildTaskRefs(taskRef);
     assertTaskCompletionGate(
@@ -46870,6 +48465,360 @@ function compareUtf817(left, right) {
   return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
 }
 
+// src/commands/man-delivery.ts
+import { execFile as execFileCallback8 } from "child_process";
+import { readFile as readFile50 } from "fs/promises";
+import path73 from "path";
+import { promisify as promisify10 } from "util";
+var execFile11 = promisify10(execFileCallback8);
+async function manDeliveryCommand(root, args, options) {
+  try {
+    const [ref, action] = args;
+    if (!ref || args.length !== 2 || ![
+      "inspect",
+      "check",
+      "publication",
+      "sync",
+      "verify",
+      "confirm",
+      "review"
+    ].includes(action ?? "")) {
+      throw new Error(
+        "MANCODE_MAN_DELIVERY_ARGUMENT_INVALID: delivery <TaskRef> <inspect|check|publication|sync|verify|confirm|review>"
+      );
+    }
+    const project = await readV3CommandProject(root);
+    const taskRef = parseTaskRef(ref);
+    let task = await project.store.readTaskSnapshot(taskRef);
+    if (!isManDelivery(task.metadata))
+      throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
+    if (action === "publication")
+      return printV3Result(
+        options.json,
+        await inspectManPublication(project.projectRoot)
+      );
+    if (action === "inspect")
+      return printV3Result(options.json, {
+        ...await inspectManDelivery(project.projectRoot, task),
+        acceptanceCriteria: task.requirements.acceptanceCriteria,
+        review: task.review,
+        verification: task.verification
+      });
+    if (action === "check") {
+      await assertManDeliveryReady(project.projectRoot, task);
+      assertTaskCompletionGate(
+        { ...task, planDigest: task.plan?.digest ?? null },
+        {
+          activeChildTaskRefs: await project.store.listActiveChildTaskRefs(taskRef),
+          hasPendingRepairOperation: false,
+          activeClaimCount: 0
+        }
+      );
+      return printV3Result(options.json, {
+        delivery: "ready_for_complete",
+        publication: "not_checked",
+        note: "complete rechecks operation authority; upstream publication requires an actual push result"
+      });
+    }
+    const expectedTaskRevision = Number(options.expectedRevision);
+    if (!Number.isSafeInteger(expectedTaskRevision) || expectedTaskRevision < 1)
+      throw new Error("MANCODE_EXPECTED_REVISION_REQUIRED");
+    if (options.sync) throw new Error("MANCODE_GIT_REF_DEFERRED_SYNC_REQUIRED");
+    const session = await resolveV3CommandSession(project, options);
+    const context = await openV3TaskOperation({
+      projectRoot: project.projectRoot,
+      taskRef,
+      sessionId: session.sessionId,
+      expectedTaskRevision
+    });
+    const actorId = context.session.actorId;
+    try {
+      task = context.task;
+      if (action === "sync") {
+        const progress = await syncManDeliveryRecord(project.projectRoot, task);
+        const synced = await project.store.readTaskSnapshot(taskRef);
+        const finalization2 = await inspectFinalization(
+          project.projectRoot,
+          synced
+        );
+        return printV3Result(options.json, {
+          deliveryRecord: "synced",
+          progress,
+          revision: synced.metadata.revision,
+          finalization: finalization2
+        });
+      }
+      if (task.metadata.governance.planDecision !== "governed_execution" || task.metadata.currentStep < 5 || task.metadata.status !== "in_progress") {
+        throw new Error("MANCODE_MAN_DELIVERY_EXECUTION_REQUIRED");
+      }
+    } finally {
+      await context.release();
+    }
+    if (!options.file) throw new Error("MANCODE_MAN_DELIVERY_INPUT_REQUIRED");
+    const input = JSON.parse(
+      await readFile50(path73.resolve(project.projectRoot, options.file), "utf8")
+    );
+    let output;
+    if (action === "verify" || action === "confirm") {
+      assertRecord(input, "verification command");
+      assertKnownKeys(
+        input,
+        action === "verify" ? ["argv", "surface"] : ["confirmed", "summary", "surface"],
+        "verification command"
+      );
+      if (action === "verify" && (!Array.isArray(input.argv) || !input.argv.length || input.argv.some(
+        (arg) => typeof arg !== "string" || arg.includes("\0")
+      ) || !input.argv[0]))
+        throw new Error("MANCODE_MAN_VERIFY_ARGV_INVALID");
+      if (action === "confirm" && (input.confirmed !== true || typeof input.summary !== "string" || !input.summary.trim()))
+        throw new Error("MANCODE_MAN_EXPLICIT_CONFIRMATION_REQUIRED");
+      const surface = parseManVerificationSurface(input.surface);
+      const checks = verificationChecks(task);
+      const acceptanceIds = options.acceptance?.split(",").map((id) => id.trim()) ?? [];
+      const component = action === "verify" ? "automated" : "manual";
+      if (!acceptanceIds.length || new Set(acceptanceIds).size !== acceptanceIds.length || acceptanceIds.some(
+        (id) => !checks.some(
+          (check) => check.displayId === id && check[component] !== null
+        )
+      ))
+        throw new Error("MANCODE_MAN_ACCEPTANCE_SLOT_REQUIRED");
+      const subject = await captureManSubject(project.projectRoot, task);
+      let result2 = {
+        stdout: "",
+        stderr: "",
+        exitCode: 0
+      };
+      if (action === "verify") {
+        const argv = input.argv;
+        try {
+          const run = await execFile11(argv[0], argv.slice(1), {
+            cwd: project.projectRoot,
+            encoding: "utf8",
+            maxBuffer: 8 * 1024 * 1024
+          });
+          result2 = { ...run, exitCode: 0 };
+        } catch (error) {
+          const failed = error;
+          if (typeof failed.code !== "number") throw error;
+          result2 = {
+            exitCode: failed.code,
+            stdout: failed.stdout ?? "",
+            stderr: failed.stderr ?? ""
+          };
+        }
+      }
+      if ((await captureManSubject(project.projectRoot, task)).contentDigest !== subject.contentDigest)
+        throw new Error("MANCODE_MAN_VERIFICATION_CHANGED_DURING_RUN");
+      const timestamp4 = (/* @__PURE__ */ new Date()).toISOString();
+      const invalidate = (evidence) => {
+        if (!evidence || evidence.subject?.contentDigest === subject.contentDigest && evidence.subject.environment === subject.environment)
+          return evidence;
+        const {
+          subject: _oldSubject,
+          surface: _oldSurface,
+          ...rest
+        } = evidence;
+        return {
+          ...rest,
+          status: "pending",
+          summary: null,
+          command: null,
+          exitCode: null,
+          artifactRef: null,
+          confirmedByActorId: null,
+          confirmationSource: null,
+          updatedAt: timestamp4
+        };
+      };
+      const draft = {
+        ...task.verification,
+        requirementsDigest: task.requirements.contentDigest,
+        planVersion: task.metadata.governance.planVersion,
+        remediationRound: task.review.remediationRound,
+        checks: checks.map((item) => {
+          const next = {
+            ...item,
+            automated: invalidate(item.automated),
+            manual: invalidate(item.manual)
+          };
+          const slot = item[component];
+          if (acceptanceIds.includes(item.displayId) && slot)
+            next[component] = {
+              ...slot,
+              subject,
+              surface,
+              status: result2.exitCode === 0 ? "passed" : "failed",
+              command: action === "verify" ? JSON.stringify(input.argv) : null,
+              exitCode: action === "verify" ? result2.exitCode : null,
+              summary: action === "verify" ? `Executed argv in project root; captured exit code ${result2.exitCode}.` : input.summary,
+              confirmedByActorId: action === "confirm" ? actorId : null,
+              confirmationSource: action === "confirm" ? "actor" : null,
+              updatedAt: timestamp4
+            };
+          return next;
+        })
+      };
+      const current = {
+        ...draft,
+        status: deriveVerificationLedgerStatus(draft)
+      };
+      output = {
+        ...await recordV3Verification({
+          projectRoot: project.projectRoot,
+          taskRef,
+          sessionId: session.sessionId,
+          expectedTaskRevision,
+          verification: {
+            ...current,
+            contentDigest: verificationLedgerDigest(current)
+          }
+        }),
+        ...action === "verify" ? { commandResult: result2 } : { manualConfirmation: { actorId, summary: input.summary } }
+      };
+    } else {
+      output = await applyV3ReviewLedger({
+        projectRoot: project.projectRoot,
+        taskRef,
+        sessionId: session.sessionId,
+        expectedTaskRevision,
+        review: reviewInput(task, input, options.reviewDepth)
+      });
+    }
+    const updated = await project.store.readTaskSnapshot(taskRef);
+    let deliveryRecord = { status: "synced" };
+    try {
+      deliveryRecord.progress = await syncManDeliveryRecord(
+        project.projectRoot,
+        updated
+      );
+    } catch (error) {
+      deliveryRecord = {
+        status: "pending",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const finalization = await inspectFinalization(
+      project.projectRoot,
+      updated
+    );
+    return printV3Result(options.json, {
+      result: output,
+      deliveryRecord,
+      revision: updated.metadata.revision,
+      finalization
+    });
+  } catch (error) {
+    return printV3Error(
+      options.json,
+      v3ErrorCode(error, "MANCODE_MAN_DELIVERY_FAILED"),
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function inspectFinalization(root, task) {
+  try {
+    return (await inspectManDelivery(root, task)).finalization;
+  } catch (error) {
+    return manInspectionFailureFinalization(error);
+  }
+}
+function verificationChecks(task) {
+  const emptySlot = () => ({
+    evidenceId: createUlid(),
+    status: "pending",
+    summary: null,
+    command: null,
+    exitCode: null,
+    artifactRef: null,
+    confirmedByActorId: null,
+    confirmationSource: null,
+    updatedAt: null
+  });
+  return task.requirements.acceptanceCriteria.map((criterion) => {
+    const previous = task.verification.checks.find(
+      (check) => check.criterionId === criterion.criterionId && check.verificationRequirement === criterion.verificationRequirement
+    );
+    return previous ?? {
+      displayId: criterion.displayId,
+      legacyId: criterion.legacyId,
+      checkId: createUlid(),
+      criterionId: criterion.criterionId,
+      required: criterion.required,
+      verificationRequirement: criterion.verificationRequirement,
+      automated: criterion.verificationRequirement === "manual" ? null : emptySlot(),
+      manual: criterion.verificationRequirement === "automated" ? null : emptySlot()
+    };
+  });
+}
+function reviewInput(task, input, depth) {
+  assertRecord(input, "module review");
+  const { findings = [], resolved = [], ...report } = input;
+  const delivery = parseManReviewEvidence(report);
+  if (!Array.isArray(findings) || !Array.isArray(resolved) || resolved.some((id) => typeof id !== "string"))
+    throw new Error("MANCODE_MAN_REVIEW_FINDINGS_INVALID");
+  if (resolved.some(
+    (id) => !task.review.blockers.some((blocker) => blocker.displayId === id)
+  ))
+    throw new Error("MANCODE_MAN_REVIEW_UNKNOWN_FINDING");
+  const blockers = task.review.blockers.map(
+    (blocker) => resolved.includes(blocker.displayId) ? { ...blocker, status: "resolved" } : blocker
+  );
+  const ids = /* @__PURE__ */ new Set();
+  for (const finding of findings) {
+    assertRecord(finding, "module review finding");
+    assertKnownKeys(
+      finding,
+      ["id", "domain", "severity", "summary"],
+      "module review finding"
+    );
+    if (typeof finding.id !== "string" || !finding.id.trim() || ids.has(finding.id) || typeof finding.summary !== "string" || !finding.summary.trim() || finding.domain !== "quality" && finding.domain !== "security" || !["p0", "p1", "p2"].includes(String(finding.severity)))
+      throw new Error("MANCODE_MAN_REVIEW_FINDINGS_INVALID");
+    ids.add(finding.id);
+    const previous = blockers.find((item) => item.displayId === finding.id);
+    const entry = {
+      displayId: finding.id,
+      legacyId: null,
+      blockerId: previous?.blockerId ?? createUlid(),
+      domain: finding.domain,
+      severity: finding.severity,
+      status: "open",
+      summary: finding.summary,
+      waiver: null
+    };
+    if (previous) blockers[blockers.indexOf(previous)] = entry;
+    else blockers.push(entry);
+  }
+  if (depth !== void 0 && depth !== "targeted" && depth !== "full")
+    throw new Error("MANCODE_MAN_REVIEW_DEPTH_INVALID");
+  const full = depth === "full" || task.review.depth === "full" || blockers.some((item) => item.domain === "security");
+  const requiredDomains = full ? ["quality", "security"] : ["quality"];
+  const covered = task.requirements.acceptanceCriteria.filter((item) => item.required).every(
+    (criterion) => delivery.coverage.some(
+      (row) => row.acceptanceId === criterion.displayId && row.status === "met"
+    )
+  );
+  const draft = {
+    ...task.review,
+    delivery,
+    depth: full ? "full" : "targeted",
+    requiredDomains: [...requiredDomains],
+    requirementsDigest: task.requirements.contentDigest,
+    planVersion: task.metadata.governance.planVersion,
+    domains: requiredDomains.map((domain) => ({
+      domain,
+      status: blockers.some(
+        (item) => item.domain === domain && item.status === "open"
+      ) || !covered ? "blocked" : "passed",
+      reportRef: null
+    })),
+    blockers,
+    skip: null,
+    remediationRound: task.review.remediationRound + (resolved.length ? 1 : 0)
+  };
+  const current = { ...draft, status: deriveReviewLedgerStatus(draft) };
+  return { ...current, contentDigest: reviewLedgerDigest(current) };
+}
+
 // src/commands/requirements-input.ts
 function normalizeRequirementsInput(value, requestedTaskRef, now = /* @__PURE__ */ new Date(), options = {}) {
   if (isRecord14(value) && "schemaVersion" in value) {
@@ -46921,7 +48870,8 @@ function buildCanonicalRequirements(semantic, requestedTaskRef, now) {
       requirementIds: [],
       statement: item.description,
       required: item.required,
-      verificationRequirement: item.method
+      verificationRequirement: item.method,
+      ...item.verificationSurfaces === void 0 ? {} : { verificationSurfaces: item.verificationSurfaces }
     })),
     blockingUnknowns: semantic.blockingUnknowns.map((statement, index) => ({
       displayId: `U-${index + 1}`,
@@ -46953,7 +48903,14 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
   if (v3Activation === "v3_active") {
     return workflowV3(rootDir, subcommand, args, options);
   }
-  if (!await pathExists16(path70.join(rootDir, ".mancode", "state.json"))) {
+  if (options.delivery || subcommand === "delivery") {
+    return printV3Error(
+      options.json,
+      "MANCODE_MAN_DELIVERY_REQUIRES_CONTINUITY",
+      "Man delivery requires Continuity; legacy workflows are unchanged."
+    );
+  }
+  if (!await pathExists16(path74.join(rootDir, ".mancode", "state.json"))) {
     if (v3Activation !== null) {
       return printV3Error(
         options.json,
@@ -47009,6 +48966,7 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
   }
 }
 var WORKFLOW_V3_HANDLERS = {
+  delivery: manDeliveryCommand,
   create: workflowCreateV3,
   list: workflowListV3,
   show: workflowShowV3,
@@ -47913,6 +49871,7 @@ async function workflowPlanV3(rootDir, args, options) {
       sessionId: session.sessionId,
       expectedTaskRevision,
       plan,
+      planSource: action === "revise" && isManDelivery((await project.store.readTaskSnapshot(taskRef)).metadata) ? options.file : void 0,
       implementationScope,
       planDecision: parseV3PlanDecision(options.planDecision)
     });
@@ -48036,8 +49995,8 @@ function parseV3ParticipantActorIds(values) {
   return values;
 }
 async function readWorkflowInputFile(projectRoot, value) {
-  const inputPath = path70.isAbsolute(value) ? value : path70.resolve(projectRoot, value);
-  return readFile48(inputPath, "utf8");
+  const inputPath = path74.isAbsolute(value) ? value : path74.resolve(projectRoot, value);
+  return readFile51(inputPath, "utf8");
 }
 async function readWorkflowJsonInputFile(projectRoot, value) {
   return JSON.parse(await readWorkflowInputFile(projectRoot, value));
@@ -48077,6 +50036,7 @@ async function workflowCreateV3(rootDir, args, options) {
       evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     const result2 = await createV3Workflow({
+      delivery: options.delivery,
       projectRoot: project.projectRoot,
       task,
       workflowMode: parsedWorkflowMode,
@@ -48110,7 +50070,7 @@ async function readV3ActivationState2(rootDir) {
   try {
     const manifest = parseSchemaManifest(
       JSON.parse(
-        await readFile48(path70.join(rootDir, ".mancode", "schema.json"), "utf8")
+        await readFile51(path74.join(rootDir, ".mancode", "schema.json"), "utf8")
       )
     );
     return manifest.activationState === "v3_active" ? "v3_active" : "other";
@@ -48155,22 +50115,22 @@ async function workflowRequirements(rootDir, args, options) {
       "requirements can only be finalized for an in-progress man or manteam workflow at step 1 or 2"
     );
   }
-  const workflowPath = path70.join(rootDir, ".mancode", "workflows", taskId);
-  const jsonPath = path70.join(workflowPath, "requirements.json");
-  const markdownPath = path70.join(workflowPath, "requirements.md");
-  const metadataPath3 = path70.join(workflowPath, "metadata.json");
+  const workflowPath = path74.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path74.join(workflowPath, "requirements.json");
+  const markdownPath = path74.join(workflowPath, "requirements.md");
+  const metadataPath3 = path74.join(workflowPath, "metadata.json");
   let originalJson;
   let originalMarkdown;
   let originalMetadata;
   try {
-    const inputPath = path70.isAbsolute(options.file) ? options.file : path70.resolve(rootDir, options.file);
-    const input = await readFile48(inputPath, "utf-8");
+    const inputPath = path74.isAbsolute(options.file) ? options.file : path74.resolve(rootDir, options.file);
+    const input = await readFile51(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
     assertRequirementsScopeConsistent2(requirements);
     [originalJson, originalMarkdown, originalMetadata] = await Promise.all([
       readOptionalText2(jsonPath),
       readOptionalText2(markdownPath),
-      readFile48(metadataPath3, "utf-8")
+      readFile51(metadataPath3, "utf-8")
     ]);
     await writeRequirementsArtifacts(rootDir, taskId, requirements);
     await updateWorkflow(rootDir, taskId, {
@@ -48200,7 +50160,7 @@ async function workflowRequirements(rootDir, args, options) {
       const rollback = await Promise.allSettled([
         restoreOptionalText(jsonPath, originalJson),
         restoreOptionalText(markdownPath, originalMarkdown),
-        writeFile51(metadataPath3, originalMetadata, "utf-8")
+        writeFile53(metadataPath3, originalMetadata, "utf-8")
       ]);
       rollbackIncomplete = rollback.some(
         (result2) => result2.status === "rejected"
@@ -48288,7 +50248,7 @@ async function workflowVerify(rootDir, args, options) {
             );
           }
           if (options.evidenceFile) {
-            const evidencePath = path70.isAbsolute(options.evidenceFile) ? options.evidenceFile : path70.resolve(rootDir, options.evidenceFile);
+            const evidencePath = path74.isAbsolute(options.evidenceFile) ? options.evidenceFile : path74.resolve(rootDir, options.evidenceFile);
             if (!await pathExists16(evidencePath)) {
               return invalidArg(
                 options,
@@ -48348,17 +50308,17 @@ async function workflowVerify(rootDir, args, options) {
 }
 async function commitVerificationTransition(rootDir, meta, ledger) {
   const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path70.join(
+  const metadataPath3 = path74.join(
     rootDir,
     ".mancode",
     "workflows",
     meta.taskId,
     "metadata.json"
   );
-  const specPath = path70.join(rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path74.join(rootDir, ".mancode", "memory", "spec.md");
   const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile48(metadataPath3, "utf-8"),
+    readFile51(metadataPath3, "utf-8"),
     readOptionalText2(specPath)
   ]);
   const wasVerificationBlocked = meta.status === "blocked" && meta.blockingReason?.startsWith("[verification]");
@@ -48387,7 +50347,7 @@ async function commitVerificationTransition(rootDir, meta, ledger) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile51(metadataPath3, originalMetadata, "utf-8"),
+      writeFile53(metadataPath3, originalMetadata, "utf-8"),
       restoreOptionalText(specPath, originalSpec)
     ]);
     const message = error instanceof Error ? error.message : "verification transition failed";
@@ -48519,7 +50479,7 @@ async function workflowReview(rootDir, args, options) {
 }
 async function commitReviewSkip(rootDir, meta, reason) {
   const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path70.join(
+  const metadataPath3 = path74.join(
     rootDir,
     ".mancode",
     "workflows",
@@ -48528,7 +50488,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   );
   const [originalLedger, originalMetadata] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile48(metadataPath3, "utf-8")
+    readFile51(metadataPath3, "utf-8")
   ]);
   try {
     await initializeSkippedReview(rootDir, meta.taskId, reason);
@@ -48539,7 +50499,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile51(metadataPath3, originalMetadata, "utf-8")
+      writeFile53(metadataPath3, originalMetadata, "utf-8")
     ]);
     const message = error instanceof Error ? error.message : "review skip failed";
     return rollback.some((result2) => result2.status === "rejected") ? `${message}; rollback was incomplete` : message;
@@ -48759,18 +50719,18 @@ async function workflowHandoff(rootDir, taskId, options) {
       "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
     );
   }
-  const workflowPath = path70.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path70.join(workflowPath, "requirements.md")) || !await pathExists16(path70.join(workflowPath, "plan.md"))) {
+  const workflowPath = path74.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path74.join(workflowPath, "requirements.md")) || !await pathExists16(path74.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "solo handoff requires requirements.md and plan.md"
     );
   }
-  const statePath = path70.join(rootDir, ".mancode", "state.json");
+  const statePath = path74.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile48(statePath, "utf-8");
+    originalState = await readFile51(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -48841,11 +50801,11 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
       `workflow is not an active solo handoff: ${taskId}`
     );
   }
-  const statePath = path70.join(rootDir, ".mancode", "state.json");
+  const statePath = path74.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile48(statePath, "utf-8");
+    originalState = await readFile51(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -48908,18 +50868,18 @@ async function workflowDecide(rootDir, taskId, options) {
       `workflow is not ready for a plan-only decision: ${taskId}`
     );
   }
-  const workflowPath = path70.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path70.join(workflowPath, "requirements.md")) || !await pathExists16(path70.join(workflowPath, "plan.md"))) {
+  const workflowPath = path74.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path74.join(workflowPath, "requirements.md")) || !await pathExists16(path74.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "plan-only requires requirements.md and plan.md"
     );
   }
-  const statePath = path70.join(rootDir, ".mancode", "state.json");
+  const statePath = path74.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile48(statePath, "utf-8");
+    originalState = await readFile51(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -48971,25 +50931,25 @@ async function workflowDecide(rootDir, taskId, options) {
   return EXIT_OK11;
 }
 async function commitPlanningTransition(args) {
-  const metadataPath3 = path70.join(
+  const metadataPath3 = path74.join(
     args.rootDir,
     ".mancode",
     "workflows",
     args.taskId,
     "metadata.json"
   );
-  const specPath = path70.join(args.rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path74.join(args.rootDir, ".mancode", "memory", "spec.md");
   let originalMetadata;
   let originalSpec;
   try {
-    originalMetadata = await readFile48(metadataPath3, "utf-8");
+    originalMetadata = await readFile51(metadataPath3, "utf-8");
     originalSpec = await readOptionalText2(specPath);
   } catch (error) {
     return error instanceof Error ? `unable to prepare planning transition: ${error.message}` : "unable to prepare planning transition";
   }
   try {
     await updateWorkflow(args.rootDir, args.taskId, args.workflowPatch);
-    await writeFile51(
+    await writeFile53(
       args.statePath,
       `${JSON.stringify(args.nextState, null, 2)}
 `,
@@ -49003,9 +50963,9 @@ async function commitPlanningTransition(args) {
     return null;
   } catch (error) {
     const rollback = await Promise.allSettled([
-      writeFile51(metadataPath3, originalMetadata, "utf-8"),
-      writeFile51(args.statePath, args.originalState, "utf-8"),
-      originalSpec === null ? rm24(specPath, { force: true }) : writeFile51(specPath, originalSpec, "utf-8")
+      writeFile53(metadataPath3, originalMetadata, "utf-8"),
+      writeFile53(args.statePath, args.originalState, "utf-8"),
+      originalSpec === null ? rm26(specPath, { force: true }) : writeFile53(specPath, originalSpec, "utf-8")
     ]);
     const message = error instanceof Error ? error.message : "planning transition failed";
     return rollback.some((result2) => result2.status === "rejected") ? `${message}; rollback was incomplete` : message;
@@ -49013,7 +50973,7 @@ async function commitPlanningTransition(args) {
 }
 async function readOptionalText2(filePath) {
   try {
-    return await readFile48(filePath, "utf-8");
+    return await readFile51(filePath, "utf-8");
   } catch (error) {
     if (isNodeError11(error) && error.code === "ENOENT") return null;
     throw error;
@@ -49021,10 +50981,10 @@ async function readOptionalText2(filePath) {
 }
 async function restoreOptionalText(filePath, content) {
   if (content === null) {
-    await rm24(filePath, { force: true });
+    await rm26(filePath, { force: true });
     return;
   }
-  await writeFile51(filePath, content, "utf-8");
+  await writeFile53(filePath, content, "utf-8");
 }
 function readActiveSoloPlan(value) {
   if (!value || typeof value !== "object") return null;
@@ -49371,7 +51331,10 @@ Public Continuity subcommands:
   ).option("--to <mode>", "Workflow handoff target (solo)").option("--complete", "Complete an active solo handoff").option(
     "--skipped <steps>",
     "Policy v2: clarification only; use workflow review skip for review"
-  ).option("--review-depth <depth>", "Review depth: targeted or full").option("--review-domain <domain>", "Review domain: quality or security").option(
+  ).option("--review-depth <depth>", "Review depth: targeted or full").option(
+    "--delivery",
+    "Opt in a new man task to document-bound module delivery"
+  ).option("--review-domain <domain>", "Review domain: quality or security").option(
     "--report <path>",
     "Relative Markdown report path for a review domain"
   ).option("--blockers <ids>", "Comma-separated blocker ids found by a review").option(
@@ -49520,7 +51483,10 @@ Public Continuity subcommands:
       options
     );
   });
-  operationProgram.command("repair <operationId>").description("Repair an operation using its original actor and session").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+  operationProgram.command("repair <operationId>").description("Repair an operation using its original actor and session").option(
+    "--replacement-checkpoint-id <id>",
+    "Replace only a conflicted reframe checkpoint target"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
     process.exitCode = await operationRepair(
       process.cwd(),
       operationId,